Panda3D
 All Classes Functions Variables Enumerations
geomVertexColumn.cxx
00001 // Filename: geomVertexColumn.cxx
00002 // Created by:  drose (06Mar05)
00003 //
00004 ////////////////////////////////////////////////////////////////////
00005 //
00006 // PANDA 3D SOFTWARE
00007 // Copyright (c) Carnegie Mellon University.  All rights reserved.
00008 //
00009 // All use of this software is subject to the terms of the revised BSD
00010 // license.  You should have received a copy of this license along
00011 // with this source code in a file named "LICENSE."
00012 //
00013 ////////////////////////////////////////////////////////////////////
00014 
00015 #include "geomVertexColumn.h"
00016 #include "geomVertexData.h"
00017 #include "bamReader.h"
00018 #include "bamWriter.h"
00019 
00020 ////////////////////////////////////////////////////////////////////
00021 //     Function: GeomVertexColumn::Copy Assignment Operator
00022 //       Access: Published
00023 //  Description: 
00024 ////////////////////////////////////////////////////////////////////
00025 void GeomVertexColumn::
00026 operator = (const GeomVertexColumn &copy) {
00027   _name = copy._name;
00028   _num_components = copy._num_components;
00029   _numeric_type = copy._numeric_type;
00030   _contents = copy._contents;
00031   _start = copy._start;
00032   _column_alignment = copy._column_alignment;
00033 
00034   delete _packer;
00035   _packer = NULL;
00036 
00037   setup();
00038 }
00039 
00040 ////////////////////////////////////////////////////////////////////
00041 //     Function: GeomVertexColumn::output
00042 //       Access: Published
00043 //  Description: 
00044 ////////////////////////////////////////////////////////////////////
00045 void GeomVertexColumn::
00046 output(ostream &out) const {
00047   out << *get_name() << "(" << get_num_components();
00048   switch (get_numeric_type()) {
00049   case NT_uint8:
00050     out << "b";
00051     break;
00052 
00053   case NT_uint16:
00054     out << "s";
00055     break;
00056 
00057   case NT_uint32:
00058     out << "l";
00059     break;
00060 
00061   case NT_packed_dcba:
00062     out << "p-";
00063     break;
00064 
00065   case NT_packed_dabc:
00066     out << "p";
00067     break;
00068 
00069   case NT_float32:
00070     out << "f";
00071     break;
00072 
00073   case NT_float64:
00074     out << "d";
00075     break;
00076 
00077   case NT_stdfloat:
00078     out << "?";
00079     break;
00080   }
00081 
00082   out << ")";
00083 }
00084 
00085 ////////////////////////////////////////////////////////////////////
00086 //     Function: GeomVertexColumn::setup
00087 //       Access: Private
00088 //  Description: Called once at construction time (or at bam-reading
00089 //               time) to initialize the internal dependent values.
00090 ////////////////////////////////////////////////////////////////////
00091 void GeomVertexColumn::
00092 setup() {
00093   nassertv(_num_components > 0 && _start >= 0);
00094 
00095   _num_values = _num_components;
00096 
00097   if (_numeric_type == NT_stdfloat) {
00098     if (vertices_float64) {
00099       _numeric_type = NT_float64;
00100     } else {
00101       _numeric_type = NT_float32;
00102     }
00103   }
00104 
00105   switch (_numeric_type) {
00106   case NT_uint16:
00107     _component_bytes = 2;  // sizeof(PN_uint16)
00108     break;
00109 
00110   case NT_uint32:
00111     _component_bytes = 4;  // sizeof(PN_uint32)
00112     break;
00113 
00114   case NT_uint8:
00115     _component_bytes = 1;
00116     break;
00117 
00118   case NT_packed_dcba:
00119   case NT_packed_dabc:
00120     _component_bytes = 4;  // sizeof(PN_uint32)
00121     _num_values *= 4;
00122     break;
00123 
00124   case NT_float32:
00125     _component_bytes = 4;  // sizeof(PN_float32)
00126     break;
00127 
00128   case NT_float64:
00129     _component_bytes = 8;  // sizeof(PN_float64)
00130     break;
00131 
00132   case NT_stdfloat:
00133     nassertv(false);
00134     break;
00135   }
00136 
00137   if (_column_alignment < 1) {
00138     // The default column alignment is to align to the individual
00139     // numeric components, or to vertex_column_alignment, whichever is
00140     // greater.
00141     _column_alignment = max(_component_bytes, (int)vertex_column_alignment);
00142   }
00143 
00144   // Enforce the column alignment requirements on the _start byte.
00145   _start = ((_start + _column_alignment - 1) / _column_alignment) * _column_alignment;
00146 
00147   _total_bytes = _component_bytes * _num_components;
00148 
00149   _packer = make_packer();
00150   _packer->_column = this;
00151 }
00152 
00153 ////////////////////////////////////////////////////////////////////
00154 //     Function: GeomVertexColumn::make_packer
00155 //       Access: Private
00156 //  Description: Returns a newly-allocated Packer object suitable for
00157 //               packing and unpacking this column.  The _column
00158 //               member of the packer is not filled in.
00159 ////////////////////////////////////////////////////////////////////
00160 GeomVertexColumn::Packer *GeomVertexColumn::
00161 make_packer() const {
00162   switch (get_contents()) {
00163   case C_point:
00164   case C_clip_point:
00165   case C_texcoord:
00166     // These types are read as a 4-d homogeneous point.
00167     switch (get_numeric_type()) {
00168     case NT_float32:
00169       if (sizeof(float) == sizeof(PN_float32)) {
00170         // Use the native float type implementation for a tiny bit
00171         // more optimization.
00172         switch (get_num_components()) {
00173         case 2:
00174           return new Packer_point_nativefloat_2;
00175         case 3:
00176           return new Packer_point_nativefloat_3;
00177         case 4:
00178           return new Packer_point_nativefloat_4;
00179         }
00180       } else {
00181         switch (get_num_components()) {
00182         case 2:
00183           return new Packer_point_float32_2;
00184         case 3:
00185           return new Packer_point_float32_3;
00186         case 4:
00187           return new Packer_point_float32_4;
00188         }
00189       }
00190       break;
00191     case NT_float64:
00192       if (sizeof(double) == sizeof(PN_float64)) {
00193         // Use the native float type implementation for a tiny bit
00194         // more optimization.
00195         switch (get_num_components()) {
00196         case 2:
00197           return new Packer_point_nativedouble_2;
00198         case 3:
00199           return new Packer_point_nativedouble_3;
00200         case 4:
00201           return new Packer_point_nativedouble_4;
00202         }
00203       } else {
00204         switch (get_num_components()) {
00205         case 2:
00206           return new Packer_point_float64_2;
00207         case 3:
00208           return new Packer_point_float64_3;
00209         case 4:
00210           return new Packer_point_float64_4;
00211         }
00212       }
00213       break;
00214     default:
00215       break;
00216     }
00217     return new Packer_point;
00218 
00219   case C_color:
00220     switch (get_numeric_type()) {
00221     case NT_uint8:
00222       switch (get_num_components()) {
00223       case 4:
00224         return new Packer_rgba_uint8_4;
00225         
00226       default:
00227         break;
00228       }
00229       break;
00230     case NT_packed_dabc:
00231       switch (get_num_components()) {
00232       case 1:
00233         return new Packer_argb_packed;
00234         
00235       default:
00236         break;
00237       }
00238       break;
00239     case NT_float32:
00240       switch (get_num_components()) {
00241       case 4:
00242         if (sizeof(float) == sizeof(PN_float32)) {
00243           // Use the native float type implementation for a tiny bit
00244           // more optimization.
00245           return new Packer_rgba_nativefloat_4;
00246         } else {
00247           return new Packer_rgba_float32_4;
00248         }
00249         
00250       default:
00251         break;
00252       }
00253       break;
00254     default:
00255       break;
00256     }
00257     return new Packer_color;
00258 
00259   default:
00260     // Otherwise, we just read it as a generic value.
00261     switch (get_numeric_type()) {
00262     case NT_float32:
00263       switch (get_num_components()) {
00264       case 3:
00265         if (sizeof(float) == sizeof(PN_float32)) {
00266           // Use the native float type implementation for a tiny bit
00267           // more optimization.
00268           return new Packer_nativefloat_3;
00269         } else {
00270           return new Packer_float32_3;
00271         }
00272 
00273       default:
00274         break;
00275       }
00276       break;
00277     case NT_float64:
00278       switch (get_num_components()) {
00279       case 3:
00280         if (sizeof(double) == sizeof(PN_float64)) {
00281           // Use the native float type implementation for a tiny bit
00282           // more optimization.
00283           return new Packer_nativedouble_3;
00284         } else {
00285           return new Packer_float64_3;
00286         }
00287 
00288       default:
00289         break;
00290       }
00291       break;
00292     default:
00293       break;
00294     }
00295     return new Packer;
00296   }
00297 }
00298 
00299 ////////////////////////////////////////////////////////////////////
00300 //     Function: GeomVertexColumn::write_datagram
00301 //       Access: Public
00302 //  Description: Writes the contents of this object to the datagram
00303 //               for shipping out to a Bam file.
00304 ////////////////////////////////////////////////////////////////////
00305 void GeomVertexColumn::
00306 write_datagram(BamWriter *manager, Datagram &dg) {
00307   manager->write_pointer(dg, _name);
00308   dg.add_uint8(_num_components);
00309   dg.add_uint8(_numeric_type);
00310   dg.add_uint8(_contents);
00311   dg.add_uint16(_start);
00312   dg.add_uint8(_column_alignment);
00313 }
00314 
00315 ////////////////////////////////////////////////////////////////////
00316 //     Function: GeomVertexColumn::complete_pointers
00317 //       Access: Public
00318 //  Description: Receives an array of pointers, one for each time
00319 //               manager->read_pointer() was called in fillin().
00320 //               Returns the number of pointers processed.
00321 ////////////////////////////////////////////////////////////////////
00322 int GeomVertexColumn::
00323 complete_pointers(TypedWritable **p_list, BamReader *manager) {
00324   int pi = 0;
00325 
00326   _name = DCAST(InternalName, p_list[pi++]);
00327 
00328   return pi;
00329 }
00330 
00331 ////////////////////////////////////////////////////////////////////
00332 //     Function: GeomVertexColumn::fillin
00333 //       Access: Protected
00334 //  Description: This internal function is called by make_from_bam to
00335 //               read in all of the relevant data from the BamFile for
00336 //               the new GeomVertexColumn.
00337 ////////////////////////////////////////////////////////////////////
00338 void GeomVertexColumn::
00339 fillin(DatagramIterator &scan, BamReader *manager) {
00340   manager->read_pointer(scan);
00341 
00342   _num_components = scan.get_uint8();
00343   _numeric_type = (NumericType)scan.get_uint8();
00344   _contents = (Contents)scan.get_uint8();
00345   _start = scan.get_uint16();
00346 
00347   _column_alignment = 1;
00348   if (manager->get_file_minor_ver() >= 29) {
00349     _column_alignment = scan.get_uint8();
00350   }
00351 
00352   setup();
00353 }
00354 
00355 ////////////////////////////////////////////////////////////////////
00356 //     Function: GeomVertexColumn::Packer::Destructor
00357 //       Access: Public, Virtual
00358 //  Description: 
00359 ////////////////////////////////////////////////////////////////////
00360 GeomVertexColumn::Packer::
00361 ~Packer() {
00362 }
00363 
00364 ////////////////////////////////////////////////////////////////////
00365 //     Function: GeomVertexColumn::Packer::get_data1f
00366 //       Access: Public, Virtual
00367 //  Description: 
00368 ////////////////////////////////////////////////////////////////////
00369 float GeomVertexColumn::Packer::
00370 get_data1f(const unsigned char *pointer) {
00371   switch (_column->get_numeric_type()) {
00372   case NT_uint8:
00373     return maybe_scale_color_f(*pointer);
00374 
00375   case NT_uint16:
00376     return *(const PN_uint16 *)pointer;
00377 
00378   case NT_uint32:
00379     return *(const PN_uint32 *)pointer;
00380 
00381   case NT_packed_dcba:
00382     {
00383       PN_uint32 dword = *(const PN_uint32 *)pointer;
00384       return maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword));
00385     }
00386 
00387   case NT_packed_dabc:
00388     {
00389       PN_uint32 dword = *(const PN_uint32 *)pointer;
00390       return maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword));
00391     }
00392 
00393   case NT_float32:
00394     return *(const PN_float32 *)pointer;
00395 
00396   case NT_float64:
00397     return *(const PN_float64 *)pointer;
00398 
00399   default:
00400     nassertr(false, 0.0f);
00401   }
00402 
00403   return 0.0f;
00404 }
00405 
00406 ////////////////////////////////////////////////////////////////////
00407 //     Function: GeomVertexColumn::Packer::get_data2f
00408 //       Access: Public, Virtual
00409 //  Description: 
00410 ////////////////////////////////////////////////////////////////////
00411 const LVecBase2f &GeomVertexColumn::Packer::
00412 get_data2f(const unsigned char *pointer) {
00413   if (_column->get_num_values() == 1) {
00414     _v2.set(get_data1f(pointer), 0.0f);
00415     return _v2;
00416 
00417   } else {
00418     switch (_column->get_numeric_type()) {
00419     case NT_uint8:
00420       maybe_scale_color_f(pointer[0], pointer[1]);
00421       return _v2;
00422       
00423     case NT_uint16:
00424       {
00425         const PN_uint16 *pi = (const PN_uint16 *)pointer;
00426         _v2.set(pi[0], pi[1]);
00427       }
00428       return _v2;
00429       
00430     case NT_uint32:
00431       {
00432         const PN_uint32 *pi = (const PN_uint32 *)pointer;
00433         _v2.set(pi[0], pi[1]);
00434       }
00435       return _v2;
00436       
00437     case NT_packed_dcba:
00438       {
00439         PN_uint32 dword = *(const PN_uint32 *)pointer;
00440         maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
00441                             GeomVertexData::unpack_abcd_c(dword));
00442       }
00443       return _v2;
00444       
00445     case NT_packed_dabc:
00446       {
00447         PN_uint32 dword = *(const PN_uint32 *)pointer;
00448         maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
00449                             GeomVertexData::unpack_abcd_c(dword));
00450       }
00451       return _v2;
00452       
00453     case NT_float32:
00454       {
00455         const PN_float32 *pi = (const PN_float32 *)pointer;
00456         _v2.set(pi[0], pi[1]);
00457       }
00458       return _v2;
00459 
00460     case NT_float64:
00461       {
00462         const PN_float64 *pi = (const PN_float64 *)pointer;
00463         _v2.set(pi[0], pi[1]);
00464       }
00465       return _v2;
00466 
00467     case NT_stdfloat:
00468       nassertr(false, _v2);
00469     }
00470   }
00471 
00472   return _v2;
00473 }
00474 
00475 ////////////////////////////////////////////////////////////////////
00476 //     Function: GeomVertexColumn::Packer::get_data3f
00477 //       Access: Public, Virtual
00478 //  Description: 
00479 ////////////////////////////////////////////////////////////////////
00480 const LVecBase3f &GeomVertexColumn::Packer::
00481 get_data3f(const unsigned char *pointer) {
00482   switch (_column->get_num_values()) {
00483   case 1:
00484     _v3.set(get_data1f(pointer), 0.0f, 0.0f);
00485     return _v3;
00486 
00487   case 2:
00488     {
00489       const LVecBase2f &v2 = get_data2f(pointer);
00490       _v3.set(v2[0], v2[1], 0.0f);
00491     }
00492     return _v3;
00493 
00494   default:
00495     switch (_column->get_numeric_type()) {
00496     case NT_uint8:
00497       maybe_scale_color_f(pointer[0], pointer[1], pointer[2]);
00498       return _v3;
00499       
00500     case NT_uint16:
00501       {
00502         const PN_uint16 *pi = (const PN_uint16 *)pointer;
00503         _v3.set(pi[0], pi[1], pi[2]);
00504       }
00505       return _v3;
00506       
00507     case NT_uint32:
00508       {
00509         const PN_uint32 *pi = (const PN_uint32 *)pointer;
00510         _v3.set(pi[0], pi[1], pi[2]);
00511       }
00512       return _v3;
00513       
00514     case NT_packed_dcba:
00515       {
00516         PN_uint32 dword = *(const PN_uint32 *)pointer;
00517         maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
00518                             GeomVertexData::unpack_abcd_c(dword),
00519                             GeomVertexData::unpack_abcd_b(dword));
00520       }
00521       return _v3;
00522       
00523     case NT_packed_dabc:
00524       {
00525         PN_uint32 dword = *(const PN_uint32 *)pointer;
00526         maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
00527                             GeomVertexData::unpack_abcd_c(dword),
00528                             GeomVertexData::unpack_abcd_d(dword));
00529       }
00530       return _v3;
00531       
00532     case NT_float32:
00533       {
00534         const PN_float32 *pi = (const PN_float32 *)pointer;
00535         _v3.set(pi[0], pi[1], pi[2]);
00536       }
00537       return _v3;
00538       
00539     case NT_float64:
00540       {
00541         const PN_float64 *pi = (const PN_float64 *)pointer;
00542         _v3.set(pi[0], pi[1], pi[2]);
00543       }
00544       return _v3;
00545 
00546     case NT_stdfloat:
00547       nassertr(false, _v3);
00548     }
00549   }
00550 
00551   return _v3;
00552 }
00553 
00554 ////////////////////////////////////////////////////////////////////
00555 //     Function: GeomVertexColumn::Packer::get_data4f
00556 //       Access: Public, Virtual
00557 //  Description: 
00558 ////////////////////////////////////////////////////////////////////
00559 const LVecBase4f &GeomVertexColumn::Packer::
00560 get_data4f(const unsigned char *pointer) {
00561   switch (_column->get_num_values()) {
00562   case 1:
00563     _v4.set(get_data1f(pointer), 0.0f, 0.0f, 0.0f);
00564     return _v4;
00565 
00566   case 2:
00567     {
00568       const LVecBase2f &v2 = get_data2f(pointer);
00569       _v4.set(v2[0], v2[1], 0.0f, 0.0f);
00570     }
00571     return _v4;
00572 
00573   case 3:
00574     {
00575       const LVecBase3f &v3 = get_data3f(pointer);
00576       _v4.set(v3[0], v3[1], v3[2], 0.0f);
00577     }
00578     return _v4;
00579 
00580   default:
00581     switch (_column->get_numeric_type()) {
00582     case NT_uint8:
00583       maybe_scale_color_f(pointer[0], pointer[1], pointer[2], pointer[3]);
00584       return _v4;
00585       
00586     case NT_uint16:
00587       {
00588         const PN_uint16 *pi = (const PN_uint16 *)pointer;
00589         _v4.set(pi[0], pi[1], pi[2], pi[3]);
00590       }
00591       return _v4;
00592       
00593     case NT_uint32:
00594       {
00595         const PN_uint32 *pi = (const PN_uint32 *)pointer;
00596         _v4.set(pi[0], pi[1], pi[2], pi[3]);
00597       }
00598       return _v4;
00599       
00600     case NT_packed_dcba:
00601       {
00602         PN_uint32 dword = *(const PN_uint32 *)pointer;
00603         maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
00604                             GeomVertexData::unpack_abcd_c(dword),
00605                             GeomVertexData::unpack_abcd_b(dword),
00606                             GeomVertexData::unpack_abcd_a(dword));
00607       }
00608       return _v4;
00609       
00610     case NT_packed_dabc:
00611       {
00612         PN_uint32 dword = *(const PN_uint32 *)pointer;
00613         maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
00614                             GeomVertexData::unpack_abcd_c(dword),
00615                             GeomVertexData::unpack_abcd_d(dword),
00616                             GeomVertexData::unpack_abcd_a(dword));
00617       }
00618       return _v4;
00619       
00620     case NT_float32:
00621       {
00622         const PN_float32 *pi = (const PN_float32 *)pointer;
00623         _v4.set(pi[0], pi[1], pi[2], pi[3]);
00624       }
00625       return _v4;
00626       
00627     case NT_float64:
00628       {
00629         const PN_float64 *pi = (const PN_float64 *)pointer;
00630         _v4.set(pi[0], pi[1], pi[2], pi[3]);
00631       }
00632       return _v4;
00633 
00634     case NT_stdfloat:
00635       nassertr(false, _v4);
00636     }
00637   }
00638 
00639   return _v4;
00640 }
00641 
00642 ////////////////////////////////////////////////////////////////////
00643 //     Function: GeomVertexColumn::Packer::get_data1d
00644 //       Access: Public, Virtual
00645 //  Description: 
00646 ////////////////////////////////////////////////////////////////////
00647 double GeomVertexColumn::Packer::
00648 get_data1d(const unsigned char *pointer) {
00649   switch (_column->get_numeric_type()) {
00650   case NT_uint8:
00651     return maybe_scale_color_d(*pointer);
00652 
00653   case NT_uint16:
00654     return *(const PN_uint16 *)pointer;
00655 
00656   case NT_uint32:
00657     return *(const PN_uint32 *)pointer;
00658 
00659   case NT_packed_dcba:
00660     {
00661       PN_uint32 dword = *(const PN_uint32 *)pointer;
00662       return maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword));
00663     }
00664 
00665   case NT_packed_dabc:
00666     {
00667       PN_uint32 dword = *(const PN_uint32 *)pointer;
00668       return maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword));
00669     }
00670 
00671   case NT_float32:
00672     return *(const PN_float32 *)pointer;
00673 
00674   case NT_float64:
00675     return *(const PN_float64 *)pointer;
00676 
00677   case NT_stdfloat:
00678     nassertr(false, 0.0f);
00679   }
00680 
00681   return 0.0f;
00682 }
00683 
00684 ////////////////////////////////////////////////////////////////////
00685 //     Function: GeomVertexColumn::Packer::get_data2d
00686 //       Access: Public, Virtual
00687 //  Description: 
00688 ////////////////////////////////////////////////////////////////////
00689 const LVecBase2d &GeomVertexColumn::Packer::
00690 get_data2d(const unsigned char *pointer) {
00691   if (_column->get_num_values() == 1) {
00692     _v2d.set(get_data1d(pointer), 0.0f);
00693     return _v2d;
00694 
00695   } else {
00696     switch (_column->get_numeric_type()) {
00697     case NT_uint8:
00698       maybe_scale_color_d(pointer[0], pointer[1]);
00699       return _v2d;
00700       
00701     case NT_uint16:
00702       {
00703         const PN_uint16 *pi = (const PN_uint16 *)pointer;
00704         _v2d.set(pi[0], pi[1]);
00705       }
00706       return _v2d;
00707       
00708     case NT_uint32:
00709       {
00710         const PN_uint32 *pi = (const PN_uint32 *)pointer;
00711         _v2d.set(pi[0], pi[1]);
00712       }
00713       return _v2d;
00714       
00715     case NT_packed_dcba:
00716       {
00717         PN_uint32 dword = *(const PN_uint32 *)pointer;
00718         maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
00719                             GeomVertexData::unpack_abcd_c(dword));
00720       }
00721       return _v2d;
00722       
00723     case NT_packed_dabc:
00724       {
00725         PN_uint32 dword = *(const PN_uint32 *)pointer;
00726         maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
00727                             GeomVertexData::unpack_abcd_c(dword));
00728       }
00729       return _v2d;
00730       
00731     case NT_float32:
00732       {
00733         const PN_float32 *pi = (const PN_float32 *)pointer;
00734         _v2d.set(pi[0], pi[1]);
00735       }
00736       return _v2d;
00737 
00738     case NT_float64:
00739       {
00740         const PN_float64 *pi = (const PN_float64 *)pointer;
00741         _v2d.set(pi[0], pi[1]);
00742       }
00743       return _v2d;
00744 
00745     case NT_stdfloat:
00746       nassertr(false, _v2d);
00747     }
00748   }
00749 
00750   return _v2d;
00751 }
00752 
00753 ////////////////////////////////////////////////////////////////////
00754 //     Function: GeomVertexColumn::Packer::get_data3d
00755 //       Access: Public, Virtual
00756 //  Description: 
00757 ////////////////////////////////////////////////////////////////////
00758 const LVecBase3d &GeomVertexColumn::Packer::
00759 get_data3d(const unsigned char *pointer) {
00760   switch (_column->get_num_values()) {
00761   case 1:
00762     _v3d.set(get_data1d(pointer), 0.0f, 0.0f);
00763     return _v3d;
00764 
00765   case 2:
00766     {
00767       const LVecBase2d &v2 = get_data2d(pointer);
00768       _v3d.set(v2[0], v2[1], 0.0f);
00769     }
00770     return _v3d;
00771 
00772   default:
00773     switch (_column->get_numeric_type()) {
00774     case NT_uint8:
00775       maybe_scale_color_d(pointer[0], pointer[1], pointer[2]);
00776       return _v3d;
00777       
00778     case NT_uint16:
00779       {
00780         const PN_uint16 *pi = (const PN_uint16 *)pointer;
00781         _v3d.set(pi[0], pi[1], pi[2]);
00782       }
00783       return _v3d;
00784       
00785     case NT_uint32:
00786       {
00787         const PN_uint32 *pi = (const PN_uint32 *)pointer;
00788         _v3d.set(pi[0], pi[1], pi[2]);
00789       }
00790       return _v3d;
00791       
00792     case NT_packed_dcba:
00793       {
00794         PN_uint32 dword = *(const PN_uint32 *)pointer;
00795         maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
00796                             GeomVertexData::unpack_abcd_c(dword),
00797                             GeomVertexData::unpack_abcd_b(dword));
00798       }
00799       return _v3d;
00800       
00801     case NT_packed_dabc:
00802       {
00803         PN_uint32 dword = *(const PN_uint32 *)pointer;
00804         maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
00805                             GeomVertexData::unpack_abcd_c(dword),
00806                             GeomVertexData::unpack_abcd_d(dword));
00807       }
00808       return _v3d;
00809       
00810     case NT_float32:
00811       {
00812         const PN_float32 *pi = (const PN_float32 *)pointer;
00813         _v3d.set(pi[0], pi[1], pi[2]);
00814       }
00815       return _v3d;
00816       
00817     case NT_float64:
00818       {
00819         const PN_float64 *pi = (const PN_float64 *)pointer;
00820         _v3d.set(pi[0], pi[1], pi[2]);
00821       }
00822       return _v3d;
00823 
00824     case NT_stdfloat:
00825       nassertr(false, _v3d);
00826     }
00827   }
00828 
00829   return _v3d;
00830 }
00831 
00832 ////////////////////////////////////////////////////////////////////
00833 //     Function: GeomVertexColumn::Packer::get_data4d
00834 //       Access: Public, Virtual
00835 //  Description: 
00836 ////////////////////////////////////////////////////////////////////
00837 const LVecBase4d &GeomVertexColumn::Packer::
00838 get_data4d(const unsigned char *pointer) {
00839   switch (_column->get_num_values()) {
00840   case 1:
00841     _v4d.set(get_data1d(pointer), 0.0f, 0.0f, 0.0f);
00842     return _v4d;
00843 
00844   case 2:
00845     {
00846       const LVecBase2d &v2 = get_data2d(pointer);
00847       _v4d.set(v2[0], v2[1], 0.0f, 0.0f);
00848     }
00849     return _v4d;
00850 
00851   case 3:
00852     {
00853       const LVecBase3d &v3 = get_data3d(pointer);
00854       _v4d.set(v3[0], v3[1], v3[2], 0.0f);
00855     }
00856     return _v4d;
00857 
00858   default:
00859     switch (_column->get_numeric_type()) {
00860     case NT_uint8:
00861       maybe_scale_color_d(pointer[0], pointer[1], pointer[2], pointer[3]);
00862       return _v4d;
00863       
00864     case NT_uint16:
00865       {
00866         const PN_uint16 *pi = (const PN_uint16 *)pointer;
00867         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
00868       }
00869       return _v4d;
00870       
00871     case NT_uint32:
00872       {
00873         const PN_uint32 *pi = (const PN_uint32 *)pointer;
00874         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
00875       }
00876       return _v4d;
00877       
00878     case NT_packed_dcba:
00879       {
00880         PN_uint32 dword = *(const PN_uint32 *)pointer;
00881         maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
00882                             GeomVertexData::unpack_abcd_c(dword),
00883                             GeomVertexData::unpack_abcd_b(dword),
00884                             GeomVertexData::unpack_abcd_a(dword));
00885       }
00886       return _v4d;
00887       
00888     case NT_packed_dabc:
00889       {
00890         PN_uint32 dword = *(const PN_uint32 *)pointer;
00891         maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
00892                             GeomVertexData::unpack_abcd_c(dword),
00893                             GeomVertexData::unpack_abcd_d(dword),
00894                             GeomVertexData::unpack_abcd_a(dword));
00895       }
00896       return _v4d;
00897       
00898     case NT_float32:
00899       {
00900         const PN_float32 *pi = (const PN_float32 *)pointer;
00901         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
00902       }
00903       return _v4d;
00904       
00905     case NT_float64:
00906       {
00907         const PN_float64 *pi = (const PN_float64 *)pointer;
00908         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
00909       }
00910       return _v4d;
00911 
00912     case NT_stdfloat:
00913       nassertr(false, _v4d);
00914     }
00915   }
00916 
00917   return _v4d;
00918 }
00919 
00920 ////////////////////////////////////////////////////////////////////
00921 //     Function: GeomVertexColumn::Packer::get_data1i
00922 //       Access: Public, Virtual
00923 //  Description: 
00924 ////////////////////////////////////////////////////////////////////
00925 int GeomVertexColumn::Packer::
00926 get_data1i(const unsigned char *pointer) {
00927   switch (_column->get_numeric_type()) {
00928   case NT_uint8:
00929     return *pointer;
00930 
00931   case NT_uint16:
00932     return *(const PN_uint16 *)pointer;
00933 
00934   case NT_uint32:
00935     return *(const PN_uint32 *)pointer;
00936 
00937   case NT_packed_dcba:
00938     {
00939       PN_uint32 dword = *(const PN_uint32 *)pointer;
00940       return GeomVertexData::unpack_abcd_d(dword);
00941     }
00942 
00943   case NT_packed_dabc:
00944     {
00945       PN_uint32 dword = *(const PN_uint32 *)pointer;
00946       return GeomVertexData::unpack_abcd_b(dword);
00947     }
00948 
00949   case NT_float32:
00950     return (int)*(const PN_float32 *)pointer;
00951 
00952   case NT_float64:
00953     return (int)*(const PN_float64 *)pointer;
00954 
00955   case NT_stdfloat:
00956     nassertr(false, 0);
00957   }
00958 
00959   return 0;
00960 }
00961 
00962 ////////////////////////////////////////////////////////////////////
00963 //     Function: GeomVertexColumn::Packer::get_data2i
00964 //       Access: Public, Virtual
00965 //  Description: 
00966 ////////////////////////////////////////////////////////////////////
00967 const int *GeomVertexColumn::Packer::
00968 get_data2i(const unsigned char *pointer) {
00969   switch (_column->get_num_values()) {
00970   case 1:
00971     _i[0] = get_data1i(pointer);
00972     _i[1] = 0;
00973     return _i;
00974 
00975   default:
00976     switch (_column->get_numeric_type()) {
00977     case NT_uint8:
00978       _i[0] = pointer[0];
00979       _i[1] = pointer[1];
00980       return _i;
00981       
00982     case NT_uint16:
00983       {
00984         const PN_uint16 *pi = (const PN_uint16 *)pointer;
00985         _i[0] = pi[0];
00986         _i[1] = pi[1];
00987       }
00988       return _i;
00989       
00990     case NT_uint32:
00991       {
00992         const PN_uint32 *pi = (const PN_uint32 *)pointer;
00993         _i[0] = pi[0];
00994         _i[1] = pi[1];
00995       }
00996       return _i;
00997       
00998     case NT_packed_dcba:
00999       {
01000         PN_uint32 dword = *(const PN_uint32 *)pointer;
01001         _i[0] = GeomVertexData::unpack_abcd_d(dword);
01002         _i[1] = GeomVertexData::unpack_abcd_c(dword);
01003       }
01004       return _i;
01005       
01006     case NT_packed_dabc:
01007       {
01008         PN_uint32 dword = *(const PN_uint32 *)pointer;
01009         _i[0] = GeomVertexData::unpack_abcd_b(dword);
01010         _i[1] = GeomVertexData::unpack_abcd_c(dword);
01011       }
01012       return _i;
01013       
01014     case NT_float32:
01015       {
01016         const PN_float32 *pi = (const PN_float32 *)pointer;
01017         _i[0] = (int)pi[0];
01018         _i[1] = (int)pi[1];
01019       }
01020       return _i;
01021       
01022     case NT_float64:
01023       {
01024         const PN_float64 *pi = (const PN_float64 *)pointer;
01025         _i[0] = (int)pi[0];
01026         _i[1] = (int)pi[1];
01027       }
01028       return _i;
01029 
01030     case NT_stdfloat:
01031       nassertr(false, _i);
01032     }
01033   }
01034 
01035   return _i;
01036 }
01037 
01038 ////////////////////////////////////////////////////////////////////
01039 //     Function: GeomVertexColumn::Packer::get_data3i
01040 //       Access: Public, Virtual
01041 //  Description: 
01042 ////////////////////////////////////////////////////////////////////
01043 const int *GeomVertexColumn::Packer::
01044 get_data3i(const unsigned char *pointer) {
01045   switch (_column->get_num_values()) {
01046   case 1:
01047     _i[0] = get_data1i(pointer);
01048     _i[1] = 0;
01049     _i[2] = 0;
01050     return _i;
01051 
01052   case 2:
01053     {
01054       const int *i = get_data2i(pointer);
01055       _i[0] = i[0];
01056       _i[1] = i[1];
01057       _i[2] = 0;
01058     }
01059     return _i;
01060 
01061   default:
01062     switch (_column->get_numeric_type()) {
01063     case NT_uint8:
01064       _i[0] = pointer[0];
01065       _i[1] = pointer[1];
01066       _i[2] = pointer[2];
01067       return _i;
01068       
01069     case NT_uint16:
01070       {
01071         const PN_uint16 *pi = (const PN_uint16 *)pointer;
01072         _i[0] = pi[0];
01073         _i[1] = pi[1];
01074         _i[2] = pi[2];
01075       }
01076       return _i;
01077       
01078     case NT_uint32:
01079       {
01080         const PN_uint32 *pi = (const PN_uint32 *)pointer;
01081         _i[0] = pi[0];
01082         _i[1] = pi[1];
01083         _i[2] = pi[2];
01084       }
01085       return _i;
01086       
01087     case NT_packed_dcba:
01088       {
01089         PN_uint32 dword = *(const PN_uint32 *)pointer;
01090         _i[0] = GeomVertexData::unpack_abcd_d(dword);
01091         _i[1] = GeomVertexData::unpack_abcd_c(dword);
01092         _i[2] = GeomVertexData::unpack_abcd_b(dword);
01093       }
01094       return _i;
01095       
01096     case NT_packed_dabc:
01097       {
01098         PN_uint32 dword = *(const PN_uint32 *)pointer;
01099         _i[0] = GeomVertexData::unpack_abcd_b(dword);
01100         _i[1] = GeomVertexData::unpack_abcd_c(dword);
01101         _i[2] = GeomVertexData::unpack_abcd_d(dword);
01102       }
01103       return _i;
01104       
01105     case NT_float32:
01106       {
01107         const PN_float32 *pi = (const PN_float32 *)pointer;
01108         _i[0] = (int)pi[0];
01109         _i[1] = (int)pi[1];
01110         _i[2] = (int)pi[2];
01111       }
01112       return _i;
01113       
01114     case NT_float64:
01115       {
01116         const PN_float64 *pi = (const PN_float64 *)pointer;
01117         _i[0] = (int)pi[0];
01118         _i[1] = (int)pi[1];
01119         _i[2] = (int)pi[2];
01120       }
01121       return _i;
01122 
01123     case NT_stdfloat:
01124       nassertr(false, _i);
01125     }
01126   }
01127 
01128   return _i;
01129 }
01130 
01131 ////////////////////////////////////////////////////////////////////
01132 //     Function: GeomVertexColumn::Packer::get_data4i
01133 //       Access: Public, Virtual
01134 //  Description: 
01135 ////////////////////////////////////////////////////////////////////
01136 const int *GeomVertexColumn::Packer::
01137 get_data4i(const unsigned char *pointer) {
01138   switch (_column->get_num_values()) {
01139   case 1:
01140     _i[0] = get_data1i(pointer);
01141     _i[1] = 0;
01142     _i[2] = 0;
01143     _i[3] = 0;
01144     return _i;
01145 
01146   case 2:
01147     {
01148       const int *i = get_data2i(pointer);
01149       _i[0] = i[0];
01150       _i[1] = i[1];
01151       _i[2] = 0;
01152       _i[3] = 0;
01153     }
01154     return _i;
01155 
01156   case 3:
01157     {
01158       const int *i = get_data3i(pointer);
01159       _i[0] = i[0];
01160       _i[1] = i[1];
01161       _i[2] = i[2];
01162       _i[3] = 0;
01163     }
01164     return _i;
01165 
01166   default:
01167     switch (_column->get_numeric_type()) {
01168     case NT_uint8:
01169       _i[0] = pointer[0];
01170       _i[1] = pointer[1];
01171       _i[2] = pointer[2];
01172       _i[3] = pointer[3];
01173       return _i;
01174       
01175     case NT_uint16:
01176       {
01177         const PN_uint16 *pi = (const PN_uint16 *)pointer;
01178         _i[0] = pi[0];
01179         _i[1] = pi[1];
01180         _i[2] = pi[2];
01181         _i[3] = pi[3];
01182       }
01183       return _i;
01184       
01185     case NT_uint32:
01186       {
01187         const PN_uint32 *pi = (const PN_uint32 *)pointer;
01188         _i[0] = pi[0];
01189         _i[1] = pi[1];
01190         _i[2] = pi[2];
01191         _i[3] = pi[3];
01192       }
01193       return _i;
01194       
01195     case NT_packed_dcba:
01196       {
01197         PN_uint32 dword = *(const PN_uint32 *)pointer;
01198         _i[0] = GeomVertexData::unpack_abcd_d(dword);
01199         _i[1] = GeomVertexData::unpack_abcd_c(dword);
01200         _i[2] = GeomVertexData::unpack_abcd_b(dword);
01201         _i[3] = GeomVertexData::unpack_abcd_a(dword);
01202       }
01203       return _i;
01204       
01205     case NT_packed_dabc:
01206       {
01207         PN_uint32 dword = *(const PN_uint32 *)pointer;
01208         _i[0] = GeomVertexData::unpack_abcd_b(dword);
01209         _i[1] = GeomVertexData::unpack_abcd_c(dword);
01210         _i[2] = GeomVertexData::unpack_abcd_d(dword);
01211         _i[3] = GeomVertexData::unpack_abcd_a(dword);
01212       }
01213       return _i;
01214       
01215     case NT_float32:
01216       {
01217         const PN_float32 *pi = (const PN_float32 *)pointer;
01218         _i[0] = (int)pi[0];
01219         _i[1] = (int)pi[1];
01220         _i[2] = (int)pi[2];
01221         _i[3] = (int)pi[3];
01222       }
01223       return _i;
01224       
01225     case NT_float64:
01226       {
01227         const PN_float64 *pi = (const PN_float64 *)pointer;
01228         _i[0] = (int)pi[0];
01229         _i[1] = (int)pi[1];
01230         _i[2] = (int)pi[2];
01231         _i[3] = (int)pi[3];
01232       }
01233       return _i;
01234 
01235     case NT_stdfloat:
01236       nassertr(false, _i);
01237     }
01238   }
01239 
01240   return _i;
01241 }
01242 
01243 ////////////////////////////////////////////////////////////////////
01244 //     Function: GeomVertexColumn::Packer::set_data1f
01245 //       Access: Public, Virtual
01246 //  Description: 
01247 ////////////////////////////////////////////////////////////////////
01248 void GeomVertexColumn::Packer::
01249 set_data1f(unsigned char *pointer, float data) {
01250   switch (_column->get_num_values()) {
01251   case 1:
01252     switch (_column->get_numeric_type()) {
01253     case NT_uint8:
01254       *pointer = maybe_unscale_color_f(data);
01255       break;
01256       
01257     case NT_uint16:
01258       *(PN_uint16 *)pointer = (unsigned int)data;
01259       break;
01260       
01261     case NT_uint32:
01262       *(PN_uint32 *)pointer = (unsigned int)data;
01263       break;
01264       
01265     case NT_packed_dcba:
01266     case NT_packed_dabc:
01267       nassertv(false);
01268       break;
01269       
01270     case NT_float32:
01271       *(PN_float32 *)pointer = data;
01272       break;
01273       
01274     case NT_float64:
01275       *(PN_float64 *)pointer = data;
01276       break;
01277 
01278     case NT_stdfloat:
01279       nassertv(false);
01280     }
01281     break;
01282 
01283   case 2:
01284     set_data2f(pointer, LVecBase2f(data, 0.0f));
01285     break;
01286 
01287   case 3:
01288     set_data3f(pointer, LVecBase3f(data, 0.0f, 0.0f));
01289     break;
01290 
01291   case 4:
01292     set_data4f(pointer, LVecBase4f(data, 0.0f, 0.0f, 0.0f));
01293     break;
01294   }
01295 }
01296 
01297 ////////////////////////////////////////////////////////////////////
01298 //     Function: GeomVertexColumn::Packer::set_data2f
01299 //       Access: Public, Virtual
01300 //  Description: 
01301 ////////////////////////////////////////////////////////////////////
01302 void GeomVertexColumn::Packer::
01303 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
01304   switch (_column->get_num_values()) {
01305   case 1:
01306     set_data1f(pointer, data[0]);
01307 
01308   case 2:
01309     switch (_column->get_numeric_type()) {
01310     case NT_uint8:
01311       maybe_unscale_color_f(data);
01312       pointer[0] = _a;
01313       pointer[1] = _b;
01314       break;
01315       
01316     case NT_uint16:
01317       {
01318         PN_uint16 *pi = (PN_uint16 *)pointer;
01319         pi[0] = (unsigned int)data[0];
01320         pi[1] = (unsigned int)data[1];
01321       }
01322       break;
01323       
01324     case NT_uint32:
01325       {
01326         PN_uint32 *pi = (PN_uint32 *)pointer;
01327         pi[0] = (unsigned int)data[0];
01328         pi[1] = (unsigned int)data[1];
01329       }
01330       break;
01331       
01332     case NT_packed_dcba:
01333     case NT_packed_dabc:
01334       nassertv(false);
01335       break;
01336       
01337     case NT_float32:
01338       {
01339         PN_float32 *pi = (PN_float32 *)pointer;
01340         pi[0] = data[0];
01341         pi[1] = data[1];
01342       }
01343       break;
01344       
01345     case NT_float64:
01346       {
01347         PN_float64 *pi = (PN_float64 *)pointer;
01348         pi[0] = data[0];
01349         pi[1] = data[1];
01350       }
01351       break;
01352 
01353     case NT_stdfloat:
01354       nassertv(false);
01355     }
01356     break;
01357 
01358   case 3:
01359     set_data3f(pointer, LVecBase3f(data[0], data[1], 0.0f));
01360     break;
01361 
01362   default:
01363     set_data4f(pointer, LVecBase4f(data[0], data[1], 0.0f, 0.0f));
01364     break;
01365   }
01366 }
01367 
01368 ////////////////////////////////////////////////////////////////////
01369 //     Function: GeomVertexColumn::Packer::set_data3f
01370 //       Access: Public, Virtual
01371 //  Description: 
01372 ////////////////////////////////////////////////////////////////////
01373 void GeomVertexColumn::Packer::
01374 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
01375   switch (_column->get_num_values()) {
01376   case 1:
01377     set_data1f(pointer, data[0]);
01378     break;
01379 
01380   case 2:
01381     set_data2f(pointer, LVecBase2f(data[0], data[1]));
01382     break;
01383     
01384   case 3:
01385     switch (_column->get_numeric_type()) {
01386     case NT_uint8:
01387       maybe_unscale_color_f(data);
01388       pointer[0] = _a;
01389       pointer[1] = _b;
01390       pointer[2] = _c;
01391       break;
01392       
01393     case NT_uint16:
01394       {
01395         PN_uint16 *pi = (PN_uint16 *)pointer;
01396         pi[0] = (unsigned int)data[0];
01397         pi[1] = (unsigned int)data[1];
01398         pi[2] = (unsigned int)data[2];
01399       }
01400       break;
01401       
01402     case NT_uint32:
01403       {
01404         PN_uint32 *pi = (PN_uint32 *)pointer;
01405         pi[0] = (unsigned int)data[0];
01406         pi[1] = (unsigned int)data[1];
01407         pi[2] = (unsigned int)data[2];
01408       }
01409       break;
01410       
01411     case NT_packed_dcba:
01412     case NT_packed_dabc:
01413       nassertv(false);
01414       break;
01415       
01416     case NT_float32:
01417       {
01418         PN_float32 *pi = (PN_float32 *)pointer;
01419         pi[0] = data[0];
01420         pi[1] = data[1];
01421         pi[2] = data[2];
01422       }
01423       break;
01424       
01425     case NT_float64:
01426       {
01427         PN_float64 *pi = (PN_float64 *)pointer;
01428         pi[0] = data[0];
01429         pi[1] = data[1];
01430         pi[2] = data[2];
01431       }
01432       break;
01433 
01434     case NT_stdfloat:
01435       nassertv(false);
01436     }
01437     break;
01438 
01439   default:
01440     set_data4f(pointer, LVecBase4f(data[0], data[1], data[2], 0.0f));
01441     break;
01442   }
01443 }
01444 
01445 ////////////////////////////////////////////////////////////////////
01446 //     Function: GeomVertexColumn::Packer::set_data4f
01447 //       Access: Public, Virtual
01448 //  Description: 
01449 ////////////////////////////////////////////////////////////////////
01450 void GeomVertexColumn::Packer::
01451 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
01452   switch (_column->get_num_values()) {
01453   case 1:
01454     set_data1f(pointer, data[0]);
01455     break;
01456 
01457   case 2:
01458     set_data2f(pointer, LVecBase2f(data[0], data[1]));
01459     break;
01460 
01461   case 3:
01462     set_data3f(pointer, LVecBase3f(data[0], data[1], data[2]));
01463     break;
01464 
01465   default:
01466     switch (_column->get_numeric_type()) {
01467     case NT_uint8:
01468       maybe_unscale_color_f(data);
01469       pointer[0] = _a;
01470       pointer[1] = _b;
01471       pointer[2] = _c;
01472       pointer[3] = _d;
01473       break;
01474 
01475     case NT_uint16:
01476       {
01477         PN_uint16 *pi = (PN_uint16 *)pointer;
01478         pi[0] = (unsigned int)data[0];
01479         pi[1] = (unsigned int)data[1];
01480         pi[2] = (unsigned int)data[2];
01481         pi[3] = (unsigned int)data[3];
01482       }
01483       break;
01484 
01485     case NT_uint32:
01486       {
01487         PN_uint32 *pi = (PN_uint32 *)pointer;
01488         pi[0] = (unsigned int)data[0];
01489         pi[1] = (unsigned int)data[1];
01490         pi[2] = (unsigned int)data[2];
01491         pi[3] = (unsigned int)data[3];
01492       }
01493       break;
01494       
01495     case NT_packed_dcba:
01496       maybe_unscale_color_f(data);
01497       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
01498       break;
01499       
01500     case NT_packed_dabc:
01501       maybe_unscale_color_f(data);
01502       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
01503       break;
01504       
01505     case NT_float32:
01506       {
01507         PN_float32 *pi = (PN_float32 *)pointer;
01508         pi[0] = data[0];
01509         pi[1] = data[1];
01510         pi[2] = data[2];
01511         pi[3] = data[3];
01512       }
01513       break;
01514       
01515     case NT_float64:
01516       {
01517         PN_float64 *pi = (PN_float64 *)pointer;
01518         pi[0] = data[0];
01519         pi[1] = data[1];
01520         pi[2] = data[2];
01521         pi[3] = data[3];
01522       }
01523       break;
01524 
01525     case NT_stdfloat:
01526       nassertv(false);
01527     }
01528     break;
01529   }
01530 }
01531 
01532 ////////////////////////////////////////////////////////////////////
01533 //     Function: GeomVertexColumn::Packer::set_data1d
01534 //       Access: Public, Virtual
01535 //  Description: 
01536 ////////////////////////////////////////////////////////////////////
01537 void GeomVertexColumn::Packer::
01538 set_data1d(unsigned char *pointer, double data) {
01539   switch (_column->get_num_values()) {
01540   case 1:
01541     switch (_column->get_numeric_type()) {
01542     case NT_uint8:
01543       *pointer = maybe_unscale_color_d(data);
01544       break;
01545       
01546     case NT_uint16:
01547       *(PN_uint16 *)pointer = (unsigned int)data;
01548       break;
01549       
01550     case NT_uint32:
01551       *(PN_uint32 *)pointer = (unsigned int)data;
01552       break;
01553       
01554     case NT_packed_dcba:
01555     case NT_packed_dabc:
01556       nassertv(false);
01557       break;
01558       
01559     case NT_float32:
01560       *(PN_float32 *)pointer = data;
01561       break;
01562       
01563     case NT_float64:
01564       *(PN_float64 *)pointer = data;
01565       break;
01566 
01567     case NT_stdfloat:
01568       nassertv(false);
01569     }
01570     break;
01571 
01572   case 2:
01573     set_data2d(pointer, LVecBase2d(data, 0.0f));
01574     break;
01575 
01576   case 3:
01577     set_data3d(pointer, LVecBase3d(data, 0.0f, 0.0f));
01578     break;
01579 
01580   case 4:
01581     set_data4d(pointer, LVecBase4d(data, 0.0f, 0.0f, 0.0f));
01582     break;
01583   }
01584 }
01585 
01586 ////////////////////////////////////////////////////////////////////
01587 //     Function: GeomVertexColumn::Packer::set_data2d
01588 //       Access: Public, Virtual
01589 //  Description: 
01590 ////////////////////////////////////////////////////////////////////
01591 void GeomVertexColumn::Packer::
01592 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
01593   switch (_column->get_num_values()) {
01594   case 1:
01595     set_data1d(pointer, data[0]);
01596 
01597   case 2:
01598     switch (_column->get_numeric_type()) {
01599     case NT_uint8:
01600       maybe_unscale_color_d(data);
01601       pointer[0] = _a;
01602       pointer[1] = _b;
01603       break;
01604       
01605     case NT_uint16:
01606       {
01607         PN_uint16 *pi = (PN_uint16 *)pointer;
01608         pi[0] = (unsigned int)data[0];
01609         pi[1] = (unsigned int)data[1];
01610       }
01611       break;
01612       
01613     case NT_uint32:
01614       {
01615         PN_uint32 *pi = (PN_uint32 *)pointer;
01616         pi[0] = (unsigned int)data[0];
01617         pi[1] = (unsigned int)data[1];
01618       }
01619       break;
01620       
01621     case NT_packed_dcba:
01622     case NT_packed_dabc:
01623       nassertv(false);
01624       break;
01625       
01626     case NT_float32:
01627       {
01628         PN_float32 *pi = (PN_float32 *)pointer;
01629         pi[0] = data[0];
01630         pi[1] = data[1];
01631       }
01632       break;
01633       
01634     case NT_float64:
01635       {
01636         PN_float64 *pi = (PN_float64 *)pointer;
01637         pi[0] = data[0];
01638         pi[1] = data[1];
01639       }
01640       break;
01641 
01642     case NT_stdfloat:
01643       nassertv(false);
01644     }
01645     break;
01646 
01647   case 3:
01648     set_data3d(pointer, LVecBase3d(data[0], data[1], 0.0f));
01649     break;
01650 
01651   default:
01652     set_data4d(pointer, LVecBase4d(data[0], data[1], 0.0f, 0.0f));
01653     break;
01654   }
01655 }
01656 
01657 ////////////////////////////////////////////////////////////////////
01658 //     Function: GeomVertexColumn::Packer::set_data3d
01659 //       Access: Public, Virtual
01660 //  Description: 
01661 ////////////////////////////////////////////////////////////////////
01662 void GeomVertexColumn::Packer::
01663 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
01664   switch (_column->get_num_values()) {
01665   case 1:
01666     set_data1d(pointer, data[0]);
01667     break;
01668 
01669   case 2:
01670     set_data2d(pointer, LVecBase2d(data[0], data[1]));
01671     break;
01672     
01673   case 3:
01674     switch (_column->get_numeric_type()) {
01675     case NT_uint8:
01676       maybe_unscale_color_d(data);
01677       pointer[0] = _a;
01678       pointer[1] = _b;
01679       pointer[2] = _c;
01680       break;
01681       
01682     case NT_uint16:
01683       {
01684         PN_uint16 *pi = (PN_uint16 *)pointer;
01685         pi[0] = (unsigned int)data[0];
01686         pi[1] = (unsigned int)data[1];
01687         pi[2] = (unsigned int)data[2];
01688       }
01689       break;
01690       
01691     case NT_uint32:
01692       {
01693         PN_uint32 *pi = (PN_uint32 *)pointer;
01694         pi[0] = (unsigned int)data[0];
01695         pi[1] = (unsigned int)data[1];
01696         pi[2] = (unsigned int)data[2];
01697       }
01698       break;
01699       
01700     case NT_packed_dcba:
01701     case NT_packed_dabc:
01702       nassertv(false);
01703       break;
01704       
01705     case NT_float32:
01706       {
01707         PN_float32 *pi = (PN_float32 *)pointer;
01708         pi[0] = data[0];
01709         pi[1] = data[1];
01710         pi[2] = data[2];
01711       }
01712       break;
01713       
01714     case NT_float64:
01715       {
01716         PN_float64 *pi = (PN_float64 *)pointer;
01717         pi[0] = data[0];
01718         pi[1] = data[1];
01719         pi[2] = data[2];
01720       }
01721       break;
01722 
01723     case NT_stdfloat:
01724       nassertv(false);
01725     }
01726     break;
01727 
01728   default:
01729     set_data4d(pointer, LVecBase4d(data[0], data[1], data[2], 0.0f));
01730     break;
01731   }
01732 }
01733 
01734 ////////////////////////////////////////////////////////////////////
01735 //     Function: GeomVertexColumn::Packer::set_data4d
01736 //       Access: Public, Virtual
01737 //  Description: 
01738 ////////////////////////////////////////////////////////////////////
01739 void GeomVertexColumn::Packer::
01740 set_data4d(unsigned char *pointer, const LVecBase4d &data) {
01741   switch (_column->get_num_values()) {
01742   case 1:
01743     set_data1d(pointer, data[0]);
01744     break;
01745 
01746   case 2:
01747     set_data2d(pointer, LVecBase2d(data[0], data[1]));
01748     break;
01749 
01750   case 3:
01751     set_data3d(pointer, LVecBase3d(data[0], data[1], data[2]));
01752     break;
01753 
01754   default:
01755     switch (_column->get_numeric_type()) {
01756     case NT_uint8:
01757       maybe_unscale_color_d(data);
01758       pointer[0] = _a;
01759       pointer[1] = _b;
01760       pointer[2] = _c;
01761       pointer[3] = _d;
01762       break;
01763 
01764     case NT_uint16:
01765       {
01766         PN_uint16 *pi = (PN_uint16 *)pointer;
01767         pi[0] = (unsigned int)data[0];
01768         pi[1] = (unsigned int)data[1];
01769         pi[2] = (unsigned int)data[2];
01770         pi[3] = (unsigned int)data[3];
01771       }
01772       break;
01773 
01774     case NT_uint32:
01775       {
01776         PN_uint32 *pi = (PN_uint32 *)pointer;
01777         pi[0] = (unsigned int)data[0];
01778         pi[1] = (unsigned int)data[1];
01779         pi[2] = (unsigned int)data[2];
01780         pi[3] = (unsigned int)data[3];
01781       }
01782       break;
01783       
01784     case NT_packed_dcba:
01785       maybe_unscale_color_d(data);
01786       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
01787       break;
01788       
01789     case NT_packed_dabc:
01790       maybe_unscale_color_d(data);
01791       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
01792       break;
01793       
01794     case NT_float32:
01795       {
01796         PN_float32 *pi = (PN_float32 *)pointer;
01797         pi[0] = data[0];
01798         pi[1] = data[1];
01799         pi[2] = data[2];
01800         pi[3] = data[3];
01801       }
01802       break;
01803       
01804     case NT_float64:
01805       {
01806         PN_float64 *pi = (PN_float64 *)pointer;
01807         pi[0] = data[0];
01808         pi[1] = data[1];
01809         pi[2] = data[2];
01810         pi[3] = data[3];
01811       }
01812       break;
01813 
01814     case NT_stdfloat:
01815       nassertv(false);
01816     }
01817     break;
01818   }
01819 }
01820 
01821 ////////////////////////////////////////////////////////////////////
01822 //     Function: GeomVertexColumn::Packer::set_data1i
01823 //       Access: Public, Virtual
01824 //  Description: 
01825 ////////////////////////////////////////////////////////////////////
01826 void GeomVertexColumn::Packer::
01827 set_data1i(unsigned char *pointer, int a) {
01828   switch (_column->get_num_values()) {
01829   case 1:
01830     switch (_column->get_numeric_type()) {
01831     case NT_uint8:
01832       *pointer = a;
01833       nassertv((*pointer) == a);
01834       break;
01835       
01836     case NT_uint16:
01837       *(PN_uint16 *)pointer = a;
01838       nassertv(*(PN_uint16 *)pointer == a);
01839       break;
01840       
01841     case NT_uint32:
01842       *(PN_uint32 *)pointer = a;
01843       break;
01844       
01845     case NT_packed_dcba:
01846     case NT_packed_dabc:
01847       nassertv(false);
01848       break;
01849       
01850     case NT_float32:
01851       *(PN_float32 *)pointer = (float)a;
01852       break;
01853       
01854     case NT_float64:
01855       *(PN_float64 *)pointer = (double)a;
01856       break;
01857 
01858     case NT_stdfloat:
01859       nassertv(false);
01860     }
01861     break;
01862 
01863   case 2:
01864     set_data2i(pointer, a, 0);
01865     break;
01866 
01867   case 3:
01868     set_data3i(pointer, a, 0, 0);
01869     break;
01870 
01871   default:
01872     set_data4i(pointer, a, 0, 0, 0);
01873     break;
01874   }
01875 }
01876 
01877 ////////////////////////////////////////////////////////////////////
01878 //     Function: GeomVertexColumn::Packer::set_data2i
01879 //       Access: Public, Virtual
01880 //  Description: 
01881 ////////////////////////////////////////////////////////////////////
01882 void GeomVertexColumn::Packer::
01883 set_data2i(unsigned char *pointer, int a, int b) {
01884   switch (_column->get_num_values()) {
01885   case 1:
01886     set_data1i(pointer, a);
01887     break;
01888 
01889   case 2:
01890     switch (_column->get_numeric_type()) {
01891     case NT_uint8:
01892       pointer[0] = a;
01893       pointer[1] = b;
01894       break;
01895 
01896     case NT_uint16:
01897       {
01898         PN_uint16 *pi = (PN_uint16 *)pointer;
01899         pi[0] = a;
01900         pi[1] = b;
01901       }
01902       break;
01903 
01904     case NT_uint32:
01905       {
01906         PN_uint32 *pi = (PN_uint32 *)pointer;
01907         pi[0] = a;
01908         pi[1] = b;
01909       }
01910       break;
01911       
01912     case NT_packed_dcba:
01913     case NT_packed_dabc:
01914       nassertv(false);
01915       break;
01916       
01917     case NT_float32:
01918       {
01919         PN_float32 *pi = (PN_float32 *)pointer;
01920         pi[0] = a;
01921         pi[1] = b;
01922       }
01923       break;
01924       
01925     case NT_float64:
01926       {
01927         PN_float64 *pi = (PN_float64 *)pointer;
01928         pi[0] = a;
01929         pi[1] = b;
01930       }
01931       break;
01932 
01933     case NT_stdfloat:
01934       nassertv(false);
01935     }
01936     break;
01937 
01938   case 3:
01939     set_data3i(pointer, a, b, 0);
01940     break;
01941 
01942   default:
01943     set_data4i(pointer, a, b, 0, 0);
01944     break;
01945   }
01946 }
01947 
01948 ////////////////////////////////////////////////////////////////////
01949 //     Function: GeomVertexColumn::Packer::set_data3i
01950 //       Access: Public, Virtual
01951 //  Description: 
01952 ////////////////////////////////////////////////////////////////////
01953 void GeomVertexColumn::Packer::
01954 set_data3i(unsigned char *pointer, int a, int b, int c) {
01955   switch (_column->get_num_values()) {
01956   case 1:
01957     set_data1i(pointer, a);
01958     break;
01959 
01960   case 2:
01961     set_data2i(pointer, a, b);
01962     break;
01963 
01964   case 3:
01965     switch (_column->get_numeric_type()) {
01966     case NT_uint8:
01967       pointer[0] = a;
01968       pointer[1] = b;
01969       pointer[2] = c;
01970       break;
01971 
01972     case NT_uint16:
01973       {
01974         PN_uint16 *pi = (PN_uint16 *)pointer;
01975         pi[0] = a;
01976         pi[1] = b;
01977         pi[2] = c;
01978       }
01979       break;
01980 
01981     case NT_uint32:
01982       {
01983         PN_uint32 *pi = (PN_uint32 *)pointer;
01984         pi[0] = a;
01985         pi[1] = b;
01986         pi[2] = c;
01987       }
01988       break;
01989       
01990     case NT_packed_dcba:
01991     case NT_packed_dabc:
01992       nassertv(false);
01993       break;
01994       
01995     case NT_float32:
01996       {
01997         PN_float32 *pi = (PN_float32 *)pointer;
01998         pi[0] = a;
01999         pi[1] = b;
02000         pi[2] = c;
02001       }
02002       break;
02003       
02004     case NT_float64:
02005       {
02006         PN_float64 *pi = (PN_float64 *)pointer;
02007         pi[0] = a;
02008         pi[1] = b;
02009         pi[2] = c;
02010       }
02011       break;
02012 
02013     case NT_stdfloat:
02014       nassertv(false);
02015     }
02016     break;
02017 
02018   default:
02019     set_data4i(pointer, a, b, c, 0);
02020     break;
02021   }
02022 }
02023 
02024 ////////////////////////////////////////////////////////////////////
02025 //     Function: GeomVertexColumn::Packer::set_data4i
02026 //       Access: Public, Virtual
02027 //  Description: 
02028 ////////////////////////////////////////////////////////////////////
02029 void GeomVertexColumn::Packer::
02030 set_data4i(unsigned char *pointer, int a, int b, int c, int d) {
02031   switch (_column->get_num_values()) {
02032   case 1:
02033     set_data1i(pointer, a);
02034     break;
02035 
02036   case 2:
02037     set_data2i(pointer, a, b);
02038     break;
02039 
02040   case 3:
02041     set_data3i(pointer, a, b, c);
02042     break;
02043 
02044   default:
02045     switch (_column->get_numeric_type()) {
02046     case NT_uint8:
02047       pointer[0] = a;
02048       pointer[1] = b;
02049       pointer[2] = c;
02050       pointer[3] = d;
02051       break;
02052 
02053     case NT_uint16:
02054       {
02055         PN_uint16 *pi = (PN_uint16 *)pointer;
02056         pi[0] = a;
02057         pi[1] = b;
02058         pi[2] = c;
02059         pi[3] = d;
02060       }
02061       break;
02062 
02063     case NT_uint32:
02064       {
02065         PN_uint32 *pi = (PN_uint32 *)pointer;
02066         pi[0] = a;
02067         pi[1] = b;
02068         pi[2] = c;
02069         pi[3] = d;
02070       }
02071       break;
02072       
02073     case NT_packed_dcba:
02074       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(d, c, b, a);
02075       break;
02076       
02077     case NT_packed_dabc:
02078       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(d, a, b, c);
02079       break;
02080       
02081     case NT_float32:
02082       {
02083         PN_float32 *pi = (PN_float32 *)pointer;
02084         pi[0] = a;
02085         pi[1] = b;
02086         pi[2] = c;
02087         pi[3] = d;
02088       }
02089       break;
02090       
02091     case NT_float64:
02092       {
02093         PN_float64 *pi = (PN_float64 *)pointer;
02094         pi[0] = a;
02095         pi[1] = b;
02096         pi[2] = c;
02097         pi[3] = d;
02098       }
02099       break;
02100 
02101     case NT_stdfloat:
02102       nassertv(false);
02103     }
02104     break;
02105   }
02106 }
02107 
02108 ////////////////////////////////////////////////////////////////////
02109 //     Function: GeomVertexColumn::Packer_point::get_data1f
02110 //       Access: Public, Virtual
02111 //  Description: 
02112 ////////////////////////////////////////////////////////////////////
02113 float GeomVertexColumn::Packer_point::
02114 get_data1f(const unsigned char *pointer) {
02115   if (_column->get_num_values() == 4) {
02116     const LVecBase4f &v4 = get_data4f(pointer);
02117     return v4[0] / v4[3];
02118   } else {
02119     return Packer::get_data1f(pointer);
02120   }
02121 }
02122 
02123 ////////////////////////////////////////////////////////////////////
02124 //     Function: GeomVertexColumn::Packer_point::get_data2f
02125 //       Access: Public, Virtual
02126 //  Description: 
02127 ////////////////////////////////////////////////////////////////////
02128 const LVecBase2f &GeomVertexColumn::Packer_point::
02129 get_data2f(const unsigned char *pointer) {
02130   if (_column->get_num_values() == 4) {
02131     const LVecBase4f &v4 = get_data4f(pointer);
02132     _v2.set(v4[0] / v4[3], v4[1] / v4[3]);
02133     return _v2;
02134   } else {
02135     return Packer::get_data2f(pointer);
02136   }
02137 }
02138 
02139 ////////////////////////////////////////////////////////////////////
02140 //     Function: GeomVertexColumn::Packer_point::get_data3f
02141 //       Access: Public, Virtual
02142 //  Description: 
02143 ////////////////////////////////////////////////////////////////////
02144 const LVecBase3f &GeomVertexColumn::Packer_point::
02145 get_data3f(const unsigned char *pointer) {
02146   if (_column->get_num_values() == 4) {
02147     const LVecBase4f &v4 = get_data4f(pointer);
02148     _v3.set(v4[0] / v4[3], v4[1] / v4[3], v4[2] / v4[3]);
02149     return _v3;
02150   } else {
02151     return Packer::get_data3f(pointer);
02152   }
02153 }
02154 
02155 ////////////////////////////////////////////////////////////////////
02156 //     Function: GeomVertexColumn::Packer_point::get_data4f
02157 //       Access: Public, Virtual
02158 //  Description: 
02159 ////////////////////////////////////////////////////////////////////
02160 const LVecBase4f &GeomVertexColumn::Packer_point::
02161 get_data4f(const unsigned char *pointer) {
02162   switch (_column->get_num_values()) {
02163   case 1:
02164     _v4.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
02165     return _v4;
02166 
02167   case 2:
02168     {
02169       const LVecBase2f &v2 = get_data2f(pointer);
02170       _v4.set(v2[0], v2[1], 0.0f, 1.0f);
02171     }
02172     return _v4;
02173 
02174   case 3:
02175     {
02176       const LVecBase3f &v3 = get_data3f(pointer);
02177       _v4.set(v3[0], v3[1], v3[2], 1.0f);
02178     }
02179     return _v4;
02180 
02181   default:
02182     switch (_column->get_numeric_type()) {
02183     case NT_uint8:
02184       maybe_scale_color_f(pointer[0], pointer[1], pointer[2], pointer[3]);
02185       return _v4;
02186       
02187     case NT_uint16:
02188       {
02189         const PN_uint16 *pi = (const PN_uint16 *)pointer;
02190         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02191       }
02192       return _v4;
02193       
02194     case NT_uint32:
02195       {
02196         const PN_uint32 *pi = (const PN_uint32 *)pointer;
02197         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02198       }
02199       return _v4;
02200       
02201     case NT_packed_dcba:
02202       {
02203         PN_uint32 dword = *(const PN_uint32 *)pointer;
02204         maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
02205                             GeomVertexData::unpack_abcd_c(dword),
02206                             GeomVertexData::unpack_abcd_b(dword),
02207                             GeomVertexData::unpack_abcd_a(dword));
02208       }
02209       return _v4;
02210       
02211     case NT_packed_dabc:
02212       {
02213         PN_uint32 dword = *(const PN_uint32 *)pointer;
02214         maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
02215                             GeomVertexData::unpack_abcd_c(dword),
02216                             GeomVertexData::unpack_abcd_d(dword),
02217                             GeomVertexData::unpack_abcd_a(dword));
02218       }
02219       return _v4;
02220       
02221     case NT_float32:
02222       {
02223         const PN_float32 *pi = (const PN_float32 *)pointer;
02224         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02225       }
02226       return _v4;
02227       
02228     case NT_float64:
02229       {
02230         const PN_float64 *pi = (const PN_float64 *)pointer;
02231         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02232       }
02233       return _v4;
02234 
02235     case NT_stdfloat:
02236       nassertr(false, _v4);
02237     }
02238   }
02239 
02240   return _v4;
02241 }
02242 
02243 ////////////////////////////////////////////////////////////////////
02244 //     Function: GeomVertexColumn::Packer_point::get_data1d
02245 //       Access: Public, Virtual
02246 //  Description: 
02247 ////////////////////////////////////////////////////////////////////
02248 double GeomVertexColumn::Packer_point::
02249 get_data1d(const unsigned char *pointer) {
02250   if (_column->get_num_values() == 4) {
02251     const LVecBase4d &v4 = get_data4d(pointer);
02252     return v4[0] / v4[3];
02253   } else {
02254     return Packer::get_data1d(pointer);
02255   }
02256 }
02257 
02258 ////////////////////////////////////////////////////////////////////
02259 //     Function: GeomVertexColumn::Packer_point::get_data2d
02260 //       Access: Public, Virtual
02261 //  Description: 
02262 ////////////////////////////////////////////////////////////////////
02263 const LVecBase2d &GeomVertexColumn::Packer_point::
02264 get_data2d(const unsigned char *pointer) {
02265   if (_column->get_num_values() == 4) {
02266     const LVecBase4d &v4 = get_data4d(pointer);
02267     _v2d.set(v4[0] / v4[3], v4[1] / v4[3]);
02268     return _v2d;
02269   } else {
02270     return Packer::get_data2d(pointer);
02271   }
02272 }
02273 
02274 ////////////////////////////////////////////////////////////////////
02275 //     Function: GeomVertexColumn::Packer_point::get_data3d
02276 //       Access: Public, Virtual
02277 //  Description: 
02278 ////////////////////////////////////////////////////////////////////
02279 const LVecBase3d &GeomVertexColumn::Packer_point::
02280 get_data3d(const unsigned char *pointer) {
02281   if (_column->get_num_values() == 4) {
02282     const LVecBase4d &v4 = get_data4d(pointer);
02283     _v3d.set(v4[0] / v4[3], v4[1] / v4[3], v4[2] / v4[3]);
02284     return _v3d;
02285   } else {
02286     return Packer::get_data3d(pointer);
02287   }
02288 }
02289 
02290 ////////////////////////////////////////////////////////////////////
02291 //     Function: GeomVertexColumn::Packer_point::get_data4d
02292 //       Access: Public, Virtual
02293 //  Description: 
02294 ////////////////////////////////////////////////////////////////////
02295 const LVecBase4d &GeomVertexColumn::Packer_point::
02296 get_data4d(const unsigned char *pointer) {
02297   switch (_column->get_num_values()) {
02298   case 1:
02299     _v4d.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
02300     return _v4d;
02301 
02302   case 2:
02303     {
02304       const LVecBase2d &v2 = get_data2d(pointer);
02305       _v4d.set(v2[0], v2[1], 0.0f, 1.0f);
02306     }
02307     return _v4d;
02308 
02309   case 3:
02310     {
02311       const LVecBase3d &v3 = get_data3d(pointer);
02312       _v4d.set(v3[0], v3[1], v3[2], 1.0f);
02313     }
02314     return _v4d;
02315 
02316   default:
02317     switch (_column->get_numeric_type()) {
02318     case NT_uint8:
02319       maybe_scale_color_d(pointer[0], pointer[1], pointer[2], pointer[3]);
02320       return _v4d;
02321       
02322     case NT_uint16:
02323       {
02324         const PN_uint16 *pi = (const PN_uint16 *)pointer;
02325         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02326       }
02327       return _v4d;
02328       
02329     case NT_uint32:
02330       {
02331         const PN_uint32 *pi = (const PN_uint32 *)pointer;
02332         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02333       }
02334       return _v4d;
02335       
02336     case NT_packed_dcba:
02337       {
02338         PN_uint32 dword = *(const PN_uint32 *)pointer;
02339         maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
02340                             GeomVertexData::unpack_abcd_c(dword),
02341                             GeomVertexData::unpack_abcd_b(dword),
02342                             GeomVertexData::unpack_abcd_a(dword));
02343       }
02344       return _v4d;
02345       
02346     case NT_packed_dabc:
02347       {
02348         PN_uint32 dword = *(const PN_uint32 *)pointer;
02349         maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
02350                             GeomVertexData::unpack_abcd_c(dword),
02351                             GeomVertexData::unpack_abcd_d(dword),
02352                             GeomVertexData::unpack_abcd_a(dword));
02353       }
02354       return _v4d;
02355       
02356     case NT_float32:
02357       {
02358         const PN_float32 *pi = (const PN_float32 *)pointer;
02359         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02360       }
02361       return _v4d;
02362       
02363     case NT_float64:
02364       {
02365         const PN_float64 *pi = (const PN_float64 *)pointer;
02366         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02367       }
02368       return _v4d;
02369 
02370     case NT_stdfloat:
02371       nassertr(false, _v4d);
02372     }
02373   }
02374 
02375   return _v4d;
02376 }
02377 
02378 ////////////////////////////////////////////////////////////////////
02379 //     Function: GeomVertexColumn::Packer_point::set_data1f
02380 //       Access: Public, Virtual
02381 //  Description: 
02382 ////////////////////////////////////////////////////////////////////
02383 void GeomVertexColumn::Packer_point::
02384 set_data1f(unsigned char *pointer, float data) {
02385   if (_column->get_num_values() == 4) {
02386     set_data4f(pointer, LVecBase4f(data, 0.0f, 0.0f, 1.0f));
02387   } else {
02388     Packer::set_data1f(pointer, data);
02389   }
02390 }
02391 
02392 ////////////////////////////////////////////////////////////////////
02393 //     Function: GeomVertexColumn::Packer_point::set_data2f
02394 //       Access: Public, Virtual
02395 //  Description: 
02396 ////////////////////////////////////////////////////////////////////
02397 void GeomVertexColumn::Packer_point::
02398 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
02399   if (_column->get_num_values() == 4) {
02400     set_data4f(pointer, LVecBase4f(data[0], data[1], 0.0f, 1.0f));
02401   } else {
02402     Packer::set_data2f(pointer, data);
02403   }
02404 }
02405 
02406 ////////////////////////////////////////////////////////////////////
02407 //     Function: GeomVertexColumn::Packer_point::set_data3f
02408 //       Access: Public, Virtual
02409 //  Description: 
02410 ////////////////////////////////////////////////////////////////////
02411 void GeomVertexColumn::Packer_point::
02412 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
02413   if (_column->get_num_values() == 4) {
02414     set_data4f(pointer, LVecBase4f(data[0], data[1], data[2], 1.0f));
02415   } else {
02416     Packer::set_data3f(pointer, data);
02417   }
02418 }
02419 
02420 ////////////////////////////////////////////////////////////////////
02421 //     Function: GeomVertexColumn::Packer_point::set_data4f
02422 //       Access: Public, Virtual
02423 //  Description: 
02424 ////////////////////////////////////////////////////////////////////
02425 void GeomVertexColumn::Packer_point::
02426 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
02427   switch (_column->get_num_values()) {
02428   case 1:
02429     set_data1f(pointer, data[0] / data[3]);
02430     break;
02431 
02432   case 2:
02433     set_data2f(pointer, LVecBase2f(data[0] / data[3], data[1] / data[3]));
02434     break;
02435 
02436   case 3:
02437     set_data3f(pointer, LVecBase3f(data[0] / data[3], data[1] / data[3], data[2] / data[3]));
02438     break;
02439 
02440   default:
02441     switch (_column->get_numeric_type()) {
02442     case NT_uint8:
02443       maybe_unscale_color_f(data);
02444       pointer[0] = _a;
02445       pointer[1] = _b;
02446       pointer[2] = _c;
02447       pointer[3] = _d;
02448       break;
02449 
02450     case NT_uint16:
02451       {
02452         PN_uint16 *pi = (PN_uint16 *)pointer;
02453         pi[0] = (unsigned int)data[0];
02454         pi[1] = (unsigned int)data[1];
02455         pi[2] = (unsigned int)data[2];
02456         pi[3] = (unsigned int)data[3];
02457       }
02458       break;
02459 
02460     case NT_uint32:
02461       {
02462         PN_uint32 *pi = (PN_uint32 *)pointer;
02463         pi[0] = (unsigned int)data[0];
02464         pi[1] = (unsigned int)data[1];
02465         pi[2] = (unsigned int)data[2];
02466         pi[3] = (unsigned int)data[3];
02467       }
02468       break;
02469       
02470     case NT_packed_dcba:
02471       maybe_unscale_color_f(data);
02472       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
02473       break;
02474       
02475     case NT_packed_dabc:
02476       maybe_unscale_color_f(data);
02477       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
02478       break;
02479       
02480     case NT_float32:
02481       {
02482         PN_float32 *pi = (PN_float32 *)pointer;
02483         pi[0] = data[0];
02484         pi[1] = data[1];
02485         pi[2] = data[2];
02486         pi[3] = data[3];
02487       }
02488       break;
02489       
02490     case NT_float64:
02491       {
02492         PN_float64 *pi = (PN_float64 *)pointer;
02493         pi[0] = data[0];
02494         pi[1] = data[1];
02495         pi[2] = data[2];
02496         pi[3] = data[3];
02497       }
02498       break;
02499 
02500     case NT_stdfloat:
02501       nassertv(false);
02502     }
02503     break;
02504   }
02505 }
02506 
02507 ////////////////////////////////////////////////////////////////////
02508 //     Function: GeomVertexColumn::Packer_point::set_data1d
02509 //       Access: Public, Virtual
02510 //  Description: 
02511 ////////////////////////////////////////////////////////////////////
02512 void GeomVertexColumn::Packer_point::
02513 set_data1d(unsigned char *pointer, double data) {
02514   if (_column->get_num_values() == 4) {
02515     set_data4d(pointer, LVecBase4d(data, 0.0f, 0.0f, 1.0f));
02516   } else {
02517     Packer::set_data1d(pointer, data);
02518   }
02519 }
02520 
02521 ////////////////////////////////////////////////////////////////////
02522 //     Function: GeomVertexColumn::Packer_point::set_data2d
02523 //       Access: Public, Virtual
02524 //  Description: 
02525 ////////////////////////////////////////////////////////////////////
02526 void GeomVertexColumn::Packer_point::
02527 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
02528   if (_column->get_num_values() == 4) {
02529     set_data4d(pointer, LVecBase4d(data[0], data[1], 0.0f, 1.0f));
02530   } else {
02531     Packer::set_data2d(pointer, data);
02532   }
02533 }
02534 
02535 ////////////////////////////////////////////////////////////////////
02536 //     Function: GeomVertexColumn::Packer_point::set_data3d
02537 //       Access: Public, Virtual
02538 //  Description: 
02539 ////////////////////////////////////////////////////////////////////
02540 void GeomVertexColumn::Packer_point::
02541 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
02542   if (_column->get_num_values() == 4) {
02543     set_data4d(pointer, LVecBase4d(data[0], data[1], data[2], 1.0f));
02544   } else {
02545     Packer::set_data3d(pointer, data);
02546   }
02547 }
02548 
02549 ////////////////////////////////////////////////////////////////////
02550 //     Function: GeomVertexColumn::Packer_point::set_data4d
02551 //       Access: Public, Virtual
02552 //  Description: 
02553 ////////////////////////////////////////////////////////////////////
02554 void GeomVertexColumn::Packer_point::
02555 set_data4d(unsigned char *pointer, const LVecBase4d &data) {
02556   switch (_column->get_num_values()) {
02557   case 1:
02558     set_data1d(pointer, data[0] / data[3]);
02559     break;
02560 
02561   case 2:
02562     set_data2d(pointer, LVecBase2d(data[0] / data[3], data[1] / data[3]));
02563     break;
02564 
02565   case 3:
02566     set_data3d(pointer, LVecBase3d(data[0] / data[3], data[1] / data[3], data[2] / data[3]));
02567     break;
02568 
02569   default:
02570     switch (_column->get_numeric_type()) {
02571     case NT_uint8:
02572       maybe_unscale_color_d(data);
02573       pointer[0] = _a;
02574       pointer[1] = _b;
02575       pointer[2] = _c;
02576       pointer[3] = _d;
02577       break;
02578 
02579     case NT_uint16:
02580       {
02581         PN_uint16 *pi = (PN_uint16 *)pointer;
02582         pi[0] = (unsigned int)data[0];
02583         pi[1] = (unsigned int)data[1];
02584         pi[2] = (unsigned int)data[2];
02585         pi[3] = (unsigned int)data[3];
02586       }
02587       break;
02588 
02589     case NT_uint32:
02590       {
02591         PN_uint32 *pi = (PN_uint32 *)pointer;
02592         pi[0] = (unsigned int)data[0];
02593         pi[1] = (unsigned int)data[1];
02594         pi[2] = (unsigned int)data[2];
02595         pi[3] = (unsigned int)data[3];
02596       }
02597       break;
02598       
02599     case NT_packed_dcba:
02600       maybe_unscale_color_d(data);
02601       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
02602       break;
02603       
02604     case NT_packed_dabc:
02605       maybe_unscale_color_d(data);
02606       *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
02607       break;
02608       
02609     case NT_float32:
02610       {
02611         PN_float32 *pi = (PN_float32 *)pointer;
02612         pi[0] = data[0];
02613         pi[1] = data[1];
02614         pi[2] = data[2];
02615         pi[3] = data[3];
02616       }
02617       break;
02618       
02619     case NT_float64:
02620       {
02621         PN_float64 *pi = (PN_float64 *)pointer;
02622         pi[0] = data[0];
02623         pi[1] = data[1];
02624         pi[2] = data[2];
02625         pi[3] = data[3];
02626       }
02627       break;
02628 
02629     case NT_stdfloat:
02630       nassertv(false);
02631     }
02632     break;
02633   }
02634 }
02635 
02636 ////////////////////////////////////////////////////////////////////
02637 //     Function: GeomVertexColumn::Packer_color::get_data4f
02638 //       Access: Public, Virtual
02639 //  Description: 
02640 ////////////////////////////////////////////////////////////////////
02641 const LVecBase4f &GeomVertexColumn::Packer_color::
02642 get_data4f(const unsigned char *pointer) {
02643   switch (_column->get_num_values()) {
02644   case 1:
02645     _v4.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
02646     return _v4;
02647 
02648   case 2:
02649     {
02650       const LVecBase2f &v2 = get_data2f(pointer);
02651       _v4.set(v2[0], v2[1], 0.0f, 1.0f);
02652     }
02653     return _v4;
02654 
02655   case 3:
02656     {
02657       const LVecBase3f &v3 = get_data3f(pointer);
02658       _v4.set(v3[0], v3[1], v3[2], 1.0f);
02659     }
02660     return _v4;
02661 
02662   default:
02663     switch (_column->get_numeric_type()) {
02664     case NT_uint8:
02665       maybe_scale_color_f(pointer[0], pointer[1], pointer[2], pointer[3]);
02666       return _v4;
02667       
02668     case NT_uint16:
02669       {
02670         const PN_uint16 *pi = (const PN_uint16 *)pointer;
02671         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02672       }
02673       return _v4;
02674       
02675     case NT_uint32:
02676       {
02677         const PN_uint32 *pi = (const PN_uint32 *)pointer;
02678         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02679       }
02680       return _v4;
02681       
02682     case NT_packed_dcba:
02683       {
02684         PN_uint32 dword = *(const PN_uint32 *)pointer;
02685         maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
02686                             GeomVertexData::unpack_abcd_c(dword),
02687                             GeomVertexData::unpack_abcd_b(dword),
02688                             GeomVertexData::unpack_abcd_a(dword));
02689       }
02690       return _v4;
02691       
02692     case NT_packed_dabc:
02693       {
02694         PN_uint32 dword = *(const PN_uint32 *)pointer;
02695         maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
02696                             GeomVertexData::unpack_abcd_c(dword),
02697                             GeomVertexData::unpack_abcd_d(dword),
02698                             GeomVertexData::unpack_abcd_a(dword));
02699       }
02700       return _v4;
02701       
02702     case NT_float32:
02703       {
02704         const PN_float32 *pi = (const PN_float32 *)pointer;
02705         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02706       }
02707       return _v4;
02708       
02709     case NT_float64:
02710       {
02711         const PN_float64 *pi = (const PN_float64 *)pointer;
02712         _v4.set(pi[0], pi[1], pi[2], pi[3]);
02713       }
02714       return _v4;
02715 
02716     case NT_stdfloat:
02717       nassertr(false, _v4);
02718     }
02719   }
02720 
02721   return _v4;
02722 }
02723 
02724 ////////////////////////////////////////////////////////////////////
02725 //     Function: GeomVertexColumn::Packer_color::get_data4d
02726 //       Access: Public, Virtual
02727 //  Description: 
02728 ////////////////////////////////////////////////////////////////////
02729 const LVecBase4d &GeomVertexColumn::Packer_color::
02730 get_data4d(const unsigned char *pointer) {
02731   switch (_column->get_num_values()) {
02732   case 1:
02733     _v4d.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
02734     return _v4d;
02735 
02736   case 2:
02737     {
02738       const LVecBase2f &v2 = get_data2f(pointer);
02739       _v4d.set(v2[0], v2[1], 0.0f, 1.0f);
02740     }
02741     return _v4d;
02742 
02743   case 3:
02744     {
02745       const LVecBase3f &v3 = get_data3f(pointer);
02746       _v4d.set(v3[0], v3[1], v3[2], 1.0f);
02747     }
02748     return _v4d;
02749 
02750   default:
02751     switch (_column->get_numeric_type()) {
02752     case NT_uint8:
02753       maybe_scale_color_d(pointer[0], pointer[1], pointer[2], pointer[3]);
02754       return _v4d;
02755       
02756     case NT_uint16:
02757       {
02758         const PN_uint16 *pi = (const PN_uint16 *)pointer;
02759         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02760       }
02761       return _v4d;
02762       
02763     case NT_uint32:
02764       {
02765         const PN_uint32 *pi = (const PN_uint32 *)pointer;
02766         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02767       }
02768       return _v4d;
02769       
02770     case NT_packed_dcba:
02771       {
02772         PN_uint32 dword = *(const PN_uint32 *)pointer;
02773         maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
02774                             GeomVertexData::unpack_abcd_c(dword),
02775                             GeomVertexData::unpack_abcd_b(dword),
02776                             GeomVertexData::unpack_abcd_a(dword));
02777       }
02778       return _v4d;
02779       
02780     case NT_packed_dabc:
02781       {
02782         PN_uint32 dword = *(const PN_uint32 *)pointer;
02783         maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
02784                             GeomVertexData::unpack_abcd_c(dword),
02785                             GeomVertexData::unpack_abcd_d(dword),
02786                             GeomVertexData::unpack_abcd_a(dword));
02787       }
02788       return _v4d;
02789       
02790     case NT_float32:
02791       {
02792         const PN_float32 *pi = (const PN_float32 *)pointer;
02793         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02794       }
02795       return _v4d;
02796       
02797     case NT_float64:
02798       {
02799         const PN_float64 *pi = (const PN_float64 *)pointer;
02800         _v4d.set(pi[0], pi[1], pi[2], pi[3]);
02801       }
02802       return _v4d;
02803 
02804     case NT_stdfloat:
02805       nassertr(false, _v4d);
02806     }
02807   }
02808 
02809   return _v4d;
02810 }
02811 
02812 ////////////////////////////////////////////////////////////////////
02813 //     Function: GeomVertexColumn::Packer_color::set_data1f
02814 //       Access: Public, Virtual
02815 //  Description: 
02816 ////////////////////////////////////////////////////////////////////
02817 void GeomVertexColumn::Packer_color::
02818 set_data1f(unsigned char *pointer, float data) {
02819   if (_column->get_num_values() == 4) {
02820     set_data4f(pointer, LVecBase4f(data, 0.0f, 0.0f, 1.0f));
02821   } else {
02822     Packer::set_data1f(pointer, data);
02823   }
02824 }
02825 
02826 ////////////////////////////////////////////////////////////////////
02827 //     Function: GeomVertexColumn::Packer_color::set_data2f
02828 //       Access: Public, Virtual
02829 //  Description: 
02830 ////////////////////////////////////////////////////////////////////
02831 void GeomVertexColumn::Packer_color::
02832 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
02833   if (_column->get_num_values() == 4) {
02834     set_data4f(pointer, LVecBase4f(data[0], data[1], 0.0f, 1.0f));
02835   } else {
02836     Packer::set_data2f(pointer, data);
02837   }
02838 }
02839 
02840 ////////////////////////////////////////////////////////////////////
02841 //     Function: GeomVertexColumn::Packer_color::set_data3f
02842 //       Access: Public, Virtual
02843 //  Description: 
02844 ////////////////////////////////////////////////////////////////////
02845 void GeomVertexColumn::Packer_color::
02846 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
02847   if (_column->get_num_values() == 4) {
02848     set_data4f(pointer, LVecBase4f(data[0], data[1], data[2], 1.0f));
02849   } else {
02850     Packer::set_data3f(pointer, data);
02851   }
02852 }
02853 
02854 ////////////////////////////////////////////////////////////////////
02855 //     Function: GeomVertexColumn::Packer_color::set_data1d
02856 //       Access: Public, Virtual
02857 //  Description: 
02858 ////////////////////////////////////////////////////////////////////
02859 void GeomVertexColumn::Packer_color::
02860 set_data1d(unsigned char *pointer, double data) {
02861   if (_column->get_num_values() == 4) {
02862     set_data4d(pointer, LVecBase4d(data, 0.0f, 0.0f, 1.0f));
02863   } else {
02864     Packer::set_data1d(pointer, data);
02865   }
02866 }
02867 
02868 ////////////////////////////////////////////////////////////////////
02869 //     Function: GeomVertexColumn::Packer_color::set_data2d
02870 //       Access: Public, Virtual
02871 //  Description: 
02872 ////////////////////////////////////////////////////////////////////
02873 void GeomVertexColumn::Packer_color::
02874 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
02875   if (_column->get_num_values() == 4) {
02876     set_data4d(pointer, LVecBase4d(data[0], data[1], 0.0f, 1.0f));
02877   } else {
02878     Packer::set_data2d(pointer, data);
02879   }
02880 }
02881 
02882 ////////////////////////////////////////////////////////////////////
02883 //     Function: GeomVertexColumn::Packer_color::set_data3d
02884 //       Access: Public, Virtual
02885 //  Description: 
02886 ////////////////////////////////////////////////////////////////////
02887 void GeomVertexColumn::Packer_color::
02888 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
02889   if (_column->get_num_values() == 4) {
02890     set_data4d(pointer, LVecBase4d(data[0], data[1], data[2], 1.0f));
02891   } else {
02892     Packer::set_data3d(pointer, data);
02893   }
02894 }
02895 
02896 ////////////////////////////////////////////////////////////////////
02897 //     Function: GeomVertexColumn::Packer_float32_3::get_data3f
02898 //       Access: Public, Virtual
02899 //  Description: 
02900 ////////////////////////////////////////////////////////////////////
02901 const LVecBase3f &GeomVertexColumn::Packer_float32_3::
02902 get_data3f(const unsigned char *pointer) {
02903   const PN_float32 *pi = (const PN_float32 *)pointer;
02904   _v3.set(pi[0], pi[1], pi[2]);
02905   return _v3;
02906 }
02907 
02908 ////////////////////////////////////////////////////////////////////
02909 //     Function: GeomVertexColumn::Packer_float32_3::set_data3f
02910 //       Access: Public, Virtual
02911 //  Description: 
02912 ////////////////////////////////////////////////////////////////////
02913 void GeomVertexColumn::Packer_float32_3::
02914 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
02915   PN_float32 *pi = (PN_float32 *)pointer;
02916   pi[0] = data[0];
02917   pi[1] = data[1];
02918   pi[2] = data[2];
02919 }
02920 
02921 ////////////////////////////////////////////////////////////////////
02922 //     Function: GeomVertexColumn::Packer_point_float32_2::get_data2f
02923 //       Access: Public, Virtual
02924 //  Description: 
02925 ////////////////////////////////////////////////////////////////////
02926 const LVecBase2f &GeomVertexColumn::Packer_point_float32_2::
02927 get_data2f(const unsigned char *pointer) {
02928   const PN_float32 *pi = (const PN_float32 *)pointer;
02929   _v2.set(pi[0], pi[1]);
02930   return _v2;
02931 }
02932 
02933 ////////////////////////////////////////////////////////////////////
02934 //     Function: GeomVertexColumn::Packer_point_float32_2::set_data2f
02935 //       Access: Public, Virtual
02936 //  Description: 
02937 ////////////////////////////////////////////////////////////////////
02938 void GeomVertexColumn::Packer_point_float32_2::
02939 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
02940   PN_float32 *pi = (PN_float32 *)pointer;
02941   pi[0] = data[0];
02942   pi[1] = data[1];
02943 }
02944 
02945 ////////////////////////////////////////////////////////////////////
02946 //     Function: GeomVertexColumn::Packer_point_float32_3::get_data3f
02947 //       Access: Public, Virtual
02948 //  Description: 
02949 ////////////////////////////////////////////////////////////////////
02950 const LVecBase3f &GeomVertexColumn::Packer_point_float32_3::
02951 get_data3f(const unsigned char *pointer) {
02952   const PN_float32 *pi = (const PN_float32 *)pointer;
02953   _v3.set(pi[0], pi[1], pi[2]);
02954   return _v3;
02955 }
02956 
02957 ////////////////////////////////////////////////////////////////////
02958 //     Function: GeomVertexColumn::Packer_point_float32_3::set_data3f
02959 //       Access: Public, Virtual
02960 //  Description: 
02961 ////////////////////////////////////////////////////////////////////
02962 void GeomVertexColumn::Packer_point_float32_3::
02963 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
02964   PN_float32 *pi = (PN_float32 *)pointer;
02965   pi[0] = data[0];
02966   pi[1] = data[1];
02967   pi[2] = data[2];
02968 }
02969 
02970 ////////////////////////////////////////////////////////////////////
02971 //     Function: GeomVertexColumn::Packer_point_float32_4::get_data4f
02972 //       Access: Public, Virtual
02973 //  Description: 
02974 ////////////////////////////////////////////////////////////////////
02975 const LVecBase4f &GeomVertexColumn::Packer_point_float32_4::
02976 get_data4f(const unsigned char *pointer) {
02977   const PN_float32 *pi = (const PN_float32 *)pointer;
02978   _v4.set(pi[0], pi[1], pi[2], pi[3]);
02979   return _v4;
02980 }
02981 
02982 ////////////////////////////////////////////////////////////////////
02983 //     Function: GeomVertexColumn::Packer_point_float32_4::set_data4f
02984 //       Access: Public, Virtual
02985 //  Description: 
02986 ////////////////////////////////////////////////////////////////////
02987 void GeomVertexColumn::Packer_point_float32_4::
02988 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
02989   PN_float32 *pi = (PN_float32 *)pointer;
02990   pi[0] = data[0];
02991   pi[1] = data[1];
02992   pi[2] = data[2];
02993   pi[3] = data[3];
02994 }
02995 
02996 ////////////////////////////////////////////////////////////////////
02997 //     Function: GeomVertexColumn::Packer_nativefloat_3::get_data3f
02998 //       Access: Public, Virtual
02999 //  Description: 
03000 ////////////////////////////////////////////////////////////////////
03001 const LVecBase3f &GeomVertexColumn::Packer_nativefloat_3::
03002 get_data3f(const unsigned char *pointer) {
03003   return *(const LVecBase3f *)pointer;
03004 }
03005 
03006 ////////////////////////////////////////////////////////////////////
03007 //     Function: GeomVertexColumn::Packer_point_nativefloat_2::get_data2f
03008 //       Access: Public, Virtual
03009 //  Description: 
03010 ////////////////////////////////////////////////////////////////////
03011 const LVecBase2f &GeomVertexColumn::Packer_point_nativefloat_2::
03012 get_data2f(const unsigned char *pointer) {
03013   return *(const LVecBase2f *)pointer;
03014 }
03015 
03016 ////////////////////////////////////////////////////////////////////
03017 //     Function: GeomVertexColumn::Packer_point_nativefloat_3::get_data3f
03018 //       Access: Public, Virtual
03019 //  Description: 
03020 ////////////////////////////////////////////////////////////////////
03021 const LVecBase3f &GeomVertexColumn::Packer_point_nativefloat_3::
03022 get_data3f(const unsigned char *pointer) {
03023   return *(const LVecBase3f *)pointer;
03024 }
03025 
03026 ////////////////////////////////////////////////////////////////////
03027 //     Function: GeomVertexColumn::Packer_point_nativefloat_4::get_data4f
03028 //       Access: Public, Virtual
03029 //  Description: 
03030 ////////////////////////////////////////////////////////////////////
03031 const LVecBase4f &GeomVertexColumn::Packer_point_nativefloat_4::
03032 get_data4f(const unsigned char *pointer) {
03033   return *(const LVecBase4f *)pointer;
03034 }
03035 
03036 ////////////////////////////////////////////////////////////////////
03037 //     Function: GeomVertexColumn::Packer_float64_3::get_data3d
03038 //       Access: Public, Virtual
03039 //  Description: 
03040 ////////////////////////////////////////////////////////////////////
03041 const LVecBase3d &GeomVertexColumn::Packer_float64_3::
03042 get_data3d(const unsigned char *pointer) {
03043   const PN_float64 *pi = (const PN_float64 *)pointer;
03044   _v3d.set(pi[0], pi[1], pi[2]);
03045   return _v3d;
03046 }
03047 
03048 ////////////////////////////////////////////////////////////////////
03049 //     Function: GeomVertexColumn::Packer_float64_3::set_data3d
03050 //       Access: Public, Virtual
03051 //  Description: 
03052 ////////////////////////////////////////////////////////////////////
03053 void GeomVertexColumn::Packer_float64_3::
03054 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
03055   PN_float64 *pi = (PN_float64 *)pointer;
03056   pi[0] = data[0];
03057   pi[1] = data[1];
03058   pi[2] = data[2];
03059 }
03060 
03061 ////////////////////////////////////////////////////////////////////
03062 //     Function: GeomVertexColumn::Packer_point_float64_2::get_data2d
03063 //       Access: Public, Virtual
03064 //  Description: 
03065 ////////////////////////////////////////////////////////////////////
03066 const LVecBase2d &GeomVertexColumn::Packer_point_float64_2::
03067 get_data2d(const unsigned char *pointer) {
03068   const PN_float64 *pi = (const PN_float64 *)pointer;
03069   _v2d.set(pi[0], pi[1]);
03070   return _v2d;
03071 }
03072 
03073 ////////////////////////////////////////////////////////////////////
03074 //     Function: GeomVertexColumn::Packer_point_float64_2::set_data2d
03075 //       Access: Public, Virtual
03076 //  Description: 
03077 ////////////////////////////////////////////////////////////////////
03078 void GeomVertexColumn::Packer_point_float64_2::
03079 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
03080   PN_float64 *pi = (PN_float64 *)pointer;
03081   pi[0] = data[0];
03082   pi[1] = data[1];
03083 }
03084 
03085 ////////////////////////////////////////////////////////////////////
03086 //     Function: GeomVertexColumn::Packer_point_float64_3::get_data3d
03087 //       Access: Public, Virtual
03088 //  Description: 
03089 ////////////////////////////////////////////////////////////////////
03090 const LVecBase3d &GeomVertexColumn::Packer_point_float64_3::
03091 get_data3d(const unsigned char *pointer) {
03092   const PN_float64 *pi = (const PN_float64 *)pointer;
03093   _v3d.set(pi[0], pi[1], pi[2]);
03094   return _v3d;
03095 }
03096 
03097 ////////////////////////////////////////////////////////////////////
03098 //     Function: GeomVertexColumn::Packer_point_float64_3::set_data3d
03099 //       Access: Public, Virtual
03100 //  Description: 
03101 ////////////////////////////////////////////////////////////////////
03102 void GeomVertexColumn::Packer_point_float64_3::
03103 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
03104   PN_float64 *pi = (PN_float64 *)pointer;
03105   pi[0] = data[0];
03106   pi[1] = data[1];
03107   pi[2] = data[2];
03108 }
03109 
03110 ////////////////////////////////////////////////////////////////////
03111 //     Function: GeomVertexColumn::Packer_point_float64_4::get_data4d
03112 //       Access: Public, Virtual
03113 //  Description: 
03114 ////////////////////////////////////////////////////////////////////
03115 const LVecBase4d &GeomVertexColumn::Packer_point_float64_4::
03116 get_data4d(const unsigned char *pointer) {
03117   const PN_float64 *pi = (const PN_float64 *)pointer;
03118   _v4d.set(pi[0], pi[1], pi[2], pi[3]);
03119   return _v4d;
03120 }
03121 
03122 ////////////////////////////////////////////////////////////////////
03123 //     Function: GeomVertexColumn::Packer_point_float64_4::set_data4d
03124 //       Access: Public, Virtual
03125 //  Description: 
03126 ////////////////////////////////////////////////////////////////////
03127 void GeomVertexColumn::Packer_point_float64_4::
03128 set_data4d(unsigned char *pointer, const LVecBase4d &data) {
03129   PN_float64 *pi = (PN_float64 *)pointer;
03130   pi[0] = data[0];
03131   pi[1] = data[1];
03132   pi[2] = data[2];
03133   pi[3] = data[3];
03134 }
03135 
03136 ////////////////////////////////////////////////////////////////////
03137 //     Function: GeomVertexColumn::Packer_nativedouble_3::get_data3d
03138 //       Access: Public, Virtual
03139 //  Description: 
03140 ////////////////////////////////////////////////////////////////////
03141 const LVecBase3d &GeomVertexColumn::Packer_nativedouble_3::
03142 get_data3d(const unsigned char *pointer) {
03143   return *(const LVecBase3d *)pointer;
03144 }
03145 
03146 ////////////////////////////////////////////////////////////////////
03147 //     Function: GeomVertexColumn::Packer_point_nativedouble_2::get_data2d
03148 //       Access: Public, Virtual
03149 //  Description: 
03150 ////////////////////////////////////////////////////////////////////
03151 const LVecBase2d &GeomVertexColumn::Packer_point_nativedouble_2::
03152 get_data2d(const unsigned char *pointer) {
03153   return *(const LVecBase2d *)pointer;
03154 }
03155 
03156 ////////////////////////////////////////////////////////////////////
03157 //     Function: GeomVertexColumn::Packer_point_nativedouble_3::get_data3d
03158 //       Access: Public, Virtual
03159 //  Description: 
03160 ////////////////////////////////////////////////////////////////////
03161 const LVecBase3d &GeomVertexColumn::Packer_point_nativedouble_3::
03162 get_data3d(const unsigned char *pointer) {
03163   return *(const LVecBase3d *)pointer;
03164 }
03165 
03166 ////////////////////////////////////////////////////////////////////
03167 //     Function: GeomVertexColumn::Packer_point_nativedouble_4::get_data4d
03168 //       Access: Public, Virtual
03169 //  Description: 
03170 ////////////////////////////////////////////////////////////////////
03171 const LVecBase4d &GeomVertexColumn::Packer_point_nativedouble_4::
03172 get_data4d(const unsigned char *pointer) {
03173   return *(const LVecBase4d *)pointer;
03174 }
03175 
03176 ////////////////////////////////////////////////////////////////////
03177 //     Function: GeomVertexColumn::Packer_argb_packed::get_data4f
03178 //       Access: Public, Virtual
03179 //  Description: 
03180 ////////////////////////////////////////////////////////////////////
03181 const LVecBase4f &GeomVertexColumn::Packer_argb_packed::
03182 get_data4f(const unsigned char *pointer) {
03183   PN_uint32 dword = *(const PN_uint32 *)pointer;
03184   _v4.set((float)GeomVertexData::unpack_abcd_b(dword) / 255.0f,
03185           (float)GeomVertexData::unpack_abcd_c(dword) / 255.0f,
03186           (float)GeomVertexData::unpack_abcd_d(dword) / 255.0f,
03187           (float)GeomVertexData::unpack_abcd_a(dword) / 255.0f);
03188   return _v4;
03189 }
03190 
03191 ////////////////////////////////////////////////////////////////////
03192 //     Function: GeomVertexColumn::Packer_argb_packed::set_data4f
03193 //       Access: Public, Virtual
03194 //  Description: 
03195 ////////////////////////////////////////////////////////////////////
03196 void GeomVertexColumn::Packer_argb_packed::
03197 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
03198   // when packing an argb, we want to make sure we cap 
03199   // the input values at 1 since going above one will cause 
03200   // the value to be truncated.
03201   float newData[4];
03202   for (int i = 0; i < 4; i++) {
03203     if (data[i] > 1.0)
03204       newData[i] = 1.0;
03205     else
03206       newData[i] = data[i];
03207   }
03208   *(PN_uint32 *)pointer = GeomVertexData::pack_abcd
03209     ((unsigned int)(newData[3] * 255.0f),
03210      (unsigned int)(newData[0] * 255.0f),
03211      (unsigned int)(newData[1] * 255.0f),
03212      (unsigned int)(newData[2] * 255.0f));
03213 }
03214 
03215 ////////////////////////////////////////////////////////////////////
03216 //     Function: GeomVertexColumn::Packer_rgba_uint8_4::get_data4f
03217 //       Access: Public, Virtual
03218 //  Description: 
03219 ////////////////////////////////////////////////////////////////////
03220 const LVecBase4f &GeomVertexColumn::Packer_rgba_uint8_4::
03221 get_data4f(const unsigned char *pointer) {
03222   _v4.set((float)pointer[0] / 255.0f,
03223           (float)pointer[1] / 255.0f,
03224           (float)pointer[2] / 255.0f,
03225           (float)pointer[3] / 255.0f);
03226   return _v4;
03227 }
03228 
03229 ////////////////////////////////////////////////////////////////////
03230 //     Function: GeomVertexColumn::Packer_rgba_uint8_4::set_data4f
03231 //       Access: Public, Virtual
03232 //  Description: 
03233 ////////////////////////////////////////////////////////////////////
03234 void GeomVertexColumn::Packer_rgba_uint8_4::
03235 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
03236   pointer[0] = (unsigned int)(data[0] * 255.0f);
03237   pointer[1] = (unsigned int)(data[1] * 255.0f);
03238   pointer[2] = (unsigned int)(data[2] * 255.0f);
03239   pointer[3] = (unsigned int)(data[3] * 255.0f);
03240 }
03241 
03242 ////////////////////////////////////////////////////////////////////
03243 //     Function: GeomVertexColumn::Packer_rgba_float32_4::get_data4f
03244 //       Access: Public, Virtual
03245 //  Description: 
03246 ////////////////////////////////////////////////////////////////////
03247 const LVecBase4f &GeomVertexColumn::Packer_rgba_float32_4::
03248 get_data4f(const unsigned char *pointer) {
03249   const PN_float32 *pi = (const PN_float32 *)pointer;
03250   _v4.set(pi[0], pi[1], pi[2], pi[3]);
03251   return _v4;
03252 }
03253 
03254 ////////////////////////////////////////////////////////////////////
03255 //     Function: GeomVertexColumn::Packer_rgba_float32_4::set_data4f
03256 //       Access: Public, Virtual
03257 //  Description: 
03258 ////////////////////////////////////////////////////////////////////
03259 void GeomVertexColumn::Packer_rgba_float32_4::
03260 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
03261   PN_float32 *pi = (PN_float32 *)pointer;
03262   pi[0] = data[0];
03263   pi[1] = data[1];
03264   pi[2] = data[2];
03265   pi[3] = data[3];
03266 }
03267 
03268 ////////////////////////////////////////////////////////////////////
03269 //     Function: GeomVertexColumn::Packer_rgba_nativefloat_4::get_data4f
03270 //       Access: Public, Virtual
03271 //  Description: 
03272 ////////////////////////////////////////////////////////////////////
03273 const LVecBase4f &GeomVertexColumn::Packer_rgba_nativefloat_4::
03274 get_data4f(const unsigned char *pointer) {
03275   return *(const LVecBase4f *)pointer;
03276 }
03277 
03278 ////////////////////////////////////////////////////////////////////
03279 //     Function: GeomVertexColumn::Packer_uint16_1::get_data1i
03280 //       Access: Public, Virtual
03281 //  Description: 
03282 ////////////////////////////////////////////////////////////////////
03283 int GeomVertexColumn::Packer_uint16_1::
03284 get_data1i(const unsigned char *pointer) {
03285   return *(const PN_uint16 *)pointer;
03286 }
03287 
03288 ////////////////////////////////////////////////////////////////////
03289 //     Function: GeomVertexColumn::Packer_uint16_1::set_data1i
03290 //       Access: Public, Virtual
03291 //  Description: 
03292 ////////////////////////////////////////////////////////////////////
03293 void GeomVertexColumn::Packer_uint16_1::
03294 set_data1i(unsigned char *pointer, int data) {
03295   *(PN_uint16 *)pointer = data;
03296   nassertv(*(PN_uint16 *)pointer == data);
03297 }
 All Classes Functions Variables Enumerations