Panda3D
 All Classes Functions Variables Enumerations
geomVertexWriter.I
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 &copy) :
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 &copy) {
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 
 All Classes Functions Variables Enumerations