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