Panda3D
 All Classes Functions Variables Enumerations
geomVertexColumn.cxx
1 // Filename: geomVertexColumn.cxx
2 // Created by: drose (06Mar05)
3 //
4 ////////////////////////////////////////////////////////////////////
5 //
6 // PANDA 3D SOFTWARE
7 // Copyright (c) Carnegie Mellon University. All rights reserved.
8 //
9 // All use of this software is subject to the terms of the revised BSD
10 // license. You should have received a copy of this license along
11 // with this source code in a file named "LICENSE."
12 //
13 ////////////////////////////////////////////////////////////////////
14 
15 #include "geomVertexColumn.h"
16 #include "geomVertexData.h"
17 #include "bamReader.h"
18 #include "bamWriter.h"
19 
20 ////////////////////////////////////////////////////////////////////
21 // Function: GeomVertexColumn::Copy Assignment Operator
22 // Access: Published
23 // Description:
24 ////////////////////////////////////////////////////////////////////
25 void GeomVertexColumn::
26 operator = (const GeomVertexColumn &copy) {
27  _name = copy._name;
28  _num_components = copy._num_components;
29  _numeric_type = copy._numeric_type;
30  _contents = copy._contents;
31  _start = copy._start;
32  _column_alignment = copy._column_alignment;
33 
34  setup();
35 }
36 
37 ////////////////////////////////////////////////////////////////////
38 // Function: GeomVertexColumn::set_name
39 // Access: Published
40 // Description: Replaces the name of an existing column. This is
41 // only legal on an unregistered format (i.e. when
42 // constructing the format initially).
43 ////////////////////////////////////////////////////////////////////
45 set_name(InternalName *name) {
46  _name = name;
47  setup();
48 }
49 
50 ////////////////////////////////////////////////////////////////////
51 // Function: GeomVertexColumn::set_num_components
52 // Access: Published
53 // Description: Changes the number of components of an existing
54 // column. This is only legal on an unregistered format
55 // (i.e. when constructing the format initially).
56 ////////////////////////////////////////////////////////////////////
58 set_num_components(int num_components) {
59  _num_components = num_components;
60  setup();
61 }
62 
63 ////////////////////////////////////////////////////////////////////
64 // Function: GeomVertexColumn::set_numeric_type
65 // Access: Published
66 // Description: Changes the numeric type an existing column. This is
67 // only legal on an unregistered format (i.e. when
68 // constructing the format initially).
69 ////////////////////////////////////////////////////////////////////
71 set_numeric_type(NumericType numeric_type) {
72  _numeric_type = numeric_type;
73  setup();
74 }
75 
76 ////////////////////////////////////////////////////////////////////
77 // Function: GeomVertexColumn::set_contents
78 // Access: Published
79 // Description: Changes the semantic meaning of an existing column.
80 // This is only legal on an unregistered format
81 // (i.e. when constructing the format initially).
82 ////////////////////////////////////////////////////////////////////
84 set_contents(Contents contents) {
85  _contents = contents;
86  setup();
87 }
88 
89 ////////////////////////////////////////////////////////////////////
90 // Function: GeomVertexColumn::set_start
91 // Access: Published
92 // Description: Changes the start byte of an existing column.
93 // This is only legal on an unregistered format
94 // (i.e. when constructing the format initially).
95 ////////////////////////////////////////////////////////////////////
97 set_start(int start) {
98  _start = start;
99  setup();
100 }
101 
102 ////////////////////////////////////////////////////////////////////
103 // Function: GeomVertexColumn::set_column_alignment
104 // Access: Published
105 // Description: Changes the column alignment of an existing column.
106 // This is only legal on an unregistered format
107 // (i.e. when constructing the format initially).
108 ////////////////////////////////////////////////////////////////////
110 set_column_alignment(int column_alignment) {
111  _column_alignment = column_alignment;
112  setup();
113 }
114 
115 ////////////////////////////////////////////////////////////////////
116 // Function: GeomVertexColumn::output
117 // Access: Published
118 // Description:
119 ////////////////////////////////////////////////////////////////////
120 void GeomVertexColumn::
121 output(ostream &out) const {
122  out << *get_name() << "(" << get_num_components();
123  switch (get_numeric_type()) {
124  case NT_uint8:
125  out << "b";
126  break;
127 
128  case NT_uint16:
129  out << "s";
130  break;
131 
132  case NT_uint32:
133  out << "l";
134  break;
135 
136  case NT_packed_dcba:
137  out << "p-";
138  break;
139 
140  case NT_packed_dabc:
141  out << "p";
142  break;
143 
144  case NT_float32:
145  out << "f";
146  break;
147 
148  case NT_float64:
149  out << "d";
150  break;
151 
152  case NT_stdfloat:
153  out << "?";
154  break;
155  }
156 
157  out << ")";
158 }
159 
160 ////////////////////////////////////////////////////////////////////
161 // Function: GeomVertexColumn::setup
162 // Access: Private
163 // Description: Called once at construction time (or at bam-reading
164 // time) to initialize the internal dependent values.
165 ////////////////////////////////////////////////////////////////////
166 void GeomVertexColumn::
167 setup() {
168  nassertv(_num_components > 0 && _start >= 0);
169 
170  _num_values = _num_components;
171  _num_elements = 1;
172 
173  if (_numeric_type == NT_stdfloat) {
174  if (vertices_float64) {
175  _numeric_type = NT_float64;
176  } else {
177  _numeric_type = NT_float32;
178  }
179  }
180 
181  switch (_numeric_type) {
182  case NT_uint16:
183  _component_bytes = 2; // sizeof(PN_uint16)
184  break;
185 
186  case NT_uint32:
187  _component_bytes = 4; // sizeof(PN_uint32)
188  break;
189 
190  case NT_uint8:
191  _component_bytes = 1;
192  break;
193 
194  case NT_packed_dcba:
195  case NT_packed_dabc:
196  _component_bytes = 4; // sizeof(PN_uint32)
197  _num_values *= 4;
198  break;
199 
200  case NT_float32:
201  _component_bytes = 4; // sizeof(PN_float32)
202  break;
203 
204  case NT_float64:
205  _component_bytes = 8; // sizeof(PN_float64)
206  break;
207 
208  case NT_stdfloat:
209  nassertv(false);
210  break;
211  }
212 
213  if (_contents == C_matrix) {
214  _num_elements = _num_components;
215  }
216 
217  if (_column_alignment < 1) {
218  // The default column alignment is to align to the individual
219  // numeric components, or to vertex_column_alignment, whichever is
220  // greater.
221  _column_alignment = max(_component_bytes, (int)vertex_column_alignment);
222  }
223 
224  // Enforce the column alignment requirements on the _start byte.
225  _start = ((_start + _column_alignment - 1) / _column_alignment) * _column_alignment;
226 
227  _element_stride = _component_bytes * _num_components;
228  _total_bytes = _element_stride * _num_elements;
229 
230  if (_packer != NULL) {
231  delete _packer;
232  }
233 
234  _packer = make_packer();
235  _packer->_column = this;
236 }
237 
238 ////////////////////////////////////////////////////////////////////
239 // Function: GeomVertexColumn::make_packer
240 // Access: Private
241 // Description: Returns a newly-allocated Packer object suitable for
242 // packing and unpacking this column. The _column
243 // member of the packer is not filled in.
244 ////////////////////////////////////////////////////////////////////
245 GeomVertexColumn::Packer *GeomVertexColumn::
246 make_packer() const {
247  switch (get_contents()) {
248  case C_point:
249  case C_clip_point:
250  case C_texcoord:
251  // These types are read as a 4-d homogeneous point.
252  switch (get_numeric_type()) {
253  case NT_float32:
254  if (sizeof(float) == sizeof(PN_float32)) {
255  // Use the native float type implementation for a tiny bit
256  // more optimization.
257  switch (get_num_components()) {
258  case 2:
259  return new Packer_point_nativefloat_2;
260  case 3:
261  return new Packer_point_nativefloat_3;
262  case 4:
263  return new Packer_point_nativefloat_4;
264  }
265  } else {
266  switch (get_num_components()) {
267  case 2:
268  return new Packer_point_float32_2;
269  case 3:
270  return new Packer_point_float32_3;
271  case 4:
272  return new Packer_point_float32_4;
273  }
274  }
275  break;
276  case NT_float64:
277  if (sizeof(double) == sizeof(PN_float64)) {
278  // Use the native float type implementation for a tiny bit
279  // more optimization.
280  switch (get_num_components()) {
281  case 2:
282  return new Packer_point_nativedouble_2;
283  case 3:
284  return new Packer_point_nativedouble_3;
285  case 4:
286  return new Packer_point_nativedouble_4;
287  }
288  } else {
289  switch (get_num_components()) {
290  case 2:
291  return new Packer_point_float64_2;
292  case 3:
293  return new Packer_point_float64_3;
294  case 4:
295  return new Packer_point_float64_4;
296  }
297  }
298  break;
299  default:
300  break;
301  }
302  return new Packer_point;
303 
304  case C_color:
305  switch (get_numeric_type()) {
306  case NT_uint8:
307  switch (get_num_components()) {
308  case 4:
309  return new Packer_rgba_uint8_4;
310 
311  default:
312  break;
313  }
314  break;
315  case NT_packed_dabc:
316  switch (get_num_components()) {
317  case 1:
318  return new Packer_argb_packed;
319 
320  default:
321  break;
322  }
323  break;
324  case NT_float32:
325  switch (get_num_components()) {
326  case 4:
327  if (sizeof(float) == sizeof(PN_float32)) {
328  // Use the native float type implementation for a tiny bit
329  // more optimization.
330  return new Packer_rgba_nativefloat_4;
331  } else {
332  return new Packer_rgba_float32_4;
333  }
334 
335  default:
336  break;
337  }
338  break;
339  default:
340  break;
341  }
342  return new Packer_color;
343  case C_normal:
344  if (get_num_values() != 3 && get_num_values() != 4) {
345  gobj_cat.error()
346  << "GeomVertexColumn with contents C_normal must have 3 or 4 components!\n";
347  }
348  default:
349  // Otherwise, we just read it as a generic value.
350  switch (get_numeric_type()) {
351  case NT_float32:
352  switch (get_num_components()) {
353  case 3:
354  if (sizeof(float) == sizeof(PN_float32)) {
355  // Use the native float type implementation for a tiny bit
356  // more optimization.
357  return new Packer_nativefloat_3;
358  } else {
359  return new Packer_float32_3;
360  }
361 
362  default:
363  break;
364  }
365  break;
366  case NT_float64:
367  switch (get_num_components()) {
368  case 3:
369  if (sizeof(double) == sizeof(PN_float64)) {
370  // Use the native float type implementation for a tiny bit
371  // more optimization.
372  return new Packer_nativedouble_3;
373  } else {
374  return new Packer_float64_3;
375  }
376 
377  default:
378  break;
379  }
380  break;
381  default:
382  break;
383  }
384  return new Packer;
385  }
386 }
387 
388 ////////////////////////////////////////////////////////////////////
389 // Function: GeomVertexColumn::write_datagram
390 // Access: Public
391 // Description: Writes the contents of this object to the datagram
392 // for shipping out to a Bam file.
393 ////////////////////////////////////////////////////////////////////
396  manager->write_pointer(dg, _name);
397  dg.add_uint8(_num_components);
398  dg.add_uint8(_numeric_type);
399  dg.add_uint8(_contents);
400  dg.add_uint16(_start);
401  dg.add_uint8(_column_alignment);
402 }
403 
404 ////////////////////////////////////////////////////////////////////
405 // Function: GeomVertexColumn::complete_pointers
406 // Access: Public
407 // Description: Receives an array of pointers, one for each time
408 // manager->read_pointer() was called in fillin().
409 // Returns the number of pointers processed.
410 ////////////////////////////////////////////////////////////////////
413  int pi = 0;
414 
415  _name = DCAST(InternalName, p_list[pi++]);
416 
417  return pi;
418 }
419 
420 ////////////////////////////////////////////////////////////////////
421 // Function: GeomVertexColumn::fillin
422 // Access: Protected
423 // Description: This internal function is called by make_from_bam to
424 // read in all of the relevant data from the BamFile for
425 // the new GeomVertexColumn.
426 ////////////////////////////////////////////////////////////////////
429  manager->read_pointer(scan);
430 
431  _num_components = scan.get_uint8();
432  _numeric_type = (NumericType)scan.get_uint8();
433  _contents = (Contents)scan.get_uint8();
434  _start = scan.get_uint16();
435 
436  _column_alignment = 1;
437  if (manager->get_file_minor_ver() >= 29) {
438  _column_alignment = scan.get_uint8();
439  }
440 
441  setup();
442 }
443 
444 ////////////////////////////////////////////////////////////////////
445 // Function: GeomVertexColumn::Packer::Destructor
446 // Access: Public, Virtual
447 // Description:
448 ////////////////////////////////////////////////////////////////////
449 GeomVertexColumn::Packer::
450 ~Packer() {
451 }
452 
453 ////////////////////////////////////////////////////////////////////
454 // Function: GeomVertexColumn::Packer::get_data1f
455 // Access: Public, Virtual
456 // Description:
457 ////////////////////////////////////////////////////////////////////
458 float GeomVertexColumn::Packer::
459 get_data1f(const unsigned char *pointer) {
460  switch (_column->get_numeric_type()) {
461  case NT_uint8:
462  return maybe_scale_color_f(*pointer);
463 
464  case NT_uint16:
465  return *(const PN_uint16 *)pointer;
466 
467  case NT_uint32:
468  return *(const PN_uint32 *)pointer;
469 
470  case NT_packed_dcba:
471  {
472  PN_uint32 dword = *(const PN_uint32 *)pointer;
473  return maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword));
474  }
475 
476  case NT_packed_dabc:
477  {
478  PN_uint32 dword = *(const PN_uint32 *)pointer;
479  return maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword));
480  }
481 
482  case NT_float32:
483  return *(const PN_float32 *)pointer;
484 
485  case NT_float64:
486  return *(const PN_float64 *)pointer;
487 
488  default:
489  nassertr(false, 0.0f);
490  }
491 
492  return 0.0f;
493 }
494 
495 ////////////////////////////////////////////////////////////////////
496 // Function: GeomVertexColumn::Packer::get_data2f
497 // Access: Public, Virtual
498 // Description:
499 ////////////////////////////////////////////////////////////////////
500 const LVecBase2f &GeomVertexColumn::Packer::
501 get_data2f(const unsigned char *pointer) {
502  if (_column->get_num_values() == 1) {
503  _v2.set(get_data1f(pointer), 0.0f);
504  return _v2;
505 
506  } else {
507  switch (_column->get_numeric_type()) {
508  case NT_uint8:
509  maybe_scale_color_f(pointer[0], pointer[1]);
510  return _v2;
511 
512  case NT_uint16:
513  {
514  const PN_uint16 *pi = (const PN_uint16 *)pointer;
515  _v2.set(pi[0], pi[1]);
516  }
517  return _v2;
518 
519  case NT_uint32:
520  {
521  const PN_uint32 *pi = (const PN_uint32 *)pointer;
522  _v2.set(pi[0], pi[1]);
523  }
524  return _v2;
525 
526  case NT_packed_dcba:
527  {
528  PN_uint32 dword = *(const PN_uint32 *)pointer;
529  maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
531  }
532  return _v2;
533 
534  case NT_packed_dabc:
535  {
536  PN_uint32 dword = *(const PN_uint32 *)pointer;
537  maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
539  }
540  return _v2;
541 
542  case NT_float32:
543  {
544  const PN_float32 *pi = (const PN_float32 *)pointer;
545  _v2.set(pi[0], pi[1]);
546  }
547  return _v2;
548 
549  case NT_float64:
550  {
551  const PN_float64 *pi = (const PN_float64 *)pointer;
552  _v2.set(pi[0], pi[1]);
553  }
554  return _v2;
555 
556  case NT_stdfloat:
557  nassertr(false, _v2);
558  }
559  }
560 
561  return _v2;
562 }
563 
564 ////////////////////////////////////////////////////////////////////
565 // Function: GeomVertexColumn::Packer::get_data3f
566 // Access: Public, Virtual
567 // Description:
568 ////////////////////////////////////////////////////////////////////
569 const LVecBase3f &GeomVertexColumn::Packer::
570 get_data3f(const unsigned char *pointer) {
571  switch (_column->get_num_values()) {
572  case 1:
573  _v3.set(get_data1f(pointer), 0.0f, 0.0f);
574  return _v3;
575 
576  case 2:
577  {
578  const LVecBase2f &v2 = get_data2f(pointer);
579  _v3.set(v2[0], v2[1], 0.0f);
580  }
581  return _v3;
582 
583  default:
584  switch (_column->get_numeric_type()) {
585  case NT_uint8:
586  maybe_scale_color_f(pointer[0], pointer[1], pointer[2]);
587  return _v3;
588 
589  case NT_uint16:
590  {
591  const PN_uint16 *pi = (const PN_uint16 *)pointer;
592  _v3.set(pi[0], pi[1], pi[2]);
593  }
594  return _v3;
595 
596  case NT_uint32:
597  {
598  const PN_uint32 *pi = (const PN_uint32 *)pointer;
599  _v3.set(pi[0], pi[1], pi[2]);
600  }
601  return _v3;
602 
603  case NT_packed_dcba:
604  {
605  PN_uint32 dword = *(const PN_uint32 *)pointer;
606  maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
609  }
610  return _v3;
611 
612  case NT_packed_dabc:
613  {
614  PN_uint32 dword = *(const PN_uint32 *)pointer;
615  maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
618  }
619  return _v3;
620 
621  case NT_float32:
622  {
623  const PN_float32 *pi = (const PN_float32 *)pointer;
624  _v3.set(pi[0], pi[1], pi[2]);
625  }
626  return _v3;
627 
628  case NT_float64:
629  {
630  const PN_float64 *pi = (const PN_float64 *)pointer;
631  _v3.set(pi[0], pi[1], pi[2]);
632  }
633  return _v3;
634 
635  case NT_stdfloat:
636  nassertr(false, _v3);
637  }
638  }
639 
640  return _v3;
641 }
642 
643 ////////////////////////////////////////////////////////////////////
644 // Function: GeomVertexColumn::Packer::get_data4f
645 // Access: Public, Virtual
646 // Description:
647 ////////////////////////////////////////////////////////////////////
648 const LVecBase4f &GeomVertexColumn::Packer::
649 get_data4f(const unsigned char *pointer) {
650  switch (_column->get_num_values()) {
651  case 1:
652  _v4.set(get_data1f(pointer), 0.0f, 0.0f, 0.0f);
653  return _v4;
654 
655  case 2:
656  {
657  const LVecBase2f &v2 = get_data2f(pointer);
658  _v4.set(v2[0], v2[1], 0.0f, 0.0f);
659  }
660  return _v4;
661 
662  case 3:
663  {
664  const LVecBase3f &v3 = get_data3f(pointer);
665  _v4.set(v3[0], v3[1], v3[2], 0.0f);
666  }
667  return _v4;
668 
669  default:
670  switch (_column->get_numeric_type()) {
671  case NT_uint8:
672  maybe_scale_color_f(pointer[0], pointer[1], pointer[2], pointer[3]);
673  return _v4;
674 
675  case NT_uint16:
676  {
677  const PN_uint16 *pi = (const PN_uint16 *)pointer;
678  _v4.set(pi[0], pi[1], pi[2], pi[3]);
679  }
680  return _v4;
681 
682  case NT_uint32:
683  {
684  const PN_uint32 *pi = (const PN_uint32 *)pointer;
685  _v4.set(pi[0], pi[1], pi[2], pi[3]);
686  }
687  return _v4;
688 
689  case NT_packed_dcba:
690  {
691  PN_uint32 dword = *(const PN_uint32 *)pointer;
692  maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
696  }
697  return _v4;
698 
699  case NT_packed_dabc:
700  {
701  PN_uint32 dword = *(const PN_uint32 *)pointer;
702  maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
706  }
707  return _v4;
708 
709  case NT_float32:
710  {
711  const PN_float32 *pi = (const PN_float32 *)pointer;
712  _v4.set(pi[0], pi[1], pi[2], pi[3]);
713  }
714  return _v4;
715 
716  case NT_float64:
717  {
718  const PN_float64 *pi = (const PN_float64 *)pointer;
719  _v4.set(pi[0], pi[1], pi[2], pi[3]);
720  }
721  return _v4;
722 
723  case NT_stdfloat:
724  nassertr(false, _v4);
725  }
726  }
727 
728  return _v4;
729 }
730 
731 ////////////////////////////////////////////////////////////////////
732 // Function: GeomVertexColumn::Packer::get_data1d
733 // Access: Public, Virtual
734 // Description:
735 ////////////////////////////////////////////////////////////////////
736 double GeomVertexColumn::Packer::
737 get_data1d(const unsigned char *pointer) {
738  switch (_column->get_numeric_type()) {
739  case NT_uint8:
740  return maybe_scale_color_d(*pointer);
741 
742  case NT_uint16:
743  return *(const PN_uint16 *)pointer;
744 
745  case NT_uint32:
746  return *(const PN_uint32 *)pointer;
747 
748  case NT_packed_dcba:
749  {
750  PN_uint32 dword = *(const PN_uint32 *)pointer;
751  return maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword));
752  }
753 
754  case NT_packed_dabc:
755  {
756  PN_uint32 dword = *(const PN_uint32 *)pointer;
757  return maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword));
758  }
759 
760  case NT_float32:
761  return *(const PN_float32 *)pointer;
762 
763  case NT_float64:
764  return *(const PN_float64 *)pointer;
765 
766  case NT_stdfloat:
767  nassertr(false, 0.0f);
768  }
769 
770  return 0.0f;
771 }
772 
773 ////////////////////////////////////////////////////////////////////
774 // Function: GeomVertexColumn::Packer::get_data2d
775 // Access: Public, Virtual
776 // Description:
777 ////////////////////////////////////////////////////////////////////
778 const LVecBase2d &GeomVertexColumn::Packer::
779 get_data2d(const unsigned char *pointer) {
780  if (_column->get_num_values() == 1) {
781  _v2d.set(get_data1d(pointer), 0.0f);
782  return _v2d;
783 
784  } else {
785  switch (_column->get_numeric_type()) {
786  case NT_uint8:
787  maybe_scale_color_d(pointer[0], pointer[1]);
788  return _v2d;
789 
790  case NT_uint16:
791  {
792  const PN_uint16 *pi = (const PN_uint16 *)pointer;
793  _v2d.set(pi[0], pi[1]);
794  }
795  return _v2d;
796 
797  case NT_uint32:
798  {
799  const PN_uint32 *pi = (const PN_uint32 *)pointer;
800  _v2d.set(pi[0], pi[1]);
801  }
802  return _v2d;
803 
804  case NT_packed_dcba:
805  {
806  PN_uint32 dword = *(const PN_uint32 *)pointer;
807  maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
809  }
810  return _v2d;
811 
812  case NT_packed_dabc:
813  {
814  PN_uint32 dword = *(const PN_uint32 *)pointer;
815  maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
817  }
818  return _v2d;
819 
820  case NT_float32:
821  {
822  const PN_float32 *pi = (const PN_float32 *)pointer;
823  _v2d.set(pi[0], pi[1]);
824  }
825  return _v2d;
826 
827  case NT_float64:
828  {
829  const PN_float64 *pi = (const PN_float64 *)pointer;
830  _v2d.set(pi[0], pi[1]);
831  }
832  return _v2d;
833 
834  case NT_stdfloat:
835  nassertr(false, _v2d);
836  }
837  }
838 
839  return _v2d;
840 }
841 
842 ////////////////////////////////////////////////////////////////////
843 // Function: GeomVertexColumn::Packer::get_data3d
844 // Access: Public, Virtual
845 // Description:
846 ////////////////////////////////////////////////////////////////////
847 const LVecBase3d &GeomVertexColumn::Packer::
848 get_data3d(const unsigned char *pointer) {
849  switch (_column->get_num_values()) {
850  case 1:
851  _v3d.set(get_data1d(pointer), 0.0f, 0.0f);
852  return _v3d;
853 
854  case 2:
855  {
856  const LVecBase2d &v2 = get_data2d(pointer);
857  _v3d.set(v2[0], v2[1], 0.0f);
858  }
859  return _v3d;
860 
861  default:
862  switch (_column->get_numeric_type()) {
863  case NT_uint8:
864  maybe_scale_color_d(pointer[0], pointer[1], pointer[2]);
865  return _v3d;
866 
867  case NT_uint16:
868  {
869  const PN_uint16 *pi = (const PN_uint16 *)pointer;
870  _v3d.set(pi[0], pi[1], pi[2]);
871  }
872  return _v3d;
873 
874  case NT_uint32:
875  {
876  const PN_uint32 *pi = (const PN_uint32 *)pointer;
877  _v3d.set(pi[0], pi[1], pi[2]);
878  }
879  return _v3d;
880 
881  case NT_packed_dcba:
882  {
883  PN_uint32 dword = *(const PN_uint32 *)pointer;
884  maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
887  }
888  return _v3d;
889 
890  case NT_packed_dabc:
891  {
892  PN_uint32 dword = *(const PN_uint32 *)pointer;
893  maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
896  }
897  return _v3d;
898 
899  case NT_float32:
900  {
901  const PN_float32 *pi = (const PN_float32 *)pointer;
902  _v3d.set(pi[0], pi[1], pi[2]);
903  }
904  return _v3d;
905 
906  case NT_float64:
907  {
908  const PN_float64 *pi = (const PN_float64 *)pointer;
909  _v3d.set(pi[0], pi[1], pi[2]);
910  }
911  return _v3d;
912 
913  case NT_stdfloat:
914  nassertr(false, _v3d);
915  }
916  }
917 
918  return _v3d;
919 }
920 
921 ////////////////////////////////////////////////////////////////////
922 // Function: GeomVertexColumn::Packer::get_data4d
923 // Access: Public, Virtual
924 // Description:
925 ////////////////////////////////////////////////////////////////////
926 const LVecBase4d &GeomVertexColumn::Packer::
927 get_data4d(const unsigned char *pointer) {
928  switch (_column->get_num_values()) {
929  case 1:
930  _v4d.set(get_data1d(pointer), 0.0f, 0.0f, 0.0f);
931  return _v4d;
932 
933  case 2:
934  {
935  const LVecBase2d &v2 = get_data2d(pointer);
936  _v4d.set(v2[0], v2[1], 0.0f, 0.0f);
937  }
938  return _v4d;
939 
940  case 3:
941  {
942  const LVecBase3d &v3 = get_data3d(pointer);
943  _v4d.set(v3[0], v3[1], v3[2], 0.0f);
944  }
945  return _v4d;
946 
947  default:
948  switch (_column->get_numeric_type()) {
949  case NT_uint8:
950  maybe_scale_color_d(pointer[0], pointer[1], pointer[2], pointer[3]);
951  return _v4d;
952 
953  case NT_uint16:
954  {
955  const PN_uint16 *pi = (const PN_uint16 *)pointer;
956  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
957  }
958  return _v4d;
959 
960  case NT_uint32:
961  {
962  const PN_uint32 *pi = (const PN_uint32 *)pointer;
963  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
964  }
965  return _v4d;
966 
967  case NT_packed_dcba:
968  {
969  PN_uint32 dword = *(const PN_uint32 *)pointer;
970  maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
974  }
975  return _v4d;
976 
977  case NT_packed_dabc:
978  {
979  PN_uint32 dword = *(const PN_uint32 *)pointer;
980  maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
984  }
985  return _v4d;
986 
987  case NT_float32:
988  {
989  const PN_float32 *pi = (const PN_float32 *)pointer;
990  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
991  }
992  return _v4d;
993 
994  case NT_float64:
995  {
996  const PN_float64 *pi = (const PN_float64 *)pointer;
997  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
998  }
999  return _v4d;
1000 
1001  case NT_stdfloat:
1002  nassertr(false, _v4d);
1003  }
1004  }
1005 
1006  return _v4d;
1007 }
1008 
1009 ////////////////////////////////////////////////////////////////////
1010 // Function: GeomVertexColumn::Packer::get_data1i
1011 // Access: Public, Virtual
1012 // Description:
1013 ////////////////////////////////////////////////////////////////////
1014 int GeomVertexColumn::Packer::
1015 get_data1i(const unsigned char *pointer) {
1016  switch (_column->get_numeric_type()) {
1017  case NT_uint8:
1018  return *pointer;
1019 
1020  case NT_uint16:
1021  return *(const PN_uint16 *)pointer;
1022 
1023  case NT_uint32:
1024  return *(const PN_uint32 *)pointer;
1025 
1026  case NT_packed_dcba:
1027  {
1028  PN_uint32 dword = *(const PN_uint32 *)pointer;
1029  return GeomVertexData::unpack_abcd_d(dword);
1030  }
1031 
1032  case NT_packed_dabc:
1033  {
1034  PN_uint32 dword = *(const PN_uint32 *)pointer;
1035  return GeomVertexData::unpack_abcd_b(dword);
1036  }
1037 
1038  case NT_float32:
1039  return (int)*(const PN_float32 *)pointer;
1040 
1041  case NT_float64:
1042  return (int)*(const PN_float64 *)pointer;
1043 
1044  case NT_stdfloat:
1045  nassertr(false, 0);
1046  }
1047 
1048  return 0;
1049 }
1050 
1051 ////////////////////////////////////////////////////////////////////
1052 // Function: GeomVertexColumn::Packer::get_data2i
1053 // Access: Public, Virtual
1054 // Description:
1055 ////////////////////////////////////////////////////////////////////
1056 const LVecBase2i &GeomVertexColumn::Packer::
1057 get_data2i(const unsigned char *pointer) {
1058  switch (_column->get_num_values()) {
1059  case 1:
1060  _v2i.set(get_data1i(pointer), 0);
1061  return _v2i;
1062 
1063  default:
1064  switch (_column->get_numeric_type()) {
1065  case NT_uint8:
1066  _v2i.set(pointer[0], pointer[1]);
1067  return _v2i;
1068 
1069  case NT_uint16:
1070  {
1071  const PN_uint16 *pi = (const PN_uint16 *)pointer;
1072  _v2i.set(pi[0], pi[1]);
1073  }
1074  return _v2i;
1075 
1076  case NT_uint32:
1077  {
1078  const PN_uint32 *pi = (const PN_uint32 *)pointer;
1079  _v2i.set(pi[0], pi[1]);
1080  }
1081  return _v2i;
1082 
1083  case NT_packed_dcba:
1084  {
1085  PN_uint32 dword = *(const PN_uint32 *)pointer;
1086  _v2i.set(GeomVertexData::unpack_abcd_d(dword),
1088  }
1089  return _v2i;
1090 
1091  case NT_packed_dabc:
1092  {
1093  PN_uint32 dword = *(const PN_uint32 *)pointer;
1094  _v2i.set(GeomVertexData::unpack_abcd_b(dword),
1096  }
1097  return _v2i;
1098 
1099  case NT_float32:
1100  {
1101  const PN_float32 *pi = (const PN_float32 *)pointer;
1102  _v2i.set((int)pi[0], (int)pi[1]);
1103  }
1104  return _v2i;
1105 
1106  case NT_float64:
1107  {
1108  const PN_float64 *pi = (const PN_float64 *)pointer;
1109  _v2i.set((int)pi[0], (int)pi[1]);
1110  }
1111  return _v2i;
1112 
1113  case NT_stdfloat:
1114  nassertr(false, _v2i);
1115  }
1116  }
1117 
1118  return _v2i;
1119 }
1120 
1121 ////////////////////////////////////////////////////////////////////
1122 // Function: GeomVertexColumn::Packer::get_data3i
1123 // Access: Public, Virtual
1124 // Description:
1125 ////////////////////////////////////////////////////////////////////
1126 const LVecBase3i &GeomVertexColumn::Packer::
1127 get_data3i(const unsigned char *pointer) {
1128  switch (_column->get_num_values()) {
1129  case 1:
1130  _v3i.set(get_data1i(pointer), 0, 0);
1131  return _v3i;
1132 
1133  case 2:
1134  {
1135  const LVecBase2i &v2 = get_data2i(pointer);
1136  _v3i.set(v2[0], v2[1], 0);
1137  }
1138  return _v3i;
1139 
1140  default:
1141  switch (_column->get_numeric_type()) {
1142  case NT_uint8:
1143  _v3i.set(pointer[0], pointer[1], 0);
1144  return _v3i;
1145 
1146  case NT_uint16:
1147  {
1148  const PN_uint16 *pi = (const PN_uint16 *)pointer;
1149  _v3i.set(pi[0], pi[1], pi[2]);
1150  }
1151  return _v3i;
1152 
1153  case NT_uint32:
1154  {
1155  const PN_uint32 *pi = (const PN_uint32 *)pointer;
1156  _v3i.set(pi[0], pi[1], pi[2]);
1157  }
1158  return _v3i;
1159 
1160  case NT_packed_dcba:
1161  {
1162  PN_uint32 dword = *(const PN_uint32 *)pointer;
1163  _v3i.set(GeomVertexData::unpack_abcd_d(dword),
1166  }
1167  return _v3i;
1168 
1169  case NT_packed_dabc:
1170  {
1171  PN_uint32 dword = *(const PN_uint32 *)pointer;
1172  _v3i.set(GeomVertexData::unpack_abcd_b(dword),
1175  }
1176  return _v3i;
1177 
1178  case NT_float32:
1179  {
1180  const PN_float32 *pi = (const PN_float32 *)pointer;
1181  _v3i.set((int)pi[0], (int)pi[1], (int)pi[2]);
1182  }
1183  return _v3i;
1184 
1185  case NT_float64:
1186  {
1187  const PN_float64 *pi = (const PN_float64 *)pointer;
1188  _v3i.set((int)pi[0], (int)pi[1], (int)pi[2]);
1189  }
1190  return _v3i;
1191 
1192  case NT_stdfloat:
1193  nassertr(false, _v3i);
1194  }
1195  }
1196 
1197  return _v3i;
1198 }
1199 
1200 ////////////////////////////////////////////////////////////////////
1201 // Function: GeomVertexColumn::Packer::get_data4i
1202 // Access: Public, Virtual
1203 // Description:
1204 ////////////////////////////////////////////////////////////////////
1205 const LVecBase4i &GeomVertexColumn::Packer::
1206 get_data4i(const unsigned char *pointer) {
1207  switch (_column->get_num_values()) {
1208  case 1:
1209  _v4i.set(get_data1i(pointer), 0, 0, 0);
1210  return _v4i;
1211 
1212  case 2:
1213  {
1214  const LVecBase2i &v2 = get_data2i(pointer);
1215  _v4i.set(v2[0], v2[1], 0, 0);
1216  }
1217  return _v4i;
1218 
1219  case 3:
1220  {
1221  const LVecBase3i &v3 = get_data3i(pointer);
1222  _v4i.set(v3[0], v3[1], v3[2], 0);
1223  }
1224  return _v4i;
1225 
1226  default:
1227  switch (_column->get_numeric_type()) {
1228  case NT_uint8:
1229  _v4i.set(pointer[0], pointer[1], pointer[2], pointer[3]);
1230  return _v4i;
1231 
1232  case NT_uint16:
1233  {
1234  const PN_uint16 *pi = (const PN_uint16 *)pointer;
1235  _v4i.set(pi[0], pi[1], pi[2], pi[3]);
1236  }
1237  return _v4i;
1238 
1239  case NT_uint32:
1240  {
1241  const PN_uint32 *pi = (const PN_uint32 *)pointer;
1242  _v4i.set(pi[0], pi[1], pi[2], pi[3]);
1243  }
1244  return _v4i;
1245 
1246  case NT_packed_dcba:
1247  {
1248  PN_uint32 dword = *(const PN_uint32 *)pointer;
1249  _v4i.set(GeomVertexData::unpack_abcd_d(dword),
1253  }
1254  return _v4i;
1255 
1256  case NT_packed_dabc:
1257  {
1258  PN_uint32 dword = *(const PN_uint32 *)pointer;
1259  _v4i.set(GeomVertexData::unpack_abcd_b(dword),
1263  }
1264  return _v4i;
1265 
1266  case NT_float32:
1267  {
1268  const PN_float32 *pi = (const PN_float32 *)pointer;
1269  _v4i.set((int)pi[0], (int)pi[1], (int)pi[2], (int)pi[3]);
1270  }
1271  return _v4i;
1272 
1273  case NT_float64:
1274  {
1275  const PN_float64 *pi = (const PN_float64 *)pointer;
1276  _v4i.set((int)pi[0], (int)pi[1], (int)pi[2], (int)pi[3]);
1277  }
1278  return _v4i;
1279 
1280  case NT_stdfloat:
1281  nassertr(false, _v4i);
1282  }
1283  }
1284 
1285  return _v4i;
1286 }
1287 
1288 ////////////////////////////////////////////////////////////////////
1289 // Function: GeomVertexColumn::Packer::set_data1f
1290 // Access: Public, Virtual
1291 // Description:
1292 ////////////////////////////////////////////////////////////////////
1293 void GeomVertexColumn::Packer::
1294 set_data1f(unsigned char *pointer, float data) {
1295  switch (_column->get_num_values()) {
1296  case 1:
1297  switch (_column->get_numeric_type()) {
1298  case NT_uint8:
1299  *pointer = maybe_unscale_color_f(data);
1300  break;
1301 
1302  case NT_uint16:
1303  *(PN_uint16 *)pointer = (unsigned int)data;
1304  break;
1305 
1306  case NT_uint32:
1307  *(PN_uint32 *)pointer = (unsigned int)data;
1308  break;
1309 
1310  case NT_packed_dcba:
1311  case NT_packed_dabc:
1312  nassertv(false);
1313  break;
1314 
1315  case NT_float32:
1316  *(PN_float32 *)pointer = data;
1317  break;
1318 
1319  case NT_float64:
1320  *(PN_float64 *)pointer = data;
1321  break;
1322 
1323  case NT_stdfloat:
1324  nassertv(false);
1325  }
1326  break;
1327 
1328  case 2:
1329  set_data2f(pointer, LVecBase2f(data, 0.0f));
1330  break;
1331 
1332  case 3:
1333  set_data3f(pointer, LVecBase3f(data, 0.0f, 0.0f));
1334  break;
1335 
1336  case 4:
1337  set_data4f(pointer, LVecBase4f(data, 0.0f, 0.0f, 0.0f));
1338  break;
1339  }
1340 }
1341 
1342 ////////////////////////////////////////////////////////////////////
1343 // Function: GeomVertexColumn::Packer::set_data2f
1344 // Access: Public, Virtual
1345 // Description:
1346 ////////////////////////////////////////////////////////////////////
1347 void GeomVertexColumn::Packer::
1348 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
1349  switch (_column->get_num_values()) {
1350  case 1:
1351  set_data1f(pointer, data[0]);
1352 
1353  case 2:
1354  switch (_column->get_numeric_type()) {
1355  case NT_uint8:
1356  maybe_unscale_color_f(data);
1357  pointer[0] = _a;
1358  pointer[1] = _b;
1359  break;
1360 
1361  case NT_uint16:
1362  {
1363  PN_uint16 *pi = (PN_uint16 *)pointer;
1364  pi[0] = (unsigned int)data[0];
1365  pi[1] = (unsigned int)data[1];
1366  }
1367  break;
1368 
1369  case NT_uint32:
1370  {
1371  PN_uint32 *pi = (PN_uint32 *)pointer;
1372  pi[0] = (unsigned int)data[0];
1373  pi[1] = (unsigned int)data[1];
1374  }
1375  break;
1376 
1377  case NT_packed_dcba:
1378  case NT_packed_dabc:
1379  nassertv(false);
1380  break;
1381 
1382  case NT_float32:
1383  {
1384  PN_float32 *pi = (PN_float32 *)pointer;
1385  pi[0] = data[0];
1386  pi[1] = data[1];
1387  }
1388  break;
1389 
1390  case NT_float64:
1391  {
1392  PN_float64 *pi = (PN_float64 *)pointer;
1393  pi[0] = data[0];
1394  pi[1] = data[1];
1395  }
1396  break;
1397 
1398  case NT_stdfloat:
1399  nassertv(false);
1400  }
1401  break;
1402 
1403  case 3:
1404  set_data3f(pointer, LVecBase3f(data[0], data[1], 0.0f));
1405  break;
1406 
1407  default:
1408  set_data4f(pointer, LVecBase4f(data[0], data[1], 0.0f, 0.0f));
1409  break;
1410  }
1411 }
1412 
1413 ////////////////////////////////////////////////////////////////////
1414 // Function: GeomVertexColumn::Packer::set_data3f
1415 // Access: Public, Virtual
1416 // Description:
1417 ////////////////////////////////////////////////////////////////////
1418 void GeomVertexColumn::Packer::
1419 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
1420  switch (_column->get_num_values()) {
1421  case 1:
1422  set_data1f(pointer, data[0]);
1423  break;
1424 
1425  case 2:
1426  set_data2f(pointer, LVecBase2f(data[0], data[1]));
1427  break;
1428 
1429  case 3:
1430  switch (_column->get_numeric_type()) {
1431  case NT_uint8:
1432  maybe_unscale_color_f(data);
1433  pointer[0] = _a;
1434  pointer[1] = _b;
1435  pointer[2] = _c;
1436  break;
1437 
1438  case NT_uint16:
1439  {
1440  PN_uint16 *pi = (PN_uint16 *)pointer;
1441  pi[0] = (unsigned int)data[0];
1442  pi[1] = (unsigned int)data[1];
1443  pi[2] = (unsigned int)data[2];
1444  }
1445  break;
1446 
1447  case NT_uint32:
1448  {
1449  PN_uint32 *pi = (PN_uint32 *)pointer;
1450  pi[0] = (unsigned int)data[0];
1451  pi[1] = (unsigned int)data[1];
1452  pi[2] = (unsigned int)data[2];
1453  }
1454  break;
1455 
1456  case NT_packed_dcba:
1457  case NT_packed_dabc:
1458  nassertv(false);
1459  break;
1460 
1461  case NT_float32:
1462  {
1463  PN_float32 *pi = (PN_float32 *)pointer;
1464  pi[0] = data[0];
1465  pi[1] = data[1];
1466  pi[2] = data[2];
1467  }
1468  break;
1469 
1470  case NT_float64:
1471  {
1472  PN_float64 *pi = (PN_float64 *)pointer;
1473  pi[0] = data[0];
1474  pi[1] = data[1];
1475  pi[2] = data[2];
1476  }
1477  break;
1478 
1479  case NT_stdfloat:
1480  nassertv(false);
1481  }
1482  break;
1483 
1484  default:
1485  set_data4f(pointer, LVecBase4f(data[0], data[1], data[2], 0.0f));
1486  break;
1487  }
1488 }
1489 
1490 ////////////////////////////////////////////////////////////////////
1491 // Function: GeomVertexColumn::Packer::set_data4f
1492 // Access: Public, Virtual
1493 // Description:
1494 ////////////////////////////////////////////////////////////////////
1495 void GeomVertexColumn::Packer::
1496 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
1497  switch (_column->get_num_values()) {
1498  case 1:
1499  set_data1f(pointer, data[0]);
1500  break;
1501 
1502  case 2:
1503  set_data2f(pointer, LVecBase2f(data[0], data[1]));
1504  break;
1505 
1506  case 3:
1507  set_data3f(pointer, LVecBase3f(data[0], data[1], data[2]));
1508  break;
1509 
1510  default:
1511  switch (_column->get_numeric_type()) {
1512  case NT_uint8:
1513  maybe_unscale_color_f(data);
1514  pointer[0] = _a;
1515  pointer[1] = _b;
1516  pointer[2] = _c;
1517  pointer[3] = _d;
1518  break;
1519 
1520  case NT_uint16:
1521  {
1522  PN_uint16 *pi = (PN_uint16 *)pointer;
1523  pi[0] = (unsigned int)data[0];
1524  pi[1] = (unsigned int)data[1];
1525  pi[2] = (unsigned int)data[2];
1526  pi[3] = (unsigned int)data[3];
1527  }
1528  break;
1529 
1530  case NT_uint32:
1531  {
1532  PN_uint32 *pi = (PN_uint32 *)pointer;
1533  pi[0] = (unsigned int)data[0];
1534  pi[1] = (unsigned int)data[1];
1535  pi[2] = (unsigned int)data[2];
1536  pi[3] = (unsigned int)data[3];
1537  }
1538  break;
1539 
1540  case NT_packed_dcba:
1541  maybe_unscale_color_f(data);
1542  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
1543  break;
1544 
1545  case NT_packed_dabc:
1546  maybe_unscale_color_f(data);
1547  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
1548  break;
1549 
1550  case NT_float32:
1551  {
1552  PN_float32 *pi = (PN_float32 *)pointer;
1553  pi[0] = data[0];
1554  pi[1] = data[1];
1555  pi[2] = data[2];
1556  pi[3] = data[3];
1557  }
1558  break;
1559 
1560  case NT_float64:
1561  {
1562  PN_float64 *pi = (PN_float64 *)pointer;
1563  pi[0] = data[0];
1564  pi[1] = data[1];
1565  pi[2] = data[2];
1566  pi[3] = data[3];
1567  }
1568  break;
1569 
1570  case NT_stdfloat:
1571  nassertv(false);
1572  }
1573  break;
1574  }
1575 }
1576 
1577 ////////////////////////////////////////////////////////////////////
1578 // Function: GeomVertexColumn::Packer::set_data1d
1579 // Access: Public, Virtual
1580 // Description:
1581 ////////////////////////////////////////////////////////////////////
1582 void GeomVertexColumn::Packer::
1583 set_data1d(unsigned char *pointer, double data) {
1584  switch (_column->get_num_values()) {
1585  case 1:
1586  switch (_column->get_numeric_type()) {
1587  case NT_uint8:
1588  *pointer = maybe_unscale_color_d(data);
1589  break;
1590 
1591  case NT_uint16:
1592  *(PN_uint16 *)pointer = (unsigned int)data;
1593  break;
1594 
1595  case NT_uint32:
1596  *(PN_uint32 *)pointer = (unsigned int)data;
1597  break;
1598 
1599  case NT_packed_dcba:
1600  case NT_packed_dabc:
1601  nassertv(false);
1602  break;
1603 
1604  case NT_float32:
1605  *(PN_float32 *)pointer = data;
1606  break;
1607 
1608  case NT_float64:
1609  *(PN_float64 *)pointer = data;
1610  break;
1611 
1612  case NT_stdfloat:
1613  nassertv(false);
1614  }
1615  break;
1616 
1617  case 2:
1618  set_data2d(pointer, LVecBase2d(data, 0.0f));
1619  break;
1620 
1621  case 3:
1622  set_data3d(pointer, LVecBase3d(data, 0.0f, 0.0f));
1623  break;
1624 
1625  case 4:
1626  set_data4d(pointer, LVecBase4d(data, 0.0f, 0.0f, 0.0f));
1627  break;
1628  }
1629 }
1630 
1631 ////////////////////////////////////////////////////////////////////
1632 // Function: GeomVertexColumn::Packer::set_data2d
1633 // Access: Public, Virtual
1634 // Description:
1635 ////////////////////////////////////////////////////////////////////
1636 void GeomVertexColumn::Packer::
1637 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
1638  switch (_column->get_num_values()) {
1639  case 1:
1640  set_data1d(pointer, data[0]);
1641 
1642  case 2:
1643  switch (_column->get_numeric_type()) {
1644  case NT_uint8:
1645  maybe_unscale_color_d(data);
1646  pointer[0] = _a;
1647  pointer[1] = _b;
1648  break;
1649 
1650  case NT_uint16:
1651  {
1652  PN_uint16 *pi = (PN_uint16 *)pointer;
1653  pi[0] = (unsigned int)data[0];
1654  pi[1] = (unsigned int)data[1];
1655  }
1656  break;
1657 
1658  case NT_uint32:
1659  {
1660  PN_uint32 *pi = (PN_uint32 *)pointer;
1661  pi[0] = (unsigned int)data[0];
1662  pi[1] = (unsigned int)data[1];
1663  }
1664  break;
1665 
1666  case NT_packed_dcba:
1667  case NT_packed_dabc:
1668  nassertv(false);
1669  break;
1670 
1671  case NT_float32:
1672  {
1673  PN_float32 *pi = (PN_float32 *)pointer;
1674  pi[0] = data[0];
1675  pi[1] = data[1];
1676  }
1677  break;
1678 
1679  case NT_float64:
1680  {
1681  PN_float64 *pi = (PN_float64 *)pointer;
1682  pi[0] = data[0];
1683  pi[1] = data[1];
1684  }
1685  break;
1686 
1687  case NT_stdfloat:
1688  nassertv(false);
1689  }
1690  break;
1691 
1692  case 3:
1693  set_data3d(pointer, LVecBase3d(data[0], data[1], 0.0f));
1694  break;
1695 
1696  default:
1697  set_data4d(pointer, LVecBase4d(data[0], data[1], 0.0f, 0.0f));
1698  break;
1699  }
1700 }
1701 
1702 ////////////////////////////////////////////////////////////////////
1703 // Function: GeomVertexColumn::Packer::set_data3d
1704 // Access: Public, Virtual
1705 // Description:
1706 ////////////////////////////////////////////////////////////////////
1707 void GeomVertexColumn::Packer::
1708 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
1709  switch (_column->get_num_values()) {
1710  case 1:
1711  set_data1d(pointer, data[0]);
1712  break;
1713 
1714  case 2:
1715  set_data2d(pointer, LVecBase2d(data[0], data[1]));
1716  break;
1717 
1718  case 3:
1719  switch (_column->get_numeric_type()) {
1720  case NT_uint8:
1721  maybe_unscale_color_d(data);
1722  pointer[0] = _a;
1723  pointer[1] = _b;
1724  pointer[2] = _c;
1725  break;
1726 
1727  case NT_uint16:
1728  {
1729  PN_uint16 *pi = (PN_uint16 *)pointer;
1730  pi[0] = (unsigned int)data[0];
1731  pi[1] = (unsigned int)data[1];
1732  pi[2] = (unsigned int)data[2];
1733  }
1734  break;
1735 
1736  case NT_uint32:
1737  {
1738  PN_uint32 *pi = (PN_uint32 *)pointer;
1739  pi[0] = (unsigned int)data[0];
1740  pi[1] = (unsigned int)data[1];
1741  pi[2] = (unsigned int)data[2];
1742  }
1743  break;
1744 
1745  case NT_packed_dcba:
1746  case NT_packed_dabc:
1747  nassertv(false);
1748  break;
1749 
1750  case NT_float32:
1751  {
1752  PN_float32 *pi = (PN_float32 *)pointer;
1753  pi[0] = data[0];
1754  pi[1] = data[1];
1755  pi[2] = data[2];
1756  }
1757  break;
1758 
1759  case NT_float64:
1760  {
1761  PN_float64 *pi = (PN_float64 *)pointer;
1762  pi[0] = data[0];
1763  pi[1] = data[1];
1764  pi[2] = data[2];
1765  }
1766  break;
1767 
1768  case NT_stdfloat:
1769  nassertv(false);
1770  }
1771  break;
1772 
1773  default:
1774  set_data4d(pointer, LVecBase4d(data[0], data[1], data[2], 0.0f));
1775  break;
1776  }
1777 }
1778 
1779 ////////////////////////////////////////////////////////////////////
1780 // Function: GeomVertexColumn::Packer::set_data4d
1781 // Access: Public, Virtual
1782 // Description:
1783 ////////////////////////////////////////////////////////////////////
1784 void GeomVertexColumn::Packer::
1785 set_data4d(unsigned char *pointer, const LVecBase4d &data) {
1786  switch (_column->get_num_values()) {
1787  case 1:
1788  set_data1d(pointer, data[0]);
1789  break;
1790 
1791  case 2:
1792  set_data2d(pointer, LVecBase2d(data[0], data[1]));
1793  break;
1794 
1795  case 3:
1796  set_data3d(pointer, LVecBase3d(data[0], data[1], data[2]));
1797  break;
1798 
1799  default:
1800  switch (_column->get_numeric_type()) {
1801  case NT_uint8:
1802  maybe_unscale_color_d(data);
1803  pointer[0] = _a;
1804  pointer[1] = _b;
1805  pointer[2] = _c;
1806  pointer[3] = _d;
1807  break;
1808 
1809  case NT_uint16:
1810  {
1811  PN_uint16 *pi = (PN_uint16 *)pointer;
1812  pi[0] = (unsigned int)data[0];
1813  pi[1] = (unsigned int)data[1];
1814  pi[2] = (unsigned int)data[2];
1815  pi[3] = (unsigned int)data[3];
1816  }
1817  break;
1818 
1819  case NT_uint32:
1820  {
1821  PN_uint32 *pi = (PN_uint32 *)pointer;
1822  pi[0] = (unsigned int)data[0];
1823  pi[1] = (unsigned int)data[1];
1824  pi[2] = (unsigned int)data[2];
1825  pi[3] = (unsigned int)data[3];
1826  }
1827  break;
1828 
1829  case NT_packed_dcba:
1830  maybe_unscale_color_d(data);
1831  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
1832  break;
1833 
1834  case NT_packed_dabc:
1835  maybe_unscale_color_d(data);
1836  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
1837  break;
1838 
1839  case NT_float32:
1840  {
1841  PN_float32 *pi = (PN_float32 *)pointer;
1842  pi[0] = data[0];
1843  pi[1] = data[1];
1844  pi[2] = data[2];
1845  pi[3] = data[3];
1846  }
1847  break;
1848 
1849  case NT_float64:
1850  {
1851  PN_float64 *pi = (PN_float64 *)pointer;
1852  pi[0] = data[0];
1853  pi[1] = data[1];
1854  pi[2] = data[2];
1855  pi[3] = data[3];
1856  }
1857  break;
1858 
1859  case NT_stdfloat:
1860  nassertv(false);
1861  }
1862  break;
1863  }
1864 }
1865 
1866 ////////////////////////////////////////////////////////////////////
1867 // Function: GeomVertexColumn::Packer::set_data1i
1868 // Access: Public, Virtual
1869 // Description:
1870 ////////////////////////////////////////////////////////////////////
1871 void GeomVertexColumn::Packer::
1872 set_data1i(unsigned char *pointer, int data) {
1873  switch (_column->get_num_values()) {
1874  case 1:
1875  switch (_column->get_numeric_type()) {
1876  case NT_uint8:
1877  *pointer = data;
1878  nassertv((*pointer) == data);
1879  break;
1880 
1881  case NT_uint16:
1882  *(PN_uint16 *)pointer = data;
1883  nassertv(*(PN_uint16 *)pointer == data);
1884  break;
1885 
1886  case NT_uint32:
1887  *(PN_uint32 *)pointer = data;
1888  break;
1889 
1890  case NT_packed_dcba:
1891  case NT_packed_dabc:
1892  nassertv(false);
1893  break;
1894 
1895  case NT_float32:
1896  *(PN_float32 *)pointer = (float)data;
1897  break;
1898 
1899  case NT_float64:
1900  *(PN_float64 *)pointer = (double)data;
1901  break;
1902 
1903  case NT_stdfloat:
1904  nassertv(false);
1905  }
1906  break;
1907 
1908  case 2:
1909  set_data2i(pointer, LVecBase2i(data, 0));
1910  break;
1911 
1912  case 3:
1913  set_data3i(pointer, LVecBase3i(data, 0, 0));
1914  break;
1915 
1916  default:
1917  set_data4i(pointer, LVecBase4i(data, 0, 0, 0));
1918  break;
1919  }
1920 }
1921 
1922 ////////////////////////////////////////////////////////////////////
1923 // Function: GeomVertexColumn::Packer::set_data2i
1924 // Access: Public, Virtual
1925 // Description:
1926 ////////////////////////////////////////////////////////////////////
1927 void GeomVertexColumn::Packer::
1928 set_data2i(unsigned char *pointer, const LVecBase2i &data) {
1929  switch (_column->get_num_values()) {
1930  case 1:
1931  set_data1i(pointer, data[0]);
1932  break;
1933 
1934  case 2:
1935  switch (_column->get_numeric_type()) {
1936  case NT_uint8:
1937  pointer[0] = data[0];
1938  pointer[1] = data[1];
1939  break;
1940 
1941  case NT_uint16:
1942  {
1943  PN_uint16 *pi = (PN_uint16 *)pointer;
1944  pi[0] = data[0];
1945  pi[1] = data[1];
1946  }
1947  break;
1948 
1949  case NT_uint32:
1950  {
1951  PN_uint32 *pi = (PN_uint32 *)pointer;
1952  pi[0] = data[0];
1953  pi[1] = data[1];
1954  }
1955  break;
1956 
1957  case NT_packed_dcba:
1958  case NT_packed_dabc:
1959  nassertv(false);
1960  break;
1961 
1962  case NT_float32:
1963  {
1964  PN_float32 *pi = (PN_float32 *)pointer;
1965  pi[0] = data[0];
1966  pi[1] = data[1];
1967  }
1968  break;
1969 
1970  case NT_float64:
1971  {
1972  PN_float64 *pi = (PN_float64 *)pointer;
1973  pi[0] = data[0];
1974  pi[1] = data[1];
1975  }
1976  break;
1977 
1978  case NT_stdfloat:
1979  nassertv(false);
1980  }
1981  break;
1982 
1983  case 3:
1984  set_data3i(pointer, LVecBase3i(data[0], data[1], 0));
1985  break;
1986 
1987  default:
1988  set_data4i(pointer, LVecBase4i(data[0], data[1], 0, 0));
1989  break;
1990  }
1991 }
1992 
1993 ////////////////////////////////////////////////////////////////////
1994 // Function: GeomVertexColumn::Packer::set_data3i
1995 // Access: Public, Virtual
1996 // Description:
1997 ////////////////////////////////////////////////////////////////////
1998 void GeomVertexColumn::Packer::
1999 set_data3i(unsigned char *pointer, const LVecBase3i &data) {
2000  switch (_column->get_num_values()) {
2001  case 1:
2002  set_data1i(pointer, data[0]);
2003  break;
2004 
2005  case 2:
2006  set_data2i(pointer, LVecBase2i(data[0], data[1]));
2007  break;
2008 
2009  case 3:
2010  switch (_column->get_numeric_type()) {
2011  case NT_uint8:
2012  pointer[0] = data[0];
2013  pointer[1] = data[1];
2014  pointer[2] = data[2];
2015  break;
2016 
2017  case NT_uint16:
2018  {
2019  PN_uint16 *pi = (PN_uint16 *)pointer;
2020  pi[0] = data[0];
2021  pi[1] = data[1];
2022  pi[2] = data[2];
2023  }
2024  break;
2025 
2026  case NT_uint32:
2027  {
2028  PN_uint32 *pi = (PN_uint32 *)pointer;
2029  pi[0] = data[0];
2030  pi[1] = data[1];
2031  pi[2] = data[2];
2032  }
2033  break;
2034 
2035  case NT_packed_dcba:
2036  case NT_packed_dabc:
2037  nassertv(false);
2038  break;
2039 
2040  case NT_float32:
2041  {
2042  PN_float32 *pi = (PN_float32 *)pointer;
2043  pi[0] = data[0];
2044  pi[1] = data[1];
2045  pi[2] = data[2];
2046  }
2047  break;
2048 
2049  case NT_float64:
2050  {
2051  PN_float64 *pi = (PN_float64 *)pointer;
2052  pi[0] = data[0];
2053  pi[1] = data[1];
2054  pi[2] = data[2];
2055  }
2056  break;
2057 
2058  case NT_stdfloat:
2059  nassertv(false);
2060  }
2061  break;
2062 
2063  default:
2064  set_data4i(pointer, LVecBase4i(data[0], data[1], data[2], 0));
2065  break;
2066  }
2067 }
2068 
2069 ////////////////////////////////////////////////////////////////////
2070 // Function: GeomVertexColumn::Packer::set_data4i
2071 // Access: Public, Virtual
2072 // Description:
2073 ////////////////////////////////////////////////////////////////////
2074 void GeomVertexColumn::Packer::
2075 set_data4i(unsigned char *pointer, const LVecBase4i &data) {
2076  switch (_column->get_num_values()) {
2077  case 1:
2078  set_data1i(pointer, data[0]);
2079  break;
2080 
2081  case 2:
2082  set_data2i(pointer, LVecBase2i(data[0], data[1]));
2083  break;
2084 
2085  case 3:
2086  set_data3i(pointer, LVecBase3i(data[0], data[1], data[2]));
2087  break;
2088 
2089  default:
2090  switch (_column->get_numeric_type()) {
2091  case NT_uint8:
2092  pointer[0] = data[0];
2093  pointer[1] = data[1];
2094  pointer[2] = data[2];
2095  pointer[3] = data[3];
2096  break;
2097 
2098  case NT_uint16:
2099  {
2100  PN_uint16 *pi = (PN_uint16 *)pointer;
2101  pi[0] = data[0];
2102  pi[1] = data[1];
2103  pi[2] = data[2];
2104  pi[3] = data[3];
2105  }
2106  break;
2107 
2108  case NT_uint32:
2109  {
2110  PN_uint32 *pi = (PN_uint32 *)pointer;
2111  pi[0] = data[0];
2112  pi[1] = data[1];
2113  pi[2] = data[2];
2114  pi[3] = data[3];
2115  }
2116  break;
2117 
2118  case NT_packed_dcba:
2119  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(data[3], data[2], data[1], data[0]);
2120  break;
2121 
2122  case NT_packed_dabc:
2123  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(data[3], data[0], data[1], data[2]);
2124  break;
2125 
2126  case NT_float32:
2127  {
2128  PN_float32 *pi = (PN_float32 *)pointer;
2129  pi[0] = data[0];
2130  pi[1] = data[1];
2131  pi[2] = data[2];
2132  pi[3] = data[3];
2133  }
2134  break;
2135 
2136  case NT_float64:
2137  {
2138  PN_float64 *pi = (PN_float64 *)pointer;
2139  pi[0] = data[0];
2140  pi[1] = data[1];
2141  pi[2] = data[2];
2142  pi[3] = data[3];
2143  }
2144  break;
2145 
2146  case NT_stdfloat:
2147  nassertv(false);
2148  }
2149  break;
2150  }
2151 }
2152 
2153 ////////////////////////////////////////////////////////////////////
2154 // Function: GeomVertexColumn::Packer_point::get_data1f
2155 // Access: Public, Virtual
2156 // Description:
2157 ////////////////////////////////////////////////////////////////////
2158 float GeomVertexColumn::Packer_point::
2159 get_data1f(const unsigned char *pointer) {
2160  if (_column->get_num_values() == 4) {
2161  const LVecBase4f &v4 = get_data4f(pointer);
2162  return v4[0] / v4[3];
2163  } else {
2164  return Packer::get_data1f(pointer);
2165  }
2166 }
2167 
2168 ////////////////////////////////////////////////////////////////////
2169 // Function: GeomVertexColumn::Packer_point::get_data2f
2170 // Access: Public, Virtual
2171 // Description:
2172 ////////////////////////////////////////////////////////////////////
2173 const LVecBase2f &GeomVertexColumn::Packer_point::
2174 get_data2f(const unsigned char *pointer) {
2175  if (_column->get_num_values() == 4) {
2176  const LVecBase4f &v4 = get_data4f(pointer);
2177  _v2.set(v4[0] / v4[3], v4[1] / v4[3]);
2178  return _v2;
2179  } else {
2180  return Packer::get_data2f(pointer);
2181  }
2182 }
2183 
2184 ////////////////////////////////////////////////////////////////////
2185 // Function: GeomVertexColumn::Packer_point::get_data3f
2186 // Access: Public, Virtual
2187 // Description:
2188 ////////////////////////////////////////////////////////////////////
2189 const LVecBase3f &GeomVertexColumn::Packer_point::
2190 get_data3f(const unsigned char *pointer) {
2191  if (_column->get_num_values() == 4) {
2192  const LVecBase4f &v4 = get_data4f(pointer);
2193  _v3.set(v4[0] / v4[3], v4[1] / v4[3], v4[2] / v4[3]);
2194  return _v3;
2195  } else {
2196  return Packer::get_data3f(pointer);
2197  }
2198 }
2199 
2200 ////////////////////////////////////////////////////////////////////
2201 // Function: GeomVertexColumn::Packer_point::get_data4f
2202 // Access: Public, Virtual
2203 // Description:
2204 ////////////////////////////////////////////////////////////////////
2205 const LVecBase4f &GeomVertexColumn::Packer_point::
2206 get_data4f(const unsigned char *pointer) {
2207  switch (_column->get_num_values()) {
2208  case 1:
2209  _v4.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
2210  return _v4;
2211 
2212  case 2:
2213  {
2214  const LVecBase2f &v2 = get_data2f(pointer);
2215  _v4.set(v2[0], v2[1], 0.0f, 1.0f);
2216  }
2217  return _v4;
2218 
2219  case 3:
2220  {
2221  const LVecBase3f &v3 = get_data3f(pointer);
2222  _v4.set(v3[0], v3[1], v3[2], 1.0f);
2223  }
2224  return _v4;
2225 
2226  default:
2227  switch (_column->get_numeric_type()) {
2228  case NT_uint8:
2229  maybe_scale_color_f(pointer[0], pointer[1], pointer[2], pointer[3]);
2230  return _v4;
2231 
2232  case NT_uint16:
2233  {
2234  const PN_uint16 *pi = (const PN_uint16 *)pointer;
2235  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2236  }
2237  return _v4;
2238 
2239  case NT_uint32:
2240  {
2241  const PN_uint32 *pi = (const PN_uint32 *)pointer;
2242  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2243  }
2244  return _v4;
2245 
2246  case NT_packed_dcba:
2247  {
2248  PN_uint32 dword = *(const PN_uint32 *)pointer;
2249  maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
2253  }
2254  return _v4;
2255 
2256  case NT_packed_dabc:
2257  {
2258  PN_uint32 dword = *(const PN_uint32 *)pointer;
2259  maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
2263  }
2264  return _v4;
2265 
2266  case NT_float32:
2267  {
2268  const PN_float32 *pi = (const PN_float32 *)pointer;
2269  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2270  }
2271  return _v4;
2272 
2273  case NT_float64:
2274  {
2275  const PN_float64 *pi = (const PN_float64 *)pointer;
2276  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2277  }
2278  return _v4;
2279 
2280  case NT_stdfloat:
2281  nassertr(false, _v4);
2282  }
2283  }
2284 
2285  return _v4;
2286 }
2287 
2288 ////////////////////////////////////////////////////////////////////
2289 // Function: GeomVertexColumn::Packer_point::get_data1d
2290 // Access: Public, Virtual
2291 // Description:
2292 ////////////////////////////////////////////////////////////////////
2293 double GeomVertexColumn::Packer_point::
2294 get_data1d(const unsigned char *pointer) {
2295  if (_column->get_num_values() == 4) {
2296  const LVecBase4d &v4 = get_data4d(pointer);
2297  return v4[0] / v4[3];
2298  } else {
2299  return Packer::get_data1d(pointer);
2300  }
2301 }
2302 
2303 ////////////////////////////////////////////////////////////////////
2304 // Function: GeomVertexColumn::Packer_point::get_data2d
2305 // Access: Public, Virtual
2306 // Description:
2307 ////////////////////////////////////////////////////////////////////
2308 const LVecBase2d &GeomVertexColumn::Packer_point::
2309 get_data2d(const unsigned char *pointer) {
2310  if (_column->get_num_values() == 4) {
2311  const LVecBase4d &v4 = get_data4d(pointer);
2312  _v2d.set(v4[0] / v4[3], v4[1] / v4[3]);
2313  return _v2d;
2314  } else {
2315  return Packer::get_data2d(pointer);
2316  }
2317 }
2318 
2319 ////////////////////////////////////////////////////////////////////
2320 // Function: GeomVertexColumn::Packer_point::get_data3d
2321 // Access: Public, Virtual
2322 // Description:
2323 ////////////////////////////////////////////////////////////////////
2324 const LVecBase3d &GeomVertexColumn::Packer_point::
2325 get_data3d(const unsigned char *pointer) {
2326  if (_column->get_num_values() == 4) {
2327  const LVecBase4d &v4 = get_data4d(pointer);
2328  _v3d.set(v4[0] / v4[3], v4[1] / v4[3], v4[2] / v4[3]);
2329  return _v3d;
2330  } else {
2331  return Packer::get_data3d(pointer);
2332  }
2333 }
2334 
2335 ////////////////////////////////////////////////////////////////////
2336 // Function: GeomVertexColumn::Packer_point::get_data4d
2337 // Access: Public, Virtual
2338 // Description:
2339 ////////////////////////////////////////////////////////////////////
2340 const LVecBase4d &GeomVertexColumn::Packer_point::
2341 get_data4d(const unsigned char *pointer) {
2342  switch (_column->get_num_values()) {
2343  case 1:
2344  _v4d.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
2345  return _v4d;
2346 
2347  case 2:
2348  {
2349  const LVecBase2d &v2 = get_data2d(pointer);
2350  _v4d.set(v2[0], v2[1], 0.0f, 1.0f);
2351  }
2352  return _v4d;
2353 
2354  case 3:
2355  {
2356  const LVecBase3d &v3 = get_data3d(pointer);
2357  _v4d.set(v3[0], v3[1], v3[2], 1.0f);
2358  }
2359  return _v4d;
2360 
2361  default:
2362  switch (_column->get_numeric_type()) {
2363  case NT_uint8:
2364  maybe_scale_color_d(pointer[0], pointer[1], pointer[2], pointer[3]);
2365  return _v4d;
2366 
2367  case NT_uint16:
2368  {
2369  const PN_uint16 *pi = (const PN_uint16 *)pointer;
2370  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2371  }
2372  return _v4d;
2373 
2374  case NT_uint32:
2375  {
2376  const PN_uint32 *pi = (const PN_uint32 *)pointer;
2377  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2378  }
2379  return _v4d;
2380 
2381  case NT_packed_dcba:
2382  {
2383  PN_uint32 dword = *(const PN_uint32 *)pointer;
2384  maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
2388  }
2389  return _v4d;
2390 
2391  case NT_packed_dabc:
2392  {
2393  PN_uint32 dword = *(const PN_uint32 *)pointer;
2394  maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
2398  }
2399  return _v4d;
2400 
2401  case NT_float32:
2402  {
2403  const PN_float32 *pi = (const PN_float32 *)pointer;
2404  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2405  }
2406  return _v4d;
2407 
2408  case NT_float64:
2409  {
2410  const PN_float64 *pi = (const PN_float64 *)pointer;
2411  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2412  }
2413  return _v4d;
2414 
2415  case NT_stdfloat:
2416  nassertr(false, _v4d);
2417  }
2418  }
2419 
2420  return _v4d;
2421 }
2422 
2423 ////////////////////////////////////////////////////////////////////
2424 // Function: GeomVertexColumn::Packer_point::set_data1f
2425 // Access: Public, Virtual
2426 // Description:
2427 ////////////////////////////////////////////////////////////////////
2428 void GeomVertexColumn::Packer_point::
2429 set_data1f(unsigned char *pointer, float data) {
2430  if (_column->get_num_values() == 4) {
2431  set_data4f(pointer, LVecBase4f(data, 0.0f, 0.0f, 1.0f));
2432  } else {
2433  Packer::set_data1f(pointer, data);
2434  }
2435 }
2436 
2437 ////////////////////////////////////////////////////////////////////
2438 // Function: GeomVertexColumn::Packer_point::set_data2f
2439 // Access: Public, Virtual
2440 // Description:
2441 ////////////////////////////////////////////////////////////////////
2442 void GeomVertexColumn::Packer_point::
2443 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
2444  if (_column->get_num_values() == 4) {
2445  set_data4f(pointer, LVecBase4f(data[0], data[1], 0.0f, 1.0f));
2446  } else {
2447  Packer::set_data2f(pointer, data);
2448  }
2449 }
2450 
2451 ////////////////////////////////////////////////////////////////////
2452 // Function: GeomVertexColumn::Packer_point::set_data3f
2453 // Access: Public, Virtual
2454 // Description:
2455 ////////////////////////////////////////////////////////////////////
2456 void GeomVertexColumn::Packer_point::
2457 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
2458  if (_column->get_num_values() == 4) {
2459  set_data4f(pointer, LVecBase4f(data[0], data[1], data[2], 1.0f));
2460  } else {
2461  Packer::set_data3f(pointer, data);
2462  }
2463 }
2464 
2465 ////////////////////////////////////////////////////////////////////
2466 // Function: GeomVertexColumn::Packer_point::set_data4f
2467 // Access: Public, Virtual
2468 // Description:
2469 ////////////////////////////////////////////////////////////////////
2470 void GeomVertexColumn::Packer_point::
2471 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
2472  switch (_column->get_num_values()) {
2473  case 1:
2474  set_data1f(pointer, data[0] / data[3]);
2475  break;
2476 
2477  case 2:
2478  set_data2f(pointer, LVecBase2f(data[0] / data[3], data[1] / data[3]));
2479  break;
2480 
2481  case 3:
2482  set_data3f(pointer, LVecBase3f(data[0] / data[3], data[1] / data[3], data[2] / data[3]));
2483  break;
2484 
2485  default:
2486  switch (_column->get_numeric_type()) {
2487  case NT_uint8:
2488  maybe_unscale_color_f(data);
2489  pointer[0] = _a;
2490  pointer[1] = _b;
2491  pointer[2] = _c;
2492  pointer[3] = _d;
2493  break;
2494 
2495  case NT_uint16:
2496  {
2497  PN_uint16 *pi = (PN_uint16 *)pointer;
2498  pi[0] = (unsigned int)data[0];
2499  pi[1] = (unsigned int)data[1];
2500  pi[2] = (unsigned int)data[2];
2501  pi[3] = (unsigned int)data[3];
2502  }
2503  break;
2504 
2505  case NT_uint32:
2506  {
2507  PN_uint32 *pi = (PN_uint32 *)pointer;
2508  pi[0] = (unsigned int)data[0];
2509  pi[1] = (unsigned int)data[1];
2510  pi[2] = (unsigned int)data[2];
2511  pi[3] = (unsigned int)data[3];
2512  }
2513  break;
2514 
2515  case NT_packed_dcba:
2516  maybe_unscale_color_f(data);
2517  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
2518  break;
2519 
2520  case NT_packed_dabc:
2521  maybe_unscale_color_f(data);
2522  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
2523  break;
2524 
2525  case NT_float32:
2526  {
2527  PN_float32 *pi = (PN_float32 *)pointer;
2528  pi[0] = data[0];
2529  pi[1] = data[1];
2530  pi[2] = data[2];
2531  pi[3] = data[3];
2532  }
2533  break;
2534 
2535  case NT_float64:
2536  {
2537  PN_float64 *pi = (PN_float64 *)pointer;
2538  pi[0] = data[0];
2539  pi[1] = data[1];
2540  pi[2] = data[2];
2541  pi[3] = data[3];
2542  }
2543  break;
2544 
2545  case NT_stdfloat:
2546  nassertv(false);
2547  }
2548  break;
2549  }
2550 }
2551 
2552 ////////////////////////////////////////////////////////////////////
2553 // Function: GeomVertexColumn::Packer_point::set_data1d
2554 // Access: Public, Virtual
2555 // Description:
2556 ////////////////////////////////////////////////////////////////////
2557 void GeomVertexColumn::Packer_point::
2558 set_data1d(unsigned char *pointer, double data) {
2559  if (_column->get_num_values() == 4) {
2560  set_data4d(pointer, LVecBase4d(data, 0.0f, 0.0f, 1.0f));
2561  } else {
2562  Packer::set_data1d(pointer, data);
2563  }
2564 }
2565 
2566 ////////////////////////////////////////////////////////////////////
2567 // Function: GeomVertexColumn::Packer_point::set_data2d
2568 // Access: Public, Virtual
2569 // Description:
2570 ////////////////////////////////////////////////////////////////////
2571 void GeomVertexColumn::Packer_point::
2572 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
2573  if (_column->get_num_values() == 4) {
2574  set_data4d(pointer, LVecBase4d(data[0], data[1], 0.0f, 1.0f));
2575  } else {
2576  Packer::set_data2d(pointer, data);
2577  }
2578 }
2579 
2580 ////////////////////////////////////////////////////////////////////
2581 // Function: GeomVertexColumn::Packer_point::set_data3d
2582 // Access: Public, Virtual
2583 // Description:
2584 ////////////////////////////////////////////////////////////////////
2585 void GeomVertexColumn::Packer_point::
2586 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
2587  if (_column->get_num_values() == 4) {
2588  set_data4d(pointer, LVecBase4d(data[0], data[1], data[2], 1.0f));
2589  } else {
2590  Packer::set_data3d(pointer, data);
2591  }
2592 }
2593 
2594 ////////////////////////////////////////////////////////////////////
2595 // Function: GeomVertexColumn::Packer_point::set_data4d
2596 // Access: Public, Virtual
2597 // Description:
2598 ////////////////////////////////////////////////////////////////////
2599 void GeomVertexColumn::Packer_point::
2600 set_data4d(unsigned char *pointer, const LVecBase4d &data) {
2601  switch (_column->get_num_values()) {
2602  case 1:
2603  set_data1d(pointer, data[0] / data[3]);
2604  break;
2605 
2606  case 2:
2607  set_data2d(pointer, LVecBase2d(data[0] / data[3], data[1] / data[3]));
2608  break;
2609 
2610  case 3:
2611  set_data3d(pointer, LVecBase3d(data[0] / data[3], data[1] / data[3], data[2] / data[3]));
2612  break;
2613 
2614  default:
2615  switch (_column->get_numeric_type()) {
2616  case NT_uint8:
2617  maybe_unscale_color_d(data);
2618  pointer[0] = _a;
2619  pointer[1] = _b;
2620  pointer[2] = _c;
2621  pointer[3] = _d;
2622  break;
2623 
2624  case NT_uint16:
2625  {
2626  PN_uint16 *pi = (PN_uint16 *)pointer;
2627  pi[0] = (unsigned int)data[0];
2628  pi[1] = (unsigned int)data[1];
2629  pi[2] = (unsigned int)data[2];
2630  pi[3] = (unsigned int)data[3];
2631  }
2632  break;
2633 
2634  case NT_uint32:
2635  {
2636  PN_uint32 *pi = (PN_uint32 *)pointer;
2637  pi[0] = (unsigned int)data[0];
2638  pi[1] = (unsigned int)data[1];
2639  pi[2] = (unsigned int)data[2];
2640  pi[3] = (unsigned int)data[3];
2641  }
2642  break;
2643 
2644  case NT_packed_dcba:
2645  maybe_unscale_color_d(data);
2646  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _c, _b, _a);
2647  break;
2648 
2649  case NT_packed_dabc:
2650  maybe_unscale_color_d(data);
2651  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd(_d, _a, _b, _c);
2652  break;
2653 
2654  case NT_float32:
2655  {
2656  PN_float32 *pi = (PN_float32 *)pointer;
2657  pi[0] = data[0];
2658  pi[1] = data[1];
2659  pi[2] = data[2];
2660  pi[3] = data[3];
2661  }
2662  break;
2663 
2664  case NT_float64:
2665  {
2666  PN_float64 *pi = (PN_float64 *)pointer;
2667  pi[0] = data[0];
2668  pi[1] = data[1];
2669  pi[2] = data[2];
2670  pi[3] = data[3];
2671  }
2672  break;
2673 
2674  case NT_stdfloat:
2675  nassertv(false);
2676  }
2677  break;
2678  }
2679 }
2680 
2681 ////////////////////////////////////////////////////////////////////
2682 // Function: GeomVertexColumn::Packer_color::get_data4f
2683 // Access: Public, Virtual
2684 // Description:
2685 ////////////////////////////////////////////////////////////////////
2686 const LVecBase4f &GeomVertexColumn::Packer_color::
2687 get_data4f(const unsigned char *pointer) {
2688  switch (_column->get_num_values()) {
2689  case 1:
2690  _v4.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
2691  return _v4;
2692 
2693  case 2:
2694  {
2695  const LVecBase2f &v2 = get_data2f(pointer);
2696  _v4.set(v2[0], v2[1], 0.0f, 1.0f);
2697  }
2698  return _v4;
2699 
2700  case 3:
2701  {
2702  const LVecBase3f &v3 = get_data3f(pointer);
2703  _v4.set(v3[0], v3[1], v3[2], 1.0f);
2704  }
2705  return _v4;
2706 
2707  default:
2708  switch (_column->get_numeric_type()) {
2709  case NT_uint8:
2710  maybe_scale_color_f(pointer[0], pointer[1], pointer[2], pointer[3]);
2711  return _v4;
2712 
2713  case NT_uint16:
2714  {
2715  const PN_uint16 *pi = (const PN_uint16 *)pointer;
2716  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2717  }
2718  return _v4;
2719 
2720  case NT_uint32:
2721  {
2722  const PN_uint32 *pi = (const PN_uint32 *)pointer;
2723  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2724  }
2725  return _v4;
2726 
2727  case NT_packed_dcba:
2728  {
2729  PN_uint32 dword = *(const PN_uint32 *)pointer;
2730  maybe_scale_color_f(GeomVertexData::unpack_abcd_d(dword),
2734  }
2735  return _v4;
2736 
2737  case NT_packed_dabc:
2738  {
2739  PN_uint32 dword = *(const PN_uint32 *)pointer;
2740  maybe_scale_color_f(GeomVertexData::unpack_abcd_b(dword),
2744  }
2745  return _v4;
2746 
2747  case NT_float32:
2748  {
2749  const PN_float32 *pi = (const PN_float32 *)pointer;
2750  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2751  }
2752  return _v4;
2753 
2754  case NT_float64:
2755  {
2756  const PN_float64 *pi = (const PN_float64 *)pointer;
2757  _v4.set(pi[0], pi[1], pi[2], pi[3]);
2758  }
2759  return _v4;
2760 
2761  case NT_stdfloat:
2762  nassertr(false, _v4);
2763  }
2764  }
2765 
2766  return _v4;
2767 }
2768 
2769 ////////////////////////////////////////////////////////////////////
2770 // Function: GeomVertexColumn::Packer_color::get_data4d
2771 // Access: Public, Virtual
2772 // Description:
2773 ////////////////////////////////////////////////////////////////////
2774 const LVecBase4d &GeomVertexColumn::Packer_color::
2775 get_data4d(const unsigned char *pointer) {
2776  switch (_column->get_num_values()) {
2777  case 1:
2778  _v4d.set(get_data1i(pointer), 0.0f, 0.0f, 1.0f);
2779  return _v4d;
2780 
2781  case 2:
2782  {
2783  const LVecBase2f &v2 = get_data2f(pointer);
2784  _v4d.set(v2[0], v2[1], 0.0f, 1.0f);
2785  }
2786  return _v4d;
2787 
2788  case 3:
2789  {
2790  const LVecBase3f &v3 = get_data3f(pointer);
2791  _v4d.set(v3[0], v3[1], v3[2], 1.0f);
2792  }
2793  return _v4d;
2794 
2795  default:
2796  switch (_column->get_numeric_type()) {
2797  case NT_uint8:
2798  maybe_scale_color_d(pointer[0], pointer[1], pointer[2], pointer[3]);
2799  return _v4d;
2800 
2801  case NT_uint16:
2802  {
2803  const PN_uint16 *pi = (const PN_uint16 *)pointer;
2804  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2805  }
2806  return _v4d;
2807 
2808  case NT_uint32:
2809  {
2810  const PN_uint32 *pi = (const PN_uint32 *)pointer;
2811  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2812  }
2813  return _v4d;
2814 
2815  case NT_packed_dcba:
2816  {
2817  PN_uint32 dword = *(const PN_uint32 *)pointer;
2818  maybe_scale_color_d(GeomVertexData::unpack_abcd_d(dword),
2822  }
2823  return _v4d;
2824 
2825  case NT_packed_dabc:
2826  {
2827  PN_uint32 dword = *(const PN_uint32 *)pointer;
2828  maybe_scale_color_d(GeomVertexData::unpack_abcd_b(dword),
2832  }
2833  return _v4d;
2834 
2835  case NT_float32:
2836  {
2837  const PN_float32 *pi = (const PN_float32 *)pointer;
2838  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2839  }
2840  return _v4d;
2841 
2842  case NT_float64:
2843  {
2844  const PN_float64 *pi = (const PN_float64 *)pointer;
2845  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
2846  }
2847  return _v4d;
2848 
2849  case NT_stdfloat:
2850  nassertr(false, _v4d);
2851  }
2852  }
2853 
2854  return _v4d;
2855 }
2856 
2857 ////////////////////////////////////////////////////////////////////
2858 // Function: GeomVertexColumn::Packer_color::set_data1f
2859 // Access: Public, Virtual
2860 // Description:
2861 ////////////////////////////////////////////////////////////////////
2862 void GeomVertexColumn::Packer_color::
2863 set_data1f(unsigned char *pointer, float data) {
2864  if (_column->get_num_values() == 4) {
2865  set_data4f(pointer, LVecBase4f(data, 0.0f, 0.0f, 1.0f));
2866  } else {
2867  Packer::set_data1f(pointer, data);
2868  }
2869 }
2870 
2871 ////////////////////////////////////////////////////////////////////
2872 // Function: GeomVertexColumn::Packer_color::set_data2f
2873 // Access: Public, Virtual
2874 // Description:
2875 ////////////////////////////////////////////////////////////////////
2876 void GeomVertexColumn::Packer_color::
2877 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
2878  if (_column->get_num_values() == 4) {
2879  set_data4f(pointer, LVecBase4f(data[0], data[1], 0.0f, 1.0f));
2880  } else {
2881  Packer::set_data2f(pointer, data);
2882  }
2883 }
2884 
2885 ////////////////////////////////////////////////////////////////////
2886 // Function: GeomVertexColumn::Packer_color::set_data3f
2887 // Access: Public, Virtual
2888 // Description:
2889 ////////////////////////////////////////////////////////////////////
2890 void GeomVertexColumn::Packer_color::
2891 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
2892  if (_column->get_num_values() == 4) {
2893  set_data4f(pointer, LVecBase4f(data[0], data[1], data[2], 1.0f));
2894  } else {
2895  Packer::set_data3f(pointer, data);
2896  }
2897 }
2898 
2899 ////////////////////////////////////////////////////////////////////
2900 // Function: GeomVertexColumn::Packer_color::set_data1d
2901 // Access: Public, Virtual
2902 // Description:
2903 ////////////////////////////////////////////////////////////////////
2904 void GeomVertexColumn::Packer_color::
2905 set_data1d(unsigned char *pointer, double data) {
2906  if (_column->get_num_values() == 4) {
2907  set_data4d(pointer, LVecBase4d(data, 0.0f, 0.0f, 1.0f));
2908  } else {
2909  Packer::set_data1d(pointer, data);
2910  }
2911 }
2912 
2913 ////////////////////////////////////////////////////////////////////
2914 // Function: GeomVertexColumn::Packer_color::set_data2d
2915 // Access: Public, Virtual
2916 // Description:
2917 ////////////////////////////////////////////////////////////////////
2918 void GeomVertexColumn::Packer_color::
2919 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
2920  if (_column->get_num_values() == 4) {
2921  set_data4d(pointer, LVecBase4d(data[0], data[1], 0.0f, 1.0f));
2922  } else {
2923  Packer::set_data2d(pointer, data);
2924  }
2925 }
2926 
2927 ////////////////////////////////////////////////////////////////////
2928 // Function: GeomVertexColumn::Packer_color::set_data3d
2929 // Access: Public, Virtual
2930 // Description:
2931 ////////////////////////////////////////////////////////////////////
2932 void GeomVertexColumn::Packer_color::
2933 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
2934  if (_column->get_num_values() == 4) {
2935  set_data4d(pointer, LVecBase4d(data[0], data[1], data[2], 1.0f));
2936  } else {
2937  Packer::set_data3d(pointer, data);
2938  }
2939 }
2940 
2941 ////////////////////////////////////////////////////////////////////
2942 // Function: GeomVertexColumn::Packer_float32_3::get_data3f
2943 // Access: Public, Virtual
2944 // Description:
2945 ////////////////////////////////////////////////////////////////////
2946 const LVecBase3f &GeomVertexColumn::Packer_float32_3::
2947 get_data3f(const unsigned char *pointer) {
2948  const PN_float32 *pi = (const PN_float32 *)pointer;
2949  _v3.set(pi[0], pi[1], pi[2]);
2950  return _v3;
2951 }
2952 
2953 ////////////////////////////////////////////////////////////////////
2954 // Function: GeomVertexColumn::Packer_float32_3::set_data3f
2955 // Access: Public, Virtual
2956 // Description:
2957 ////////////////////////////////////////////////////////////////////
2958 void GeomVertexColumn::Packer_float32_3::
2959 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
2960  PN_float32 *pi = (PN_float32 *)pointer;
2961  pi[0] = data[0];
2962  pi[1] = data[1];
2963  pi[2] = data[2];
2964 }
2965 
2966 ////////////////////////////////////////////////////////////////////
2967 // Function: GeomVertexColumn::Packer_point_float32_2::get_data2f
2968 // Access: Public, Virtual
2969 // Description:
2970 ////////////////////////////////////////////////////////////////////
2971 const LVecBase2f &GeomVertexColumn::Packer_point_float32_2::
2972 get_data2f(const unsigned char *pointer) {
2973  const PN_float32 *pi = (const PN_float32 *)pointer;
2974  _v2.set(pi[0], pi[1]);
2975  return _v2;
2976 }
2977 
2978 ////////////////////////////////////////////////////////////////////
2979 // Function: GeomVertexColumn::Packer_point_float32_2::set_data2f
2980 // Access: Public, Virtual
2981 // Description:
2982 ////////////////////////////////////////////////////////////////////
2983 void GeomVertexColumn::Packer_point_float32_2::
2984 set_data2f(unsigned char *pointer, const LVecBase2f &data) {
2985  PN_float32 *pi = (PN_float32 *)pointer;
2986  pi[0] = data[0];
2987  pi[1] = data[1];
2988 }
2989 
2990 ////////////////////////////////////////////////////////////////////
2991 // Function: GeomVertexColumn::Packer_point_float32_3::get_data3f
2992 // Access: Public, Virtual
2993 // Description:
2994 ////////////////////////////////////////////////////////////////////
2995 const LVecBase3f &GeomVertexColumn::Packer_point_float32_3::
2996 get_data3f(const unsigned char *pointer) {
2997  const PN_float32 *pi = (const PN_float32 *)pointer;
2998  _v3.set(pi[0], pi[1], pi[2]);
2999  return _v3;
3000 }
3001 
3002 ////////////////////////////////////////////////////////////////////
3003 // Function: GeomVertexColumn::Packer_point_float32_3::set_data3f
3004 // Access: Public, Virtual
3005 // Description:
3006 ////////////////////////////////////////////////////////////////////
3007 void GeomVertexColumn::Packer_point_float32_3::
3008 set_data3f(unsigned char *pointer, const LVecBase3f &data) {
3009  PN_float32 *pi = (PN_float32 *)pointer;
3010  pi[0] = data[0];
3011  pi[1] = data[1];
3012  pi[2] = data[2];
3013 }
3014 
3015 ////////////////////////////////////////////////////////////////////
3016 // Function: GeomVertexColumn::Packer_point_float32_4::get_data4f
3017 // Access: Public, Virtual
3018 // Description:
3019 ////////////////////////////////////////////////////////////////////
3020 const LVecBase4f &GeomVertexColumn::Packer_point_float32_4::
3021 get_data4f(const unsigned char *pointer) {
3022  const PN_float32 *pi = (const PN_float32 *)pointer;
3023  _v4.set(pi[0], pi[1], pi[2], pi[3]);
3024  return _v4;
3025 }
3026 
3027 ////////////////////////////////////////////////////////////////////
3028 // Function: GeomVertexColumn::Packer_point_float32_4::set_data4f
3029 // Access: Public, Virtual
3030 // Description:
3031 ////////////////////////////////////////////////////////////////////
3032 void GeomVertexColumn::Packer_point_float32_4::
3033 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
3034  PN_float32 *pi = (PN_float32 *)pointer;
3035  pi[0] = data[0];
3036  pi[1] = data[1];
3037  pi[2] = data[2];
3038  pi[3] = data[3];
3039 }
3040 
3041 ////////////////////////////////////////////////////////////////////
3042 // Function: GeomVertexColumn::Packer_nativefloat_3::get_data3f
3043 // Access: Public, Virtual
3044 // Description:
3045 ////////////////////////////////////////////////////////////////////
3046 const LVecBase3f &GeomVertexColumn::Packer_nativefloat_3::
3047 get_data3f(const unsigned char *pointer) {
3048  return *(const LVecBase3f *)pointer;
3049 }
3050 
3051 ////////////////////////////////////////////////////////////////////
3052 // Function: GeomVertexColumn::Packer_point_nativefloat_2::get_data2f
3053 // Access: Public, Virtual
3054 // Description:
3055 ////////////////////////////////////////////////////////////////////
3056 const LVecBase2f &GeomVertexColumn::Packer_point_nativefloat_2::
3057 get_data2f(const unsigned char *pointer) {
3058  return *(const LVecBase2f *)pointer;
3059 }
3060 
3061 ////////////////////////////////////////////////////////////////////
3062 // Function: GeomVertexColumn::Packer_point_nativefloat_3::get_data3f
3063 // Access: Public, Virtual
3064 // Description:
3065 ////////////////////////////////////////////////////////////////////
3066 const LVecBase3f &GeomVertexColumn::Packer_point_nativefloat_3::
3067 get_data3f(const unsigned char *pointer) {
3068  return *(const LVecBase3f *)pointer;
3069 }
3070 
3071 ////////////////////////////////////////////////////////////////////
3072 // Function: GeomVertexColumn::Packer_point_nativefloat_4::get_data4f
3073 // Access: Public, Virtual
3074 // Description:
3075 ////////////////////////////////////////////////////////////////////
3076 const LVecBase4f &GeomVertexColumn::Packer_point_nativefloat_4::
3077 get_data4f(const unsigned char *pointer) {
3078  return *(const LVecBase4f *)pointer;
3079 }
3080 
3081 ////////////////////////////////////////////////////////////////////
3082 // Function: GeomVertexColumn::Packer_float64_3::get_data3d
3083 // Access: Public, Virtual
3084 // Description:
3085 ////////////////////////////////////////////////////////////////////
3086 const LVecBase3d &GeomVertexColumn::Packer_float64_3::
3087 get_data3d(const unsigned char *pointer) {
3088  const PN_float64 *pi = (const PN_float64 *)pointer;
3089  _v3d.set(pi[0], pi[1], pi[2]);
3090  return _v3d;
3091 }
3092 
3093 ////////////////////////////////////////////////////////////////////
3094 // Function: GeomVertexColumn::Packer_float64_3::set_data3d
3095 // Access: Public, Virtual
3096 // Description:
3097 ////////////////////////////////////////////////////////////////////
3098 void GeomVertexColumn::Packer_float64_3::
3099 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
3100  PN_float64 *pi = (PN_float64 *)pointer;
3101  pi[0] = data[0];
3102  pi[1] = data[1];
3103  pi[2] = data[2];
3104 }
3105 
3106 ////////////////////////////////////////////////////////////////////
3107 // Function: GeomVertexColumn::Packer_point_float64_2::get_data2d
3108 // Access: Public, Virtual
3109 // Description:
3110 ////////////////////////////////////////////////////////////////////
3111 const LVecBase2d &GeomVertexColumn::Packer_point_float64_2::
3112 get_data2d(const unsigned char *pointer) {
3113  const PN_float64 *pi = (const PN_float64 *)pointer;
3114  _v2d.set(pi[0], pi[1]);
3115  return _v2d;
3116 }
3117 
3118 ////////////////////////////////////////////////////////////////////
3119 // Function: GeomVertexColumn::Packer_point_float64_2::set_data2d
3120 // Access: Public, Virtual
3121 // Description:
3122 ////////////////////////////////////////////////////////////////////
3123 void GeomVertexColumn::Packer_point_float64_2::
3124 set_data2d(unsigned char *pointer, const LVecBase2d &data) {
3125  PN_float64 *pi = (PN_float64 *)pointer;
3126  pi[0] = data[0];
3127  pi[1] = data[1];
3128 }
3129 
3130 ////////////////////////////////////////////////////////////////////
3131 // Function: GeomVertexColumn::Packer_point_float64_3::get_data3d
3132 // Access: Public, Virtual
3133 // Description:
3134 ////////////////////////////////////////////////////////////////////
3135 const LVecBase3d &GeomVertexColumn::Packer_point_float64_3::
3136 get_data3d(const unsigned char *pointer) {
3137  const PN_float64 *pi = (const PN_float64 *)pointer;
3138  _v3d.set(pi[0], pi[1], pi[2]);
3139  return _v3d;
3140 }
3141 
3142 ////////////////////////////////////////////////////////////////////
3143 // Function: GeomVertexColumn::Packer_point_float64_3::set_data3d
3144 // Access: Public, Virtual
3145 // Description:
3146 ////////////////////////////////////////////////////////////////////
3147 void GeomVertexColumn::Packer_point_float64_3::
3148 set_data3d(unsigned char *pointer, const LVecBase3d &data) {
3149  PN_float64 *pi = (PN_float64 *)pointer;
3150  pi[0] = data[0];
3151  pi[1] = data[1];
3152  pi[2] = data[2];
3153 }
3154 
3155 ////////////////////////////////////////////////////////////////////
3156 // Function: GeomVertexColumn::Packer_point_float64_4::get_data4d
3157 // Access: Public, Virtual
3158 // Description:
3159 ////////////////////////////////////////////////////////////////////
3160 const LVecBase4d &GeomVertexColumn::Packer_point_float64_4::
3161 get_data4d(const unsigned char *pointer) {
3162  const PN_float64 *pi = (const PN_float64 *)pointer;
3163  _v4d.set(pi[0], pi[1], pi[2], pi[3]);
3164  return _v4d;
3165 }
3166 
3167 ////////////////////////////////////////////////////////////////////
3168 // Function: GeomVertexColumn::Packer_point_float64_4::set_data4d
3169 // Access: Public, Virtual
3170 // Description:
3171 ////////////////////////////////////////////////////////////////////
3172 void GeomVertexColumn::Packer_point_float64_4::
3173 set_data4d(unsigned char *pointer, const LVecBase4d &data) {
3174  PN_float64 *pi = (PN_float64 *)pointer;
3175  pi[0] = data[0];
3176  pi[1] = data[1];
3177  pi[2] = data[2];
3178  pi[3] = data[3];
3179 }
3180 
3181 ////////////////////////////////////////////////////////////////////
3182 // Function: GeomVertexColumn::Packer_nativedouble_3::get_data3d
3183 // Access: Public, Virtual
3184 // Description:
3185 ////////////////////////////////////////////////////////////////////
3186 const LVecBase3d &GeomVertexColumn::Packer_nativedouble_3::
3187 get_data3d(const unsigned char *pointer) {
3188  return *(const LVecBase3d *)pointer;
3189 }
3190 
3191 ////////////////////////////////////////////////////////////////////
3192 // Function: GeomVertexColumn::Packer_point_nativedouble_2::get_data2d
3193 // Access: Public, Virtual
3194 // Description:
3195 ////////////////////////////////////////////////////////////////////
3196 const LVecBase2d &GeomVertexColumn::Packer_point_nativedouble_2::
3197 get_data2d(const unsigned char *pointer) {
3198  return *(const LVecBase2d *)pointer;
3199 }
3200 
3201 ////////////////////////////////////////////////////////////////////
3202 // Function: GeomVertexColumn::Packer_point_nativedouble_3::get_data3d
3203 // Access: Public, Virtual
3204 // Description:
3205 ////////////////////////////////////////////////////////////////////
3206 const LVecBase3d &GeomVertexColumn::Packer_point_nativedouble_3::
3207 get_data3d(const unsigned char *pointer) {
3208  return *(const LVecBase3d *)pointer;
3209 }
3210 
3211 ////////////////////////////////////////////////////////////////////
3212 // Function: GeomVertexColumn::Packer_point_nativedouble_4::get_data4d
3213 // Access: Public, Virtual
3214 // Description:
3215 ////////////////////////////////////////////////////////////////////
3216 const LVecBase4d &GeomVertexColumn::Packer_point_nativedouble_4::
3217 get_data4d(const unsigned char *pointer) {
3218  return *(const LVecBase4d *)pointer;
3219 }
3220 
3221 ////////////////////////////////////////////////////////////////////
3222 // Function: GeomVertexColumn::Packer_argb_packed::get_data4f
3223 // Access: Public, Virtual
3224 // Description:
3225 ////////////////////////////////////////////////////////////////////
3226 const LVecBase4f &GeomVertexColumn::Packer_argb_packed::
3227 get_data4f(const unsigned char *pointer) {
3228  PN_uint32 dword = *(const PN_uint32 *)pointer;
3229  _v4.set((float)GeomVertexData::unpack_abcd_b(dword) / 255.0f,
3230  (float)GeomVertexData::unpack_abcd_c(dword) / 255.0f,
3231  (float)GeomVertexData::unpack_abcd_d(dword) / 255.0f,
3232  (float)GeomVertexData::unpack_abcd_a(dword) / 255.0f);
3233  return _v4;
3234 }
3235 
3236 ////////////////////////////////////////////////////////////////////
3237 // Function: GeomVertexColumn::Packer_argb_packed::set_data4f
3238 // Access: Public, Virtual
3239 // Description:
3240 ////////////////////////////////////////////////////////////////////
3241 void GeomVertexColumn::Packer_argb_packed::
3242 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
3243  // when packing an argb, we want to make sure we cap
3244  // the input values at 1 since going above one will cause
3245  // the value to be truncated.
3246  float newData[4];
3247  for (int i = 0; i < 4; i++) {
3248  if (data[i] > 1.0)
3249  newData[i] = 1.0;
3250  else
3251  newData[i] = data[i];
3252  }
3253  *(PN_uint32 *)pointer = GeomVertexData::pack_abcd
3254  ((unsigned int)(newData[3] * 255.0f),
3255  (unsigned int)(newData[0] * 255.0f),
3256  (unsigned int)(newData[1] * 255.0f),
3257  (unsigned int)(newData[2] * 255.0f));
3258 }
3259 
3260 ////////////////////////////////////////////////////////////////////
3261 // Function: GeomVertexColumn::Packer_rgba_uint8_4::get_data4f
3262 // Access: Public, Virtual
3263 // Description:
3264 ////////////////////////////////////////////////////////////////////
3265 const LVecBase4f &GeomVertexColumn::Packer_rgba_uint8_4::
3266 get_data4f(const unsigned char *pointer) {
3267  _v4.set((float)pointer[0] / 255.0f,
3268  (float)pointer[1] / 255.0f,
3269  (float)pointer[2] / 255.0f,
3270  (float)pointer[3] / 255.0f);
3271  return _v4;
3272 }
3273 
3274 ////////////////////////////////////////////////////////////////////
3275 // Function: GeomVertexColumn::Packer_rgba_uint8_4::set_data4f
3276 // Access: Public, Virtual
3277 // Description:
3278 ////////////////////////////////////////////////////////////////////
3279 void GeomVertexColumn::Packer_rgba_uint8_4::
3280 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
3281  pointer[0] = (unsigned int)(data[0] * 255.0f);
3282  pointer[1] = (unsigned int)(data[1] * 255.0f);
3283  pointer[2] = (unsigned int)(data[2] * 255.0f);
3284  pointer[3] = (unsigned int)(data[3] * 255.0f);
3285 }
3286 
3287 ////////////////////////////////////////////////////////////////////
3288 // Function: GeomVertexColumn::Packer_rgba_float32_4::get_data4f
3289 // Access: Public, Virtual
3290 // Description:
3291 ////////////////////////////////////////////////////////////////////
3292 const LVecBase4f &GeomVertexColumn::Packer_rgba_float32_4::
3293 get_data4f(const unsigned char *pointer) {
3294  const PN_float32 *pi = (const PN_float32 *)pointer;
3295  _v4.set(pi[0], pi[1], pi[2], pi[3]);
3296  return _v4;
3297 }
3298 
3299 ////////////////////////////////////////////////////////////////////
3300 // Function: GeomVertexColumn::Packer_rgba_float32_4::set_data4f
3301 // Access: Public, Virtual
3302 // Description:
3303 ////////////////////////////////////////////////////////////////////
3304 void GeomVertexColumn::Packer_rgba_float32_4::
3305 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
3306  PN_float32 *pi = (PN_float32 *)pointer;
3307  pi[0] = data[0];
3308  pi[1] = data[1];
3309  pi[2] = data[2];
3310  pi[3] = data[3];
3311 }
3312 
3313 ////////////////////////////////////////////////////////////////////
3314 // Function: GeomVertexColumn::Packer_rgba_nativefloat_4::get_data4f
3315 // Access: Public, Virtual
3316 // Description:
3317 ////////////////////////////////////////////////////////////////////
3318 const LVecBase4f &GeomVertexColumn::Packer_rgba_nativefloat_4::
3319 get_data4f(const unsigned char *pointer) {
3320  return *(const LVecBase4f *)pointer;
3321 }
3322 
3323 ////////////////////////////////////////////////////////////////////
3324 // Function: GeomVertexColumn::Packer_uint16_1::get_data1i
3325 // Access: Public, Virtual
3326 // Description:
3327 ////////////////////////////////////////////////////////////////////
3328 int GeomVertexColumn::Packer_uint16_1::
3329 get_data1i(const unsigned char *pointer) {
3330  return *(const PN_uint16 *)pointer;
3331 }
3332 
3333 ////////////////////////////////////////////////////////////////////
3334 // Function: GeomVertexColumn::Packer_uint16_1::set_data1i
3335 // Access: Public, Virtual
3336 // Description:
3337 ////////////////////////////////////////////////////////////////////
3338 void GeomVertexColumn::Packer_uint16_1::
3339 set_data1i(unsigned char *pointer, int data) {
3340  *(PN_uint16 *)pointer = data;
3341  nassertv(*(PN_uint16 *)pointer == data);
3342 }
This is the base class for all three-component vectors and points.
Definition: lvecBase3.h:105
void add_uint8(PN_uint8 value)
Adds an unsigned 8-bit integer to the datagram.
Definition: datagram.I:138
void fillin(DatagramIterator &scan, BamReader *manager)
This internal function is called by make_from_bam to read in all of the relevant data from the BamFil...
This is the fundamental interface for extracting binary objects from a Bam file, as generated by a Ba...
Definition: bamReader.h:122
void set_contents(Contents contents)
Changes the semantic meaning of an existing column.
static PN_uint32 pack_abcd(unsigned int a, unsigned int b, unsigned int c, unsigned int d)
Packs four values in a DirectX-style NT_packed_abcd value.
This is the base class for all two-component vectors and points.
Definition: lvecBase2.h:1241
Base class for objects that can be written to and read from Bam files.
Definition: typedWritable.h:37
This is the base class for all two-component vectors and points.
Definition: lvecBase2.h:2328
const InternalName * get_name() const
Returns the name of this particular data field, e.g.
void set_start(int start)
Changes the start byte of an existing column.
This is the base class for all three-component vectors and points.
Definition: lvecBase4.h:1661
This is the fundamental interface for writing binary objects to a Bam file, to be extracted later by ...
Definition: bamWriter.h:73
void set_num_components(int num_components)
Changes the number of components of an existing column.
PN_uint8 get_uint8()
Extracts an unsigned 8-bit integer.
void write_datagram(BamWriter *manager, Datagram &dg)
Writes the contents of this object to the datagram for shipping out to a Bam file.
int get_num_components() const
Returns the number of components of the column: the number of instances of the NumericType in each el...
This is the base class for all three-component vectors and points.
Definition: lvecBase4.h:3162
This defines how a single column is interleaved within a vertex array stored within a Geom...
PN_uint16 get_uint16()
Extracts an unsigned 16-bit integer.
static unsigned int unpack_abcd_c(PN_uint32 data)
Returns the third packed value from a DirectX-style NT_packed_abcd.
void set_name(InternalName *name)
Replaces the name of an existing column.
This is the base class for all two-component vectors and points.
Definition: lvecBase2.h:105
This is the base class for all three-component vectors and points.
Definition: lvecBase3.h:1455
void add_uint16(PN_uint16 value)
Adds an unsigned 16-bit integer to the datagram.
Definition: datagram.I:181
This is the base class for all three-component vectors and points.
Definition: lvecBase4.h:111
This is the base class for all three-component vectors and points.
Definition: lvecBase3.h:2756
void set_numeric_type(NumericType numeric_type)
Changes the numeric type an existing column.
int get_num_values() const
Returns the number of numeric values of the column: the number of distinct numeric values that go int...
void set_column_alignment(int column_alignment)
Changes the column alignment of an existing column.
static unsigned int unpack_abcd_d(PN_uint32 data)
Returns the fourth packed value from a DirectX-style NT_packed_abcd.
Contents get_contents() const
Returns the token representing the semantic meaning of the stored value.
NumericType get_numeric_type() const
Returns the token representing the numeric type of the data storage.
static unsigned int unpack_abcd_b(PN_uint32 data)
Returns the second packed value from a DirectX-style NT_packed_abcd.
A class to retrieve the individual data elements previously stored in a Datagram. ...
static unsigned int unpack_abcd_a(PN_uint32 data)
Returns the first packed value from a DirectX-style NT_packed_abcd.
int get_file_minor_ver() const
Returns the minor version number of the Bam file currently being read.
Definition: bamReader.I:105
An ordered list of data elements, formatted in memory for transmission over a socket or writing to a ...
Definition: datagram.h:43
int complete_pointers(TypedWritable **plist, BamReader *manager)
Receives an array of pointers, one for each time manager-&gt;read_pointer() was called in fillin()...
void write_pointer(Datagram &packet, const TypedWritable *dest)
The interface for writing a pointer to another object to a Bam file.
Definition: bamWriter.cxx:279
void read_pointer(DatagramIterator &scan)
The interface for reading a pointer to another object from a Bam file.
Definition: bamReader.cxx:652