00001 // Filename: geomVertexWriter.I 00002 // Created by: drose (25Mar05) 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 00016 //////////////////////////////////////////////////////////////////// 00017 // Function: GeomVertexWriter::Default Constructor 00018 // Access: Published 00019 // Description: Constructs an invalid GeomVertexWriter. You must use 00020 // the assignment operator to assign a valid 00021 // GeomVertexWriter to this object before you can use 00022 // it. 00023 //////////////////////////////////////////////////////////////////// 00024 INLINE GeomVertexWriter:: 00025 GeomVertexWriter(Thread *current_thread) : 00026 _vertex_data(NULL), 00027 _current_thread(current_thread) 00028 { 00029 initialize(); 00030 } 00031 00032 //////////////////////////////////////////////////////////////////// 00033 // Function: GeomVertexWriter::Constructor 00034 // Access: Published 00035 // Description: Constructs a new writer to process the vertices of 00036 // the indicated data object. 00037 //////////////////////////////////////////////////////////////////// 00038 INLINE GeomVertexWriter:: 00039 GeomVertexWriter(GeomVertexData *vertex_data, Thread *current_thread) : 00040 _vertex_data(vertex_data), 00041 _current_thread(current_thread) 00042 { 00043 initialize(); 00044 } 00045 00046 //////////////////////////////////////////////////////////////////// 00047 // Function: GeomVertexWriter::Constructor 00048 // Access: Published 00049 // Description: Constructs a new writer to process the vertices of 00050 // the indicated data object. This flavor creates the 00051 // writer specifically to process the named data type. 00052 //////////////////////////////////////////////////////////////////// 00053 INLINE GeomVertexWriter:: 00054 GeomVertexWriter(GeomVertexData *vertex_data, const string &name, 00055 Thread *current_thread) : 00056 _vertex_data(vertex_data), 00057 _current_thread(current_thread) 00058 { 00059 initialize(); 00060 set_column(name); 00061 } 00062 00063 //////////////////////////////////////////////////////////////////// 00064 // Function: GeomVertexWriter::Constructor 00065 // Access: Published 00066 // Description: Constructs a new writer to process the vertices of 00067 // the indicated data object. This flavor creates the 00068 // writer specifically to process the named data type. 00069 //////////////////////////////////////////////////////////////////// 00070 INLINE GeomVertexWriter:: 00071 GeomVertexWriter(GeomVertexData *vertex_data, const InternalName *name, 00072 Thread *current_thread) : 00073 _vertex_data(vertex_data), 00074 _current_thread(current_thread) 00075 { 00076 initialize(); 00077 set_column(name); 00078 } 00079 00080 //////////////////////////////////////////////////////////////////// 00081 // Function: GeomVertexWriter::Constructor 00082 // Access: Published 00083 // Description: Constructs a new writer to process the vertices of 00084 // the indicated array only. 00085 //////////////////////////////////////////////////////////////////// 00086 INLINE GeomVertexWriter:: 00087 GeomVertexWriter(GeomVertexArrayData *array_data, 00088 Thread *current_thread) : 00089 _array_data(array_data), 00090 _current_thread(current_thread) 00091 { 00092 initialize(); 00093 } 00094 00095 //////////////////////////////////////////////////////////////////// 00096 // Function: GeomVertexWriter::Constructor 00097 // Access: Published 00098 // Description: Constructs a new writer to process the vertices of 00099 // the indicated array only. 00100 //////////////////////////////////////////////////////////////////// 00101 INLINE GeomVertexWriter:: 00102 GeomVertexWriter(GeomVertexArrayData *array_data, int column, 00103 Thread *current_thread) : 00104 _array_data(array_data), 00105 _current_thread(current_thread) 00106 { 00107 initialize(); 00108 set_column(column); 00109 } 00110 00111 //////////////////////////////////////////////////////////////////// 00112 // Function: GeomVertexWriter::Constructor 00113 // Access: Public 00114 // Description: Constructs a new writer to process the vertices of 00115 // the indicated data object. This flavor creates the 00116 // writer specifically to process the named data type. 00117 //////////////////////////////////////////////////////////////////// 00118 INLINE GeomVertexWriter:: 00119 GeomVertexWriter(GeomVertexDataPipelineWriter *data_writer, 00120 const InternalName *name) : 00121 _vertex_data(data_writer->get_object()), 00122 _current_thread(data_writer->get_current_thread()) 00123 { 00124 initialize(); 00125 const GeomVertexFormat *format = data_writer->get_format(); 00126 set_vertex_column(format->get_array_with(name), 00127 format->get_column(name), 00128 data_writer); 00129 } 00130 00131 //////////////////////////////////////////////////////////////////// 00132 // Function: GeomVertexWriter::Copy Constructor 00133 // Access: Published 00134 // Description: 00135 //////////////////////////////////////////////////////////////////// 00136 INLINE GeomVertexWriter:: 00137 GeomVertexWriter(const GeomVertexWriter ©) : 00138 _vertex_data(copy._vertex_data), 00139 _array(copy._array), 00140 _array_data(copy._array_data), 00141 _current_thread(copy._current_thread), 00142 _packer(copy._packer), 00143 _stride(copy._stride), 00144 _handle(copy._handle), 00145 _pointer_begin(copy._pointer_begin), 00146 _pointer_end(copy._pointer_end), 00147 _pointer(copy._pointer), 00148 _start_row(copy._start_row) 00149 { 00150 } 00151 00152 //////////////////////////////////////////////////////////////////// 00153 // Function: GeomVertexWriter::Copy Assignment Operator 00154 // Access: Published 00155 // Description: 00156 //////////////////////////////////////////////////////////////////// 00157 INLINE void GeomVertexWriter:: 00158 operator = (const GeomVertexWriter ©) { 00159 _vertex_data = copy._vertex_data; 00160 _array = copy._array; 00161 _array_data = copy._array_data; 00162 _current_thread = copy._current_thread; 00163 _packer = copy._packer; 00164 _stride = copy._stride; 00165 _handle = copy._handle; 00166 _pointer_begin = copy._pointer_begin; 00167 _pointer_end = copy._pointer_end; 00168 _pointer = copy._pointer; 00169 _start_row = copy._start_row; 00170 } 00171 00172 //////////////////////////////////////////////////////////////////// 00173 // Function: GeomVertexWriter::Destructor 00174 // Access: Published 00175 // Description: 00176 //////////////////////////////////////////////////////////////////// 00177 INLINE GeomVertexWriter:: 00178 ~GeomVertexWriter() { 00179 } 00180 00181 //////////////////////////////////////////////////////////////////// 00182 // Function: GeomVertexWriter::get_vertex_data 00183 // Access: Published 00184 // Description: Returns the vertex data object that the 00185 // writer is processing. This may return NULL if the 00186 // writer was constructed with just an array pointer. 00187 //////////////////////////////////////////////////////////////////// 00188 INLINE GeomVertexData *GeomVertexWriter:: 00189 get_vertex_data() const { 00190 return _vertex_data; 00191 } 00192 00193 //////////////////////////////////////////////////////////////////// 00194 // Function: GeomVertexWriter::get_array_data 00195 // Access: Published 00196 // Description: Returns the particular array object that the 00197 // writer is currently processing. 00198 //////////////////////////////////////////////////////////////////// 00199 INLINE GeomVertexArrayData *GeomVertexWriter:: 00200 get_array_data() const { 00201 return _array_data; 00202 } 00203 00204 //////////////////////////////////////////////////////////////////// 00205 // Function: GeomVertexWriter::get_array_handle 00206 // Access: Published 00207 // Description: Returns the write handle to the array object that the 00208 // writer is currently processing. This low-level call 00209 // should be used with caution; be careful with 00210 // modifying the data in the handle out from under the 00211 // GeomVertexWriter. 00212 //////////////////////////////////////////////////////////////////// 00213 INLINE GeomVertexArrayDataHandle *GeomVertexWriter:: 00214 get_array_handle() const { 00215 return _handle; 00216 } 00217 00218 //////////////////////////////////////////////////////////////////// 00219 // Function: GeomVertexWriter::get_stride 00220 // Access: Published 00221 // Description: Returns the per-row stride (bytes between consecutive 00222 // rows) of the underlying vertex array. This low-level 00223 // information is normally not needed to use the 00224 // GeomVertexWriter directly. 00225 //////////////////////////////////////////////////////////////////// 00226 INLINE size_t GeomVertexWriter:: 00227 get_stride() const { 00228 return _stride; 00229 } 00230 00231 //////////////////////////////////////////////////////////////////// 00232 // Function: GeomVertexWriter::get_current_thread 00233 // Access: Published 00234 // Description: Returns the Thread pointer of the currently-executing 00235 // thread, as passed to the constructor of this object. 00236 //////////////////////////////////////////////////////////////////// 00237 INLINE Thread *GeomVertexWriter:: 00238 get_current_thread() const { 00239 return _current_thread; 00240 } 00241 00242 //////////////////////////////////////////////////////////////////// 00243 // Function: GeomVertexWriter::set_column 00244 // Access: Published 00245 // Description: Sets up the writer to use the nth data type of the 00246 // GeomVertexFormat, numbering from 0. 00247 // 00248 // This also resets the write row number to the start 00249 // row (the same value passed to a previous call to 00250 // set_row(), or 0 if set_row() was never called.) 00251 // 00252 // The return value is true if the data type is valid, 00253 // false otherwise. 00254 //////////////////////////////////////////////////////////////////// 00255 INLINE bool GeomVertexWriter:: 00256 set_column(int column) { 00257 if (_vertex_data != (GeomVertexData *)NULL) { 00258 GeomVertexDataPipelineWriter writer(_vertex_data, true, _current_thread); 00259 writer.check_array_writers(); 00260 const GeomVertexFormat *format = writer.get_format(); 00261 return set_vertex_column(format->get_array_with(column), 00262 format->get_column(column), 00263 &writer); 00264 } 00265 if (_array_data != (GeomVertexArrayData *)NULL) { 00266 return set_array_column(_array_data->get_array_format()->get_column(column)); 00267 } 00268 return false; 00269 } 00270 00271 //////////////////////////////////////////////////////////////////// 00272 // Function: GeomVertexWriter::set_column 00273 // Access: Published 00274 // Description: Sets up the writer to use the data type with the 00275 // indicated name. 00276 // 00277 // This also resets the write row number to the start 00278 // row (the same value passed to a previous call to 00279 // set_row(), or 0 if set_row() was never called.) 00280 // 00281 // The return value is true if the data type is valid, 00282 // false otherwise. 00283 //////////////////////////////////////////////////////////////////// 00284 INLINE bool GeomVertexWriter:: 00285 set_column(const string &name) { 00286 return set_column(InternalName::make(name)); 00287 } 00288 00289 //////////////////////////////////////////////////////////////////// 00290 // Function: GeomVertexWriter::set_column 00291 // Access: Published 00292 // Description: Sets up the writer to use the data type with the 00293 // indicated name. 00294 // 00295 // This also resets the write number to the start row 00296 // (the same value passed to a previous call to 00297 // set_row(), or 0 if set_row() was never called.) 00298 // 00299 // The return value is true if the data type is valid, 00300 // false otherwise. 00301 //////////////////////////////////////////////////////////////////// 00302 INLINE bool GeomVertexWriter:: 00303 set_column(const InternalName *name) { 00304 if (_vertex_data != (GeomVertexData *)NULL) { 00305 GeomVertexDataPipelineWriter writer(_vertex_data, true, _current_thread); 00306 writer.check_array_writers(); 00307 const GeomVertexFormat *format = writer.get_format(); 00308 return set_vertex_column(format->get_array_with(name), 00309 format->get_column(name), 00310 &writer); 00311 } 00312 if (_array_data != (GeomVertexArrayData *)NULL) { 00313 return set_array_column(_array_data->get_array_format()->get_column(name)); 00314 } 00315 return false; 00316 } 00317 00318 //////////////////////////////////////////////////////////////////// 00319 // Function: GeomVertexWriter::clear 00320 // Access: Published 00321 // Description: Resets the GeomVertexWriter to the initial state. 00322 //////////////////////////////////////////////////////////////////// 00323 INLINE void GeomVertexWriter:: 00324 clear() { 00325 (*this) = GeomVertexWriter(_current_thread); 00326 } 00327 00328 //////////////////////////////////////////////////////////////////// 00329 // Function: GeomVertexWriter::has_column 00330 // Access: Published 00331 // Description: Returns true if a valid data type has been 00332 // successfully set, or false if the data type does not 00333 // exist. 00334 //////////////////////////////////////////////////////////////////// 00335 INLINE bool GeomVertexWriter:: 00336 has_column() const { 00337 return (_packer != (GeomVertexColumn::Packer *)NULL); 00338 } 00339 00340 //////////////////////////////////////////////////////////////////// 00341 // Function: GeomVertexWriter::get_array 00342 // Access: Published 00343 // Description: Returns the array index containing the data type that 00344 // the writer is working on. 00345 //////////////////////////////////////////////////////////////////// 00346 INLINE int GeomVertexWriter:: 00347 get_array() const { 00348 return _array; 00349 } 00350 00351 //////////////////////////////////////////////////////////////////// 00352 // Function: GeomVertexWriter::get_column 00353 // Access: Published 00354 // Description: Returns the description of the data type that the 00355 // writer is working on. 00356 //////////////////////////////////////////////////////////////////// 00357 INLINE const GeomVertexColumn *GeomVertexWriter:: 00358 get_column() const { 00359 if (_packer != (GeomVertexColumn::Packer *)NULL) { 00360 return _packer->_column; 00361 } 00362 return NULL; 00363 } 00364 00365 //////////////////////////////////////////////////////////////////// 00366 // Function: GeomVertexWriter::set_row_unsafe 00367 // Access: Published 00368 // Description: Sets the start row to the indicated value, without 00369 // internal checks. This is the same as set_row(), but 00370 // it does not check for the possibility that the array 00371 // has been reallocated internally for some reason; use 00372 // only when you are confident that the array is 00373 // unchanged and you really need every bit of available 00374 // performance. 00375 //////////////////////////////////////////////////////////////////// 00376 INLINE void GeomVertexWriter:: 00377 set_row_unsafe(int row) { 00378 _start_row = row; 00379 if (has_column()) { 00380 quick_set_pointer(_start_row); 00381 } 00382 } 00383 00384 //////////////////////////////////////////////////////////////////// 00385 // Function: GeomVertexWriter::set_row 00386 // Access: Published 00387 // Description: Sets the start row to the indicated value. The 00388 // writer will begin writing to the indicated row; 00389 // each subsequent set_data*() call will store the data 00390 // into the subsequent row. If set_column() is called, 00391 // the writer will return to this row. 00392 //////////////////////////////////////////////////////////////////// 00393 INLINE void GeomVertexWriter:: 00394 set_row(int row) { 00395 _start_row = row; 00396 if (has_column()) { 00397 set_pointer(_start_row); 00398 } 00399 } 00400 00401 //////////////////////////////////////////////////////////////////// 00402 // Function: GeomVertexWriter::get_start_row 00403 // Access: Published 00404 // Description: Returns the row index at which the writer 00405 // started. It will return to this row if you reset 00406 // the current column. 00407 //////////////////////////////////////////////////////////////////// 00408 INLINE int GeomVertexWriter:: 00409 get_start_row() const { 00410 return _start_row; 00411 } 00412 00413 //////////////////////////////////////////////////////////////////// 00414 // Function: GeomVertexWriter::get_write_row 00415 // Access: Published 00416 // Description: Returns the row index to which the data will be 00417 // written at the next call to set_data*() or 00418 // add_data*(). 00419 //////////////////////////////////////////////////////////////////// 00420 INLINE int GeomVertexWriter:: 00421 get_write_row() const { 00422 return (int)(_pointer - _pointer_begin) / _stride; 00423 } 00424 00425 //////////////////////////////////////////////////////////////////// 00426 // Function: GeomVertexWriter::is_at_end 00427 // Access: Published 00428 // Description: Returns true if the writer is currently at the end of 00429 // the list of vertices, false otherwise. If this is 00430 // true, another call to set_data*() will result in a 00431 // crash, but another call to add_data*() will add a new 00432 // row. 00433 //////////////////////////////////////////////////////////////////// 00434 INLINE bool GeomVertexWriter:: 00435 is_at_end() const { 00436 return _pointer >= _pointer_end; 00437 } 00438 00439 //////////////////////////////////////////////////////////////////// 00440 // Function: GeomVertexWriter::set_data1f 00441 // Access: Published 00442 // Description: Sets the write row to a particular 1-component 00443 // value, and advances the write row. 00444 // 00445 // It is an error for the write row to advance past 00446 // the end of data. 00447 //////////////////////////////////////////////////////////////////// 00448 INLINE void GeomVertexWriter:: 00449 set_data1f(float data) { 00450 nassertv(has_column()); 00451 _packer->set_data1f(inc_pointer(), data); 00452 } 00453 00454 //////////////////////////////////////////////////////////////////// 00455 // Function: GeomVertexWriter::set_data2f 00456 // Access: Published 00457 // Description: Sets the write row to a particular 2-component 00458 // value, and advances the write row. 00459 // 00460 // It is an error for the write row to advance past 00461 // the end of data. 00462 //////////////////////////////////////////////////////////////////// 00463 INLINE void GeomVertexWriter:: 00464 set_data2f(float x, float y) { 00465 set_data2f(LVecBase2f(x, y)); 00466 } 00467 00468 //////////////////////////////////////////////////////////////////// 00469 // Function: GeomVertexWriter::set_data2f 00470 // Access: Published 00471 // Description: Sets the write row to a particular 2-component 00472 // value, and advances the write row. 00473 // 00474 // It is an error for the write row to advance past 00475 // the end of data. 00476 //////////////////////////////////////////////////////////////////// 00477 INLINE void GeomVertexWriter:: 00478 set_data2f(const LVecBase2f &data) { 00479 nassertv(has_column()); 00480 _packer->set_data2f(inc_pointer(), data); 00481 } 00482 00483 //////////////////////////////////////////////////////////////////// 00484 // Function: GeomVertexWriter::set_data3f 00485 // Access: Published 00486 // Description: Sets the write row to a particular 3-component 00487 // value, and advances the write row. 00488 // 00489 // It is an error for the write row to advance past 00490 // the end of data. 00491 //////////////////////////////////////////////////////////////////// 00492 INLINE void GeomVertexWriter:: 00493 set_data3f(float x, float y, float z) { 00494 set_data3f(LVecBase3f(x, y, z)); 00495 } 00496 00497 //////////////////////////////////////////////////////////////////// 00498 // Function: GeomVertexWriter::set_data3f 00499 // Access: Published 00500 // Description: Sets the write row to a particular 3-component 00501 // value, and advances the write row. 00502 // 00503 // It is an error for the write row to advance past 00504 // the end of data. 00505 //////////////////////////////////////////////////////////////////// 00506 INLINE void GeomVertexWriter:: 00507 set_data3f(const LVecBase3f &data) { 00508 nassertv(has_column()); 00509 _packer->set_data3f(inc_pointer(), data); 00510 } 00511 00512 //////////////////////////////////////////////////////////////////// 00513 // Function: GeomVertexWriter::set_data4f 00514 // Access: Published 00515 // Description: Sets the write row to a particular 4-component 00516 // value, and advances the write row. 00517 // 00518 // It is an error for the write row to advance past 00519 // the end of data. 00520 //////////////////////////////////////////////////////////////////// 00521 INLINE void GeomVertexWriter:: 00522 set_data4f(float x, float y, float z, float w) { 00523 set_data4f(LVecBase4f(x, y, z, w)); 00524 } 00525 00526 //////////////////////////////////////////////////////////////////// 00527 // Function: GeomVertexWriter::set_data4f 00528 // Access: Published 00529 // Description: Sets the write row to a particular 4-component 00530 // value, and advances the write row. 00531 // 00532 // It is an error for the write row to advance past 00533 // the end of data. 00534 //////////////////////////////////////////////////////////////////// 00535 INLINE void GeomVertexWriter:: 00536 set_data4f(const LVecBase4f &data) { 00537 nassertv(has_column()); 00538 _packer->set_data4f(inc_pointer(), data); 00539 } 00540 00541 //////////////////////////////////////////////////////////////////// 00542 // Function: GeomVertexWriter::set_data1d 00543 // Access: Published 00544 // Description: Sets the write row to a particular 1-component 00545 // value, and advances the write row. 00546 // 00547 // It is an error for the write row to advance past 00548 // the end of data. 00549 //////////////////////////////////////////////////////////////////// 00550 INLINE void GeomVertexWriter:: 00551 set_data1d(double data) { 00552 nassertv(has_column()); 00553 _packer->set_data1d(inc_pointer(), data); 00554 } 00555 00556 //////////////////////////////////////////////////////////////////// 00557 // Function: GeomVertexWriter::set_data2d 00558 // Access: Published 00559 // Description: Sets the write row to a particular 2-component 00560 // value, and advances the write row. 00561 // 00562 // It is an error for the write row to advance past 00563 // the end of data. 00564 //////////////////////////////////////////////////////////////////// 00565 INLINE void GeomVertexWriter:: 00566 set_data2d(double x, double y) { 00567 set_data2d(LVecBase2d(x, y)); 00568 } 00569 00570 //////////////////////////////////////////////////////////////////// 00571 // Function: GeomVertexWriter::set_data2d 00572 // Access: Published 00573 // Description: Sets the write row to a particular 2-component 00574 // value, and advances the write row. 00575 // 00576 // It is an error for the write row to advance past 00577 // the end of data. 00578 //////////////////////////////////////////////////////////////////// 00579 INLINE void GeomVertexWriter:: 00580 set_data2d(const LVecBase2d &data) { 00581 nassertv(has_column()); 00582 _packer->set_data2d(inc_pointer(), data); 00583 } 00584 00585 //////////////////////////////////////////////////////////////////// 00586 // Function: GeomVertexWriter::set_data3d 00587 // Access: Published 00588 // Description: Sets the write row to a particular 3-component 00589 // value, and advances the write row. 00590 // 00591 // It is an error for the write row to advance past 00592 // the end of data. 00593 //////////////////////////////////////////////////////////////////// 00594 INLINE void GeomVertexWriter:: 00595 set_data3d(double x, double y, double z) { 00596 set_data3d(LVecBase3d(x, y, z)); 00597 } 00598 00599 //////////////////////////////////////////////////////////////////// 00600 // Function: GeomVertexWriter::set_data3d 00601 // Access: Published 00602 // Description: Sets the write row to a particular 3-component 00603 // value, and advances the write row. 00604 // 00605 // It is an error for the write row to advance past 00606 // the end of data. 00607 //////////////////////////////////////////////////////////////////// 00608 INLINE void GeomVertexWriter:: 00609 set_data3d(const LVecBase3d &data) { 00610 nassertv(has_column()); 00611 _packer->set_data3d(inc_pointer(), data); 00612 } 00613 00614 //////////////////////////////////////////////////////////////////// 00615 // Function: GeomVertexWriter::set_data4d 00616 // Access: Published 00617 // Description: Sets the write row to a particular 4-component 00618 // value, and advances the write row. 00619 // 00620 // It is an error for the write row to advance past 00621 // the end of data. 00622 //////////////////////////////////////////////////////////////////// 00623 INLINE void GeomVertexWriter:: 00624 set_data4d(double x, double y, double z, double w) { 00625 set_data4d(LVecBase4d(x, y, z, w)); 00626 } 00627 00628 //////////////////////////////////////////////////////////////////// 00629 // Function: GeomVertexWriter::set_data4d 00630 // Access: Published 00631 // Description: Sets the write row to a particular 4-component 00632 // value, and advances the write row. 00633 // 00634 // It is an error for the write row to advance past 00635 // the end of data. 00636 //////////////////////////////////////////////////////////////////// 00637 INLINE void GeomVertexWriter:: 00638 set_data4d(const LVecBase4d &data) { 00639 nassertv(has_column()); 00640 _packer->set_data4d(inc_pointer(), data); 00641 } 00642 00643 //////////////////////////////////////////////////////////////////// 00644 // Function: GeomVertexWriter::set_data1 00645 // Access: Published 00646 // Description: Sets the write row to a particular 1-component 00647 // value, and advances the write row. 00648 // 00649 // It is an error for the write row to advance past 00650 // the end of data. 00651 //////////////////////////////////////////////////////////////////// 00652 INLINE void GeomVertexWriter:: 00653 set_data1(PN_stdfloat data) { 00654 #ifndef STDFLOAT_DOUBLE 00655 set_data1f(data); 00656 #else 00657 set_data1d(data); 00658 #endif 00659 } 00660 00661 //////////////////////////////////////////////////////////////////// 00662 // Function: GeomVertexWriter::set_data2 00663 // Access: Published 00664 // Description: Sets the write row to a particular 2-component 00665 // value, and advances the write row. 00666 // 00667 // It is an error for the write row to advance past 00668 // the end of data. 00669 //////////////////////////////////////////////////////////////////// 00670 INLINE void GeomVertexWriter:: 00671 set_data2(PN_stdfloat x, PN_stdfloat y) { 00672 #ifndef STDFLOAT_DOUBLE 00673 set_data2f(x, y); 00674 #else 00675 set_data2d(x, y); 00676 #endif 00677 } 00678 00679 //////////////////////////////////////////////////////////////////// 00680 // Function: GeomVertexWriter::set_data2 00681 // Access: Published 00682 // Description: Sets the write row to a particular 2-component 00683 // value, and advances the write row. 00684 // 00685 // It is an error for the write row to advance past 00686 // the end of data. 00687 //////////////////////////////////////////////////////////////////// 00688 INLINE void GeomVertexWriter:: 00689 set_data2(const LVecBase2 &data) { 00690 #ifndef STDFLOAT_DOUBLE 00691 set_data2f(data); 00692 #else 00693 set_data2d(data); 00694 #endif 00695 } 00696 00697 //////////////////////////////////////////////////////////////////// 00698 // Function: GeomVertexWriter::set_data3 00699 // Access: Published 00700 // Description: Sets the write row to a particular 3-component 00701 // value, and advances the write row. 00702 // 00703 // It is an error for the write row to advance past 00704 // the end of data. 00705 //////////////////////////////////////////////////////////////////// 00706 INLINE void GeomVertexWriter:: 00707 set_data3(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) { 00708 #ifndef STDFLOAT_DOUBLE 00709 set_data3f(x, y, z); 00710 #else 00711 set_data3d(x, y, z); 00712 #endif 00713 } 00714 00715 //////////////////////////////////////////////////////////////////// 00716 // Function: GeomVertexWriter::set_data3 00717 // Access: Published 00718 // Description: Sets the write row to a particular 3-component 00719 // value, and advances the write row. 00720 // 00721 // It is an error for the write row to advance past 00722 // the end of data. 00723 //////////////////////////////////////////////////////////////////// 00724 INLINE void GeomVertexWriter:: 00725 set_data3(const LVecBase3 &data) { 00726 #ifndef STDFLOAT_DOUBLE 00727 set_data3f(data); 00728 #else 00729 set_data3d(data); 00730 #endif 00731 } 00732 00733 //////////////////////////////////////////////////////////////////// 00734 // Function: GeomVertexWriter::set_data4 00735 // Access: Published 00736 // Description: Sets the write row to a particular 4-component 00737 // value, and advances the write row. 00738 // 00739 // It is an error for the write row to advance past 00740 // the end of data. 00741 //////////////////////////////////////////////////////////////////// 00742 INLINE void GeomVertexWriter:: 00743 set_data4(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z, PN_stdfloat w) { 00744 #ifndef STDFLOAT_DOUBLE 00745 set_data4f(x, y, z, w); 00746 #else 00747 set_data4d(x, y, z, w); 00748 #endif 00749 } 00750 00751 //////////////////////////////////////////////////////////////////// 00752 // Function: GeomVertexWriter::set_data4 00753 // Access: Published 00754 // Description: Sets the write row to a particular 4-component 00755 // value, and advances the write row. 00756 // 00757 // It is an error for the write row to advance past 00758 // the end of data. 00759 //////////////////////////////////////////////////////////////////// 00760 INLINE void GeomVertexWriter:: 00761 set_data4(const LVecBase4 &data) { 00762 #ifndef STDFLOAT_DOUBLE 00763 set_data4f(data); 00764 #else 00765 set_data4d(data); 00766 #endif 00767 } 00768 00769 //////////////////////////////////////////////////////////////////// 00770 // Function: GeomVertexWriter::set_data1i 00771 // Access: Published 00772 // Description: Sets the write row to a particular 1-component 00773 // value, and advances the write row. 00774 // 00775 // It is an error for the write row to advance past 00776 // the end of data. 00777 //////////////////////////////////////////////////////////////////// 00778 INLINE void GeomVertexWriter:: 00779 set_data1i(int data) { 00780 nassertv(has_column()); 00781 _packer->set_data1i(inc_pointer(), data); 00782 } 00783 00784 //////////////////////////////////////////////////////////////////// 00785 // Function: GeomVertexWriter::set_data2i 00786 // Access: Published 00787 // Description: Sets the write row to a particular 2-component 00788 // value, and advances the write row. 00789 // 00790 // It is an error for the write row to advance past 00791 // the end of data. 00792 //////////////////////////////////////////////////////////////////// 00793 INLINE void GeomVertexWriter:: 00794 set_data2i(int a, int b) { 00795 nassertv(has_column()); 00796 _packer->set_data2i(inc_pointer(), a, b); 00797 } 00798 00799 //////////////////////////////////////////////////////////////////// 00800 // Function: GeomVertexWriter::set_data2i 00801 // Access: Published 00802 // Description: Sets the write row to a particular 2-component 00803 // value, and advances the write row. 00804 // 00805 // It is an error for the write row to advance past 00806 // the end of data. 00807 //////////////////////////////////////////////////////////////////// 00808 INLINE void GeomVertexWriter:: 00809 set_data2i(const int data[2]) { 00810 set_data2i(data[0], data[1]); 00811 } 00812 00813 //////////////////////////////////////////////////////////////////// 00814 // Function: GeomVertexWriter::set_data3i 00815 // Access: Published 00816 // Description: Sets the write row to a particular 3-component 00817 // value, and advances the write row. 00818 // 00819 // It is an error for the write row to advance past 00820 // the end of data. 00821 //////////////////////////////////////////////////////////////////// 00822 INLINE void GeomVertexWriter:: 00823 set_data3i(int a, int b, int c) { 00824 nassertv(has_column()); 00825 _packer->set_data3i(inc_pointer(), a, b, c); 00826 } 00827 00828 //////////////////////////////////////////////////////////////////// 00829 // Function: GeomVertexWriter::set_data3i 00830 // Access: Published 00831 // Description: Sets the write row to a particular 3-component 00832 // value, and advances the write row. 00833 // 00834 // It is an error for the write row to advance past 00835 // the end of data. 00836 //////////////////////////////////////////////////////////////////// 00837 INLINE void GeomVertexWriter:: 00838 set_data3i(const int data[3]) { 00839 set_data3i(data[0], data[1], data[2]); 00840 } 00841 00842 //////////////////////////////////////////////////////////////////// 00843 // Function: GeomVertexWriter::set_data4i 00844 // Access: Published 00845 // Description: Sets the write row to a particular 4-component 00846 // value, and advances the write row. 00847 // 00848 // It is an error for the write row to advance past 00849 // the end of data. 00850 //////////////////////////////////////////////////////////////////// 00851 INLINE void GeomVertexWriter:: 00852 set_data4i(int a, int b, int c, int d) { 00853 nassertv(has_column()); 00854 _packer->set_data4i(inc_pointer(), a, b, c, d); 00855 } 00856 00857 //////////////////////////////////////////////////////////////////// 00858 // Function: GeomVertexWriter::set_data4i 00859 // Access: Published 00860 // Description: Sets the write row to a particular 4-component 00861 // value, and advances the write row. 00862 // 00863 // It is an error for the write row to advance past 00864 // the end of data. 00865 //////////////////////////////////////////////////////////////////// 00866 INLINE void GeomVertexWriter:: 00867 set_data4i(const int data[4]) { 00868 set_data4i(data[0], data[1], data[2], data[3]); 00869 } 00870 00871 //////////////////////////////////////////////////////////////////// 00872 // Function: GeomVertexWriter::add_data1f 00873 // Access: Published 00874 // Description: Sets the write row to a particular 1-component 00875 // value, and advances the write row. 00876 // 00877 // If the write row advances past the end of data, 00878 // implicitly adds a new row to the data. 00879 //////////////////////////////////////////////////////////////////// 00880 INLINE void GeomVertexWriter:: 00881 add_data1f(float data) { 00882 nassertv(has_column()); 00883 _packer->set_data1f(inc_add_pointer(), data); 00884 } 00885 00886 //////////////////////////////////////////////////////////////////// 00887 // Function: GeomVertexWriter::add_data2f 00888 // Access: Published 00889 // Description: Sets the write row to a particular 2-component 00890 // value, and advances the write row. 00891 // 00892 // If the write row advances past the end of data, 00893 // implicitly adds a new row to the data. 00894 //////////////////////////////////////////////////////////////////// 00895 INLINE void GeomVertexWriter:: 00896 add_data2f(float x, float y) { 00897 add_data2f(LVecBase2f(x, y)); 00898 } 00899 00900 //////////////////////////////////////////////////////////////////// 00901 // Function: GeomVertexWriter::add_data2f 00902 // Access: Published 00903 // Description: Sets the write row to a particular 2-component 00904 // value, and advances the write row. 00905 // 00906 // If the write row advances past the end of data, 00907 // implicitly adds a new row to the data. 00908 //////////////////////////////////////////////////////////////////// 00909 INLINE void GeomVertexWriter:: 00910 add_data2f(const LVecBase2f &data) { 00911 nassertv(has_column()); 00912 _packer->set_data2f(inc_add_pointer(), data); 00913 } 00914 00915 //////////////////////////////////////////////////////////////////// 00916 // Function: GeomVertexWriter::add_data3f 00917 // Access: Published 00918 // Description: Sets the write row to a particular 3-component 00919 // value, and advances the write row. 00920 // 00921 // If the write row advances past the end of data, 00922 // implicitly adds a new row to the data. 00923 //////////////////////////////////////////////////////////////////// 00924 INLINE void GeomVertexWriter:: 00925 add_data3f(float x, float y, float z) { 00926 add_data3f(LVecBase3f(x, y, z)); 00927 } 00928 00929 //////////////////////////////////////////////////////////////////// 00930 // Function: GeomVertexWriter::add_data3f 00931 // Access: Published 00932 // Description: Sets the write row to a particular 3-component 00933 // value, and advances the write row. 00934 // 00935 // If the write row advances past the end of data, 00936 // implicitly adds a new row to the data. 00937 //////////////////////////////////////////////////////////////////// 00938 INLINE void GeomVertexWriter:: 00939 add_data3f(const LVecBase3f &data) { 00940 nassertv(has_column()); 00941 _packer->set_data3f(inc_add_pointer(), data); 00942 } 00943 00944 //////////////////////////////////////////////////////////////////// 00945 // Function: GeomVertexWriter::add_data4f 00946 // Access: Published 00947 // Description: Sets the write row to a particular 4-component 00948 // value, and advances the write row. 00949 // 00950 // If the write row advances past the end of data, 00951 // implicitly adds a new row to the data. 00952 //////////////////////////////////////////////////////////////////// 00953 INLINE void GeomVertexWriter:: 00954 add_data4f(float x, float y, float z, float w) { 00955 add_data4f(LVecBase4f(x, y, z, w)); 00956 } 00957 00958 //////////////////////////////////////////////////////////////////// 00959 // Function: GeomVertexWriter::add_data4f 00960 // Access: Published 00961 // Description: Sets the write row to a particular 4-component 00962 // value, and advances the write row. 00963 // 00964 // If the write row advances past the end of data, 00965 // implicitly adds a new row to the data. 00966 //////////////////////////////////////////////////////////////////// 00967 INLINE void GeomVertexWriter:: 00968 add_data4f(const LVecBase4f &data) { 00969 nassertv(has_column()); 00970 _packer->set_data4f(inc_add_pointer(), data); 00971 } 00972 00973 //////////////////////////////////////////////////////////////////// 00974 // Function: GeomVertexWriter::add_data1d 00975 // Access: Published 00976 // Description: Sets the write row to a particular 1-component 00977 // value, and advances the write row. 00978 // 00979 // If the write row advances past the end of data, 00980 // implicitly adds a new row to the data. 00981 //////////////////////////////////////////////////////////////////// 00982 INLINE void GeomVertexWriter:: 00983 add_data1d(double data) { 00984 nassertv(has_column()); 00985 _packer->set_data1d(inc_add_pointer(), data); 00986 } 00987 00988 //////////////////////////////////////////////////////////////////// 00989 // Function: GeomVertexWriter::add_data2d 00990 // Access: Published 00991 // Description: Sets the write row to a particular 2-component 00992 // value, and advances the write row. 00993 // 00994 // If the write row advances past the end of data, 00995 // implicitly adds a new row to the data. 00996 //////////////////////////////////////////////////////////////////// 00997 INLINE void GeomVertexWriter:: 00998 add_data2d(double x, double y) { 00999 add_data2d(LVecBase2d(x, y)); 01000 } 01001 01002 //////////////////////////////////////////////////////////////////// 01003 // Function: GeomVertexWriter::add_data2d 01004 // Access: Published 01005 // Description: Sets the write row to a particular 2-component 01006 // value, and advances the write row. 01007 // 01008 // If the write row advances past the end of data, 01009 // implicitly adds a new row to the data. 01010 //////////////////////////////////////////////////////////////////// 01011 INLINE void GeomVertexWriter:: 01012 add_data2d(const LVecBase2d &data) { 01013 nassertv(has_column()); 01014 _packer->set_data2d(inc_add_pointer(), data); 01015 } 01016 01017 //////////////////////////////////////////////////////////////////// 01018 // Function: GeomVertexWriter::add_data3d 01019 // Access: Published 01020 // Description: Sets the write row to a particular 3-component 01021 // value, and advances the write row. 01022 // 01023 // If the write row advances past the end of data, 01024 // implicitly adds a new row to the data. 01025 //////////////////////////////////////////////////////////////////// 01026 INLINE void GeomVertexWriter:: 01027 add_data3d(double x, double y, double z) { 01028 add_data3d(LVecBase3d(x, y, z)); 01029 } 01030 01031 //////////////////////////////////////////////////////////////////// 01032 // Function: GeomVertexWriter::add_data3d 01033 // Access: Published 01034 // Description: Sets the write row to a particular 3-component 01035 // value, and advances the write row. 01036 // 01037 // If the write row advances past the end of data, 01038 // implicitly adds a new row to the data. 01039 //////////////////////////////////////////////////////////////////// 01040 INLINE void GeomVertexWriter:: 01041 add_data3d(const LVecBase3d &data) { 01042 nassertv(has_column()); 01043 _packer->set_data3d(inc_add_pointer(), data); 01044 } 01045 01046 //////////////////////////////////////////////////////////////////// 01047 // Function: GeomVertexWriter::add_data4d 01048 // Access: Published 01049 // Description: Sets the write row to a particular 4-component 01050 // value, and advances the write row. 01051 // 01052 // If the write row advances past the end of data, 01053 // implicitly adds a new row to the data. 01054 //////////////////////////////////////////////////////////////////// 01055 INLINE void GeomVertexWriter:: 01056 add_data4d(double x, double y, double z, double w) { 01057 add_data4d(LVecBase4d(x, y, z, w)); 01058 } 01059 01060 //////////////////////////////////////////////////////////////////// 01061 // Function: GeomVertexWriter::add_data4d 01062 // Access: Published 01063 // Description: Sets the write row to a particular 4-component 01064 // value, and advances the write row. 01065 // 01066 // If the write row advances past the end of data, 01067 // implicitly adds a new row to the data. 01068 //////////////////////////////////////////////////////////////////// 01069 INLINE void GeomVertexWriter:: 01070 add_data4d(const LVecBase4d &data) { 01071 nassertv(has_column()); 01072 _packer->set_data4d(inc_add_pointer(), data); 01073 } 01074 01075 //////////////////////////////////////////////////////////////////// 01076 // Function: GeomVertexWriter::add_data1 01077 // Access: Published 01078 // Description: Sets the write row to a particular 1-component 01079 // value, and advances the write row. 01080 // 01081 // If the write row advances past the end of data, 01082 // implicitly adds a new row to the data. 01083 //////////////////////////////////////////////////////////////////// 01084 INLINE void GeomVertexWriter:: 01085 add_data1(PN_stdfloat data) { 01086 #ifndef STDFLOAT_DOUBLE 01087 add_data1f(data); 01088 #else 01089 add_data1d(data); 01090 #endif 01091 } 01092 01093 //////////////////////////////////////////////////////////////////// 01094 // Function: GeomVertexWriter::add_data2 01095 // Access: Published 01096 // Description: Sets the write row to a particular 2-component 01097 // value, and advances the write row. 01098 // 01099 // If the write row advances past the end of data, 01100 // implicitly adds a new row to the data. 01101 //////////////////////////////////////////////////////////////////// 01102 INLINE void GeomVertexWriter:: 01103 add_data2(PN_stdfloat x, PN_stdfloat y) { 01104 #ifndef STDFLOAT_DOUBLE 01105 add_data2f(x, y); 01106 #else 01107 add_data2d(x, y); 01108 #endif 01109 } 01110 01111 //////////////////////////////////////////////////////////////////// 01112 // Function: GeomVertexWriter::add_data2 01113 // Access: Published 01114 // Description: Sets the write row to a particular 2-component 01115 // value, and advances the write row. 01116 // 01117 // If the write row advances past the end of data, 01118 // implicitly adds a new row to the data. 01119 //////////////////////////////////////////////////////////////////// 01120 INLINE void GeomVertexWriter:: 01121 add_data2(const LVecBase2 &data) { 01122 #ifndef STDFLOAT_DOUBLE 01123 add_data2f(data); 01124 #else 01125 add_data2d(data); 01126 #endif 01127 } 01128 01129 //////////////////////////////////////////////////////////////////// 01130 // Function: GeomVertexWriter::add_data3 01131 // Access: Published 01132 // Description: Sets the write row to a particular 3-component 01133 // value, and advances the write row. 01134 // 01135 // If the write row advances past the end of data, 01136 // implicitly adds a new row to the data. 01137 //////////////////////////////////////////////////////////////////// 01138 INLINE void GeomVertexWriter:: 01139 add_data3(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) { 01140 #ifndef STDFLOAT_DOUBLE 01141 add_data3f(x, y, z); 01142 #else 01143 add_data3d(x, y, z); 01144 #endif 01145 } 01146 01147 //////////////////////////////////////////////////////////////////// 01148 // Function: GeomVertexWriter::add_data3 01149 // Access: Published 01150 // Description: Sets the write row to a particular 3-component 01151 // value, and advances the write row. 01152 // 01153 // If the write row advances past the end of data, 01154 // implicitly adds a new row to the data. 01155 //////////////////////////////////////////////////////////////////// 01156 INLINE void GeomVertexWriter:: 01157 add_data3(const LVecBase3 &data) { 01158 #ifndef STDFLOAT_DOUBLE 01159 add_data3f(data); 01160 #else 01161 add_data3d(data); 01162 #endif 01163 } 01164 01165 //////////////////////////////////////////////////////////////////// 01166 // Function: GeomVertexWriter::add_data4 01167 // Access: Published 01168 // Description: Sets the write row to a particular 4-component 01169 // value, and advances the write row. 01170 // 01171 // If the write row advances past the end of data, 01172 // implicitly adds a new row to the data. 01173 //////////////////////////////////////////////////////////////////// 01174 INLINE void GeomVertexWriter:: 01175 add_data4(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z, PN_stdfloat w) { 01176 #ifndef STDFLOAT_DOUBLE 01177 add_data4f(x, y, z, w); 01178 #else 01179 add_data4d(x, y, z, w); 01180 #endif 01181 } 01182 01183 //////////////////////////////////////////////////////////////////// 01184 // Function: GeomVertexWriter::add_data4 01185 // Access: Published 01186 // Description: Sets the write row to a particular 4-component 01187 // value, and advances the write row. 01188 // 01189 // If the write row advances past the end of data, 01190 // implicitly adds a new row to the data. 01191 //////////////////////////////////////////////////////////////////// 01192 INLINE void GeomVertexWriter:: 01193 add_data4(const LVecBase4 &data) { 01194 #ifndef STDFLOAT_DOUBLE 01195 add_data4f(data); 01196 #else 01197 add_data4d(data); 01198 #endif 01199 } 01200 01201 //////////////////////////////////////////////////////////////////// 01202 // Function: GeomVertexWriter::add_data1i 01203 // Access: Published 01204 // Description: Sets the write row to a particular 1-component 01205 // value, and advances the write row. 01206 // 01207 // If the write row advances past the end of data, 01208 // implicitly adds a new row to the data. 01209 //////////////////////////////////////////////////////////////////// 01210 INLINE void GeomVertexWriter:: 01211 add_data1i(int data) { 01212 nassertv(has_column()); 01213 _packer->set_data1i(inc_add_pointer(), data); 01214 } 01215 01216 //////////////////////////////////////////////////////////////////// 01217 // Function: GeomVertexWriter::add_data2i 01218 // Access: Published 01219 // Description: Sets the write row to a particular 2-component 01220 // value, and advances the write row. 01221 // 01222 // If the write row advances past the end of data, 01223 // implicitly adds a new row to the data. 01224 //////////////////////////////////////////////////////////////////// 01225 INLINE void GeomVertexWriter:: 01226 add_data2i(int a, int b) { 01227 nassertv(has_column()); 01228 _packer->set_data2i(inc_add_pointer(), a, b); 01229 } 01230 01231 //////////////////////////////////////////////////////////////////// 01232 // Function: GeomVertexWriter::add_data2i 01233 // Access: Published 01234 // Description: Sets the write row to a particular 2-component 01235 // value, and advances the write row. 01236 // 01237 // If the write row advances past the end of data, 01238 // implicitly adds a new row to the data. 01239 //////////////////////////////////////////////////////////////////// 01240 INLINE void GeomVertexWriter:: 01241 add_data2i(const int data[2]) { 01242 add_data2i(data[0], data[1]); 01243 } 01244 01245 //////////////////////////////////////////////////////////////////// 01246 // Function: GeomVertexWriter::add_data3i 01247 // Access: Published 01248 // Description: Sets the write row to a particular 3-component 01249 // value, and advances the write row. 01250 // 01251 // If the write row advances past the end of data, 01252 // implicitly adds a new row to the data. 01253 //////////////////////////////////////////////////////////////////// 01254 INLINE void GeomVertexWriter:: 01255 add_data3i(int a, int b, int c) { 01256 nassertv(has_column()); 01257 _packer->set_data3i(inc_add_pointer(), a, b, c); 01258 } 01259 01260 //////////////////////////////////////////////////////////////////// 01261 // Function: GeomVertexWriter::add_data3i 01262 // Access: Published 01263 // Description: Sets the write row to a particular 3-component 01264 // value, and advances the write row. 01265 // 01266 // If the write row advances past the end of data, 01267 // implicitly adds a new row to the data. 01268 //////////////////////////////////////////////////////////////////// 01269 INLINE void GeomVertexWriter:: 01270 add_data3i(const int data[3]) { 01271 add_data3i(data[0], data[1], data[2]); 01272 } 01273 01274 //////////////////////////////////////////////////////////////////// 01275 // Function: GeomVertexWriter::add_data4i 01276 // Access: Published 01277 // Description: Sets the write row to a particular 4-component 01278 // value, and advances the write row. 01279 // 01280 // If the write row advances past the end of data, 01281 // implicitly adds a new row to the data. 01282 //////////////////////////////////////////////////////////////////// 01283 INLINE void GeomVertexWriter:: 01284 add_data4i(int a, int b, int c, int d) { 01285 nassertv(has_column()); 01286 _packer->set_data4i(inc_add_pointer(), a, b, c, d); 01287 } 01288 01289 //////////////////////////////////////////////////////////////////// 01290 // Function: GeomVertexWriter::add_data4i 01291 // Access: Published 01292 // Description: Sets the write row to a particular 4-component 01293 // value, and advances the write row. 01294 // 01295 // If the write row advances past the end of data, 01296 // implicitly adds a new row to the data. 01297 //////////////////////////////////////////////////////////////////// 01298 INLINE void GeomVertexWriter:: 01299 add_data4i(const int data[4]) { 01300 add_data4i(data[0], data[1], data[2], data[3]); 01301 } 01302 01303 //////////////////////////////////////////////////////////////////// 01304 // Function: GeomVertexWriter::get_packer 01305 // Access: Protected 01306 // Description: Returns the writer's Packer object. 01307 //////////////////////////////////////////////////////////////////// 01308 INLINE GeomVertexColumn::Packer *GeomVertexWriter:: 01309 get_packer() const { 01310 return _packer; 01311 } 01312 01313 //////////////////////////////////////////////////////////////////// 01314 // Function: GeomVertexWriter::set_pointer 01315 // Access: Private 01316 // Description: Sets up the array pointers freshly from the source 01317 // object (in case they have been reallocated recently), 01318 // and sets the internal pointer to the indicated row. 01319 //////////////////////////////////////////////////////////////////// 01320 INLINE void GeomVertexWriter:: 01321 set_pointer(int row) { 01322 _pointer_begin = _handle->get_write_pointer(); 01323 _pointer_end = _pointer_begin + _handle->get_data_size_bytes(); 01324 quick_set_pointer(row); 01325 } 01326 01327 //////////////////////////////////////////////////////////////////// 01328 // Function: GeomVertexWriter::quick_set_pointer 01329 // Access: Private 01330 // Description: Sets up the internal pointer to the indicated row, 01331 // without first verifying that arrays haven't been 01332 // reallocated. 01333 //////////////////////////////////////////////////////////////////// 01334 INLINE void GeomVertexWriter:: 01335 quick_set_pointer(int row) { 01336 nassertv(has_column()); 01337 01338 #if defined(_DEBUG) 01339 // Make sure we still have the same pointer as stored in the array. 01340 nassertv(_pointer_begin == _handle->get_write_pointer()); 01341 #endif 01342 01343 _pointer = _pointer_begin + _packer->_column->get_start() + _stride * row; 01344 01345 #if defined(_DEBUG) 01346 // We have to allow the pointer to exceed the end by up to one row's 01347 // width, because the next call might be to add_data_*(). 01348 nassertv(_pointer_begin == _pointer_end || (_pointer - _packer->_column->get_start()) <= _pointer_end); 01349 #endif 01350 } 01351 01352 //////////////////////////////////////////////////////////////////// 01353 // Function: GeomVertexWriter::inc_pointer 01354 // Access: Private 01355 // Description: Increments to the next row, and returns the data 01356 // pointer as it was before incrementing. 01357 //////////////////////////////////////////////////////////////////// 01358 INLINE unsigned char *GeomVertexWriter:: 01359 inc_pointer() { 01360 #if defined(_DEBUG) 01361 nassertr(_pointer < _pointer_end, empty_buffer); 01362 // Make sure we still have the same pointer as stored in the array. 01363 nassertr(_pointer_begin == _handle->get_write_pointer(), empty_buffer); 01364 nassertr(_pointer < _pointer_begin + _handle->get_data_size_bytes(), empty_buffer); 01365 #endif 01366 01367 unsigned char *orig_pointer = _pointer; 01368 _pointer += _stride; 01369 return orig_pointer; 01370 } 01371 01372 //////////////////////////////////////////////////////////////////// 01373 // Function: GeomVertexWriter::inc_add_pointer 01374 // Access: Private 01375 // Description: Increments to the next row, and returns the data 01376 // pointer as it was before incrementing. If we are at 01377 // or past the end of data, implicitly adds more 01378 // rows first. 01379 //////////////////////////////////////////////////////////////////// 01380 INLINE unsigned char *GeomVertexWriter:: 01381 inc_add_pointer() { 01382 if (_pointer >= _pointer_end) { 01383 // Reset the data pointer. 01384 int write_row = get_write_row(); 01385 01386 if (_vertex_data != (GeomVertexData *)NULL) { 01387 // If we have a whole GeomVertexData, we must set the length of 01388 // all its arrays at once. 01389 _handle = NULL; 01390 GeomVertexDataPipelineWriter writer(_vertex_data, true, _current_thread); 01391 writer.check_array_writers(); 01392 writer.set_num_rows(max(write_row + 1, writer.get_num_rows())); 01393 _handle = writer.get_array_writer(_array); 01394 01395 } else { 01396 // Otherwise, we can get away with modifying only the one array 01397 // we're using. 01398 _handle->set_num_rows(max(write_row + 1, _handle->get_num_rows())); 01399 } 01400 01401 set_pointer(write_row); 01402 } 01403 return inc_pointer(); 01404 } 01405