00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "geomVertexColumn.h"
00016 #include "geomVertexData.h"
00017 #include "bamReader.h"
00018 #include "bamWriter.h"
00019
00020
00021
00022
00023
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
00042
00043
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
00087
00088
00089
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;
00108 break;
00109
00110 case NT_uint32:
00111 _component_bytes = 4;
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;
00121 _num_values *= 4;
00122 break;
00123
00124 case NT_float32:
00125 _component_bytes = 4;
00126 break;
00127
00128 case NT_float64:
00129 _component_bytes = 8;
00130 break;
00131
00132 case NT_stdfloat:
00133 nassertv(false);
00134 break;
00135 }
00136
00137 if (_column_alignment < 1) {
00138
00139
00140
00141 _column_alignment = max(_component_bytes, (int)vertex_column_alignment);
00142 }
00143
00144
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
00155
00156
00157
00158
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
00167 switch (get_numeric_type()) {
00168 case NT_float32:
00169 if (sizeof(float) == sizeof(PN_float32)) {
00170
00171
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
00194
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
00244
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
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
00267
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
00282
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
00301
00302
00303
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
00317
00318
00319
00320
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
00333
00334
00335
00336
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
00357
00358
00359
00360 GeomVertexColumn::Packer::
00361 ~Packer() {
00362 }
00363
00364
00365
00366
00367
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
00408
00409
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
00477
00478
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
00556
00557
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
00644
00645
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
00686
00687
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
00755
00756
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
00834
00835
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
00922
00923
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
00964
00965
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
01040
01041
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
01133
01134
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
01245
01246
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
01299
01300
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
01370
01371
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
01447
01448
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
01534
01535
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
01588
01589
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
01659
01660
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
01736
01737
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
01823
01824
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
01879
01880
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
01950
01951
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
02026
02027
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
02110
02111
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
02125
02126
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
02141
02142
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
02157
02158
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
02245
02246
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
02260
02261
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
02276
02277
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
02292
02293
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
02380
02381
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
02394
02395
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
02408
02409
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
02422
02423
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
02509
02510
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
02523
02524
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
02537
02538
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
02551
02552
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
02638
02639
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
02726
02727
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
02814
02815
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
02828
02829
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
02842
02843
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
02856
02857
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
02870
02871
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
02884
02885
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
02898
02899
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
02910
02911
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
02923
02924
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
02935
02936
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
02947
02948
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
02959
02960
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
02972
02973
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
02984
02985
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
02998
02999
03000
03001 const LVecBase3f &GeomVertexColumn::Packer_nativefloat_3::
03002 get_data3f(const unsigned char *pointer) {
03003 return *(const LVecBase3f *)pointer;
03004 }
03005
03006
03007
03008
03009
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
03018
03019
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
03028
03029
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
03038
03039
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
03050
03051
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
03063
03064
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
03075
03076
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
03087
03088
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
03099
03100
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
03112
03113
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
03124
03125
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
03138
03139
03140
03141 const LVecBase3d &GeomVertexColumn::Packer_nativedouble_3::
03142 get_data3d(const unsigned char *pointer) {
03143 return *(const LVecBase3d *)pointer;
03144 }
03145
03146
03147
03148
03149
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
03158
03159
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
03168
03169
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
03178
03179
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
03193
03194
03195
03196 void GeomVertexColumn::Packer_argb_packed::
03197 set_data4f(unsigned char *pointer, const LVecBase4f &data) {
03198
03199
03200
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
03217
03218
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
03231
03232
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
03244
03245
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
03256
03257
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
03270
03271
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
03280
03281
03282
03283 int GeomVertexColumn::Packer_uint16_1::
03284 get_data1i(const unsigned char *pointer) {
03285 return *(const PN_uint16 *)pointer;
03286 }
03287
03288
03289
03290
03291
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 }