historical/toontown-classic.git/panda/include/geomVertexReader.I
2024-01-16 11:20:27 -06:00

738 lines
20 KiB
Text

/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file geomVertexReader.I
* @author drose
* @date 2005-03-25
*/
/**
* Constructs an invalid GeomVertexReader. You must use the assignment
* operator to assign a valid GeomVertexReader to this object before you can
* use it.
*/
INLINE GeomVertexReader::
GeomVertexReader(Thread *current_thread) :
_vertex_data(nullptr),
_current_thread(current_thread)
{
initialize();
}
/**
* Constructs a new reader to process the vertices of the indicated data
* object.
*/
INLINE GeomVertexReader::
GeomVertexReader(const GeomVertexData *vertex_data,
Thread *current_thread) :
_vertex_data(vertex_data),
_current_thread(current_thread)
{
initialize();
}
/**
* Constructs a new reader to process the vertices of the indicated data
* object. This flavor creates the reader specifically to process the named
* data type.
*/
INLINE GeomVertexReader::
GeomVertexReader(const GeomVertexData *vertex_data,
CPT_InternalName name,
Thread *current_thread) :
_vertex_data(vertex_data),
_current_thread(current_thread)
{
initialize();
set_column(std::move(name));
}
/**
* Constructs a new reader to process the vertices of the indicated array
* only.
*/
INLINE GeomVertexReader::
GeomVertexReader(const GeomVertexArrayData *array_data,
Thread *current_thread) :
_array_data(array_data),
_current_thread(current_thread)
{
initialize();
}
/**
* Constructs a new reader to process the vertices of the indicated array
* only.
*/
INLINE GeomVertexReader::
GeomVertexReader(const GeomVertexArrayData *array_data, int column,
Thread *current_thread) :
_array_data(array_data),
_current_thread(current_thread)
{
initialize();
set_column(column);
}
/**
* Constructs a new reader to process the vertices of the indicated data
* object. This flavor creates the reader specifically to process the named
* data type.
*/
INLINE GeomVertexReader::
GeomVertexReader(const GeomVertexDataPipelineReader *data_reader,
const InternalName *name, bool force) :
_vertex_data(data_reader->get_object()),
_current_thread(data_reader->get_current_thread())
{
initialize();
_force = force;
const GeomVertexFormat *format = data_reader->get_format();
set_vertex_column(format->get_array_with(name),
format->get_column(name),
data_reader);
}
/**
*
*/
INLINE GeomVertexReader::
GeomVertexReader(const GeomVertexReader &copy) :
_vertex_data(copy._vertex_data),
_array(copy._array),
_array_data(copy._array_data),
_current_thread(copy._current_thread),
_packer(copy._packer),
_stride(copy._stride),
_handle(copy._handle),
_pointer_begin(copy._pointer_begin),
_pointer_end(copy._pointer_end),
_pointer(copy._pointer),
_start_row(copy._start_row),
_force(copy._force)
{
}
/**
*
*/
INLINE void GeomVertexReader::
operator = (const GeomVertexReader &copy) {
_vertex_data = copy._vertex_data;
_array = copy._array;
_array_data = copy._array_data;
_current_thread = copy._current_thread;
_packer = copy._packer;
_stride = copy._stride;
_handle = copy._handle;
_pointer_begin = copy._pointer_begin;
_pointer_end = copy._pointer_end;
_pointer = copy._pointer;
_start_row = copy._start_row;
_force = copy._force;
}
/**
*
*/
INLINE GeomVertexReader::
~GeomVertexReader() {
}
/**
* Returns the vertex data object that the reader is processing. This may
* return NULL if the reader was constructed with just an array pointer.
*/
INLINE const GeomVertexData *GeomVertexReader::
get_vertex_data() const {
return _vertex_data;
}
/**
* Returns the particular array object that the reader is currently
* processing.
*/
INLINE const GeomVertexArrayData *GeomVertexReader::
get_array_data() const {
return _array_data;
}
/**
* Returns the read handle to the array object that the read is currently
* processing. This low-level call should be used with caution.
*/
INLINE const GeomVertexArrayDataHandle *GeomVertexReader::
get_array_handle() const {
return _handle;
}
/**
* Returns the per-row stride (bytes between consecutive rows) of the
* underlying vertex array. This low-level information is normally not needed
* to use the GeomVertexReader directly.
*/
INLINE size_t GeomVertexReader::
get_stride() const {
return _stride;
}
/**
* Returns the Thread pointer of the currently-executing thread, as passed to
* the constructor of this object.
*/
INLINE Thread *GeomVertexReader::
get_current_thread() const {
return _current_thread;
}
/**
* Sets the value of the force flag. When this is true (the default), vertex
* data will be paged in from disk if necessary. When this is false, the
* GeomVertexData will simply return a failure code when attempting to read
* vertex data that is not resident (but will put it on the queue to become
* resident later).
*
* Normally, vertex data is always resident, so this will not be an issue. It
* is only possible for vertex data to be nonresident if you have enabled
* vertex paging via the GeomVertexArrayData and VertexDataPage interfaces.
*/
INLINE void GeomVertexReader::
set_force(bool force) {
_force = force;
}
/**
* Returns the value of the force flag. See set_force().
*/
INLINE bool GeomVertexReader::
get_force() const {
return _force;
}
/**
* Sets up the reader to use the nth data type of the GeomVertexFormat,
* numbering from 0.
*
* This also resets the read row number to the start row (the same value
* passed to a previous call to set_row(), or 0 if set_row() was never
* called.)
*
* The return value is true if the data type is valid, false otherwise.
*/
INLINE bool GeomVertexReader::
set_column(int column) {
if (_vertex_data != nullptr) {
GeomVertexDataPipelineReader reader(_vertex_data, _current_thread);
reader.check_array_readers();
const GeomVertexFormat *format = reader.get_format();
return set_vertex_column(format->get_array_with(column),
format->get_column(column),
&reader);
}
if (_array_data != nullptr) {
return set_array_column(_array_data->get_array_format()->get_column(column));
}
return false;
}
/**
* Sets up the reader to use the data type with the indicated name.
*
* This also resets the read row number to the start row (the same value
* passed to a previous call to set_row(), or 0 if set_row() was never
* called.)
*
* The return value is true if the data type is valid, false otherwise.
*/
INLINE bool GeomVertexReader::
set_column(CPT_InternalName name) {
if (_vertex_data != nullptr) {
GeomVertexDataPipelineReader reader(_vertex_data, _current_thread);
reader.check_array_readers();
const GeomVertexFormat *format = reader.get_format();
return set_vertex_column(format->get_array_with(name),
format->get_column(name),
&reader);
}
if (_array_data != nullptr) {
return set_array_column(_array_data->get_array_format()->get_column(name));
}
return false;
}
/**
* Resets the GeomVertexReader to the initial state.
*/
INLINE void GeomVertexReader::
clear() {
(*this) = GeomVertexReader(_current_thread);
}
/**
* Returns true if a valid data type has been successfully set, or false if
* the data type does not exist (or if get_force() is false and the vertex
* data is nonresident).
*/
INLINE bool GeomVertexReader::
has_column() const {
return (_packer != nullptr);
}
/**
* Returns the array index containing the data type that the reader is working
* on.
*/
INLINE int GeomVertexReader::
get_array() const {
return _array;
}
/**
* Returns the description of the data type that the reader is working on.
*/
INLINE const GeomVertexColumn *GeomVertexReader::
get_column() const {
if (_packer != nullptr) {
return _packer->_column;
}
return nullptr;
}
/**
* Sets the start row to the indicated value, without internal checks. This
* is the same as set_row(), but it does not check for the possibility that
* the array has been reallocated internally for some reason; use only when
* you are confident that the array is unchanged and you really need every bit
* of available performance.
*/
INLINE void GeomVertexReader::
set_row_unsafe(int row) {
_start_row = row;
if (has_column()) {
quick_set_pointer(_start_row);
}
}
/**
* Sets the start row to the indicated value. The reader will begin reading
* from the indicated row; each subsequent get_data*() call will return the
* data from the subsequent row. If set_column() is called, the reader will
* return to this row.
*/
INLINE void GeomVertexReader::
set_row(int row) {
nassertv(row >= 0);
_start_row = row;
if (has_column()) {
bool result = set_pointer(_start_row);
nassertv(result);
}
}
/**
* Returns the row index at which the reader started. It will return to this
* row if you reset the current column.
*/
INLINE int GeomVertexReader::
get_start_row() const {
return _start_row;
}
/**
* Returns the row index from which the data will be retrieved by the next
* call to get_data*().
*/
INLINE int GeomVertexReader::
get_read_row() const {
return (int)(_pointer - _pointer_begin) / _stride;
}
/**
* Returns true if the reader is currently at the end of the list of vertices,
* false otherwise. If this is true, another call to get_data*() will result
* in a crash.
*/
INLINE bool GeomVertexReader::
is_at_end() const {
return _pointer >= _pointer_end;
}
/**
* Returns the data associated with the read row, expressed as a 1-component
* value, and advances the read row.
*/
INLINE float GeomVertexReader::
get_data1f() {
nassertr(has_column(), 0.0f);
return _packer->get_data1f(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 2-component
* value, and advances the read row.
*/
INLINE const LVecBase2f &GeomVertexReader::
get_data2f() {
nassertr(has_column(), LVecBase2f::zero());
return _packer->get_data2f(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 3-component
* value, and advances the read row.
*/
INLINE const LVecBase3f &GeomVertexReader::
get_data3f() {
nassertr(has_column(), LVecBase3f::zero());
return _packer->get_data3f(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 4-component
* value, and advances the read row.
*/
INLINE const LVecBase4f &GeomVertexReader::
get_data4f() {
nassertr(has_column(), LVecBase4f::zero());
return _packer->get_data4f(inc_pointer());
}
/**
* Returns the 3-by-3 matrix associated with the read row and advances the
* read row. This is a special method that only works when the column in
* question contains a matrix of an appropriate size.
*/
INLINE LMatrix3f GeomVertexReader::
get_matrix3f() {
nassertr(has_column() &&
_packer->_column->get_contents() == C_matrix &&
_packer->_column->get_num_elements() >= 3,
LMatrix3f::ident_mat());
size_t col_stride = _packer->_column->get_element_stride();
const unsigned char *pointer = inc_pointer();
LMatrix3f mat;
mat.set_row(0, _packer->get_data3f(pointer));
pointer += col_stride;
mat.set_row(1, _packer->get_data3f(pointer));
pointer += col_stride;
mat.set_row(2, _packer->get_data3f(pointer));
return mat;
}
/**
* Returns the 4-by-4 matrix associated with the read row and advances the
* read row. This is a special method that only works when the column in
* question contains a matrix of an appropriate size.
*/
INLINE LMatrix4f GeomVertexReader::
get_matrix4f() {
nassertr(has_column() &&
_packer->_column->get_contents() == C_matrix &&
_packer->_column->get_num_elements() >= 4,
LMatrix4f::ident_mat());
size_t col_stride = _packer->_column->get_element_stride();
const unsigned char *pointer = inc_pointer();
LMatrix4f mat;
mat.set_row(0, _packer->get_data4f(pointer));
pointer += col_stride;
mat.set_row(1, _packer->get_data4f(pointer));
pointer += col_stride;
mat.set_row(2, _packer->get_data4f(pointer));
pointer += col_stride;
mat.set_row(3, _packer->get_data4f(pointer));
return mat;
}
/**
* Returns the data associated with the read row, expressed as a 1-component
* value, and advances the read row.
*/
INLINE double GeomVertexReader::
get_data1d() {
nassertr(has_column(), 0.0f);
return _packer->get_data1d(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 2-component
* value, and advances the read row.
*/
INLINE const LVecBase2d &GeomVertexReader::
get_data2d() {
nassertr(has_column(), LVecBase2d::zero());
return _packer->get_data2d(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 3-component
* value, and advances the read row.
*/
INLINE const LVecBase3d &GeomVertexReader::
get_data3d() {
nassertr(has_column(), LVecBase3d::zero());
return _packer->get_data3d(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 4-component
* value, and advances the read row.
*/
INLINE const LVecBase4d &GeomVertexReader::
get_data4d() {
nassertr(has_column(), LVecBase4d::zero());
return _packer->get_data4d(inc_pointer());
}
/**
* Returns the 3-by-3 matrix associated with the read row and advances the
* read row. This is a special method that only works when the column in
* question contains a matrix of an appropriate size.
*/
INLINE LMatrix3d GeomVertexReader::
get_matrix3d() {
nassertr(has_column() &&
_packer->_column->get_contents() == C_matrix &&
_packer->_column->get_num_elements() >= 3,
LMatrix3d::ident_mat());
size_t col_stride = _packer->_column->get_element_stride();
const unsigned char *pointer = inc_pointer();
LMatrix3d mat;
mat.set_row(0, _packer->get_data3d(pointer));
pointer += col_stride;
mat.set_row(1, _packer->get_data3d(pointer));
pointer += col_stride;
mat.set_row(2, _packer->get_data3d(pointer));
return mat;
}
/**
* Returns the 4-by-4 matrix associated with the read row and advances the
* read row. This is a special method that only works when the column in
* question contains a matrix of an appropriate size.
*/
INLINE LMatrix4d GeomVertexReader::
get_matrix4d() {
nassertr(has_column() &&
_packer->_column->get_contents() == C_matrix &&
_packer->_column->get_num_elements() >= 4,
LMatrix4d::ident_mat());
size_t col_stride = _packer->_column->get_element_stride();
const unsigned char *pointer = inc_pointer();
LMatrix4d mat;
mat.set_row(0, _packer->get_data4d(pointer));
pointer += col_stride;
mat.set_row(1, _packer->get_data4d(pointer));
pointer += col_stride;
mat.set_row(2, _packer->get_data4d(pointer));
pointer += col_stride;
mat.set_row(3, _packer->get_data4d(pointer));
return mat;
}
/**
* Returns the data associated with the read row, expressed as a 1-component
* value, and advances the read row.
*/
INLINE PN_stdfloat GeomVertexReader::
get_data1() {
#ifndef STDFLOAT_DOUBLE
return get_data1f();
#else
return get_data1d();
#endif
}
/**
* Returns the data associated with the read row, expressed as a 2-component
* value, and advances the read row.
*/
INLINE const LVecBase2 &GeomVertexReader::
get_data2() {
#ifndef STDFLOAT_DOUBLE
return get_data2f();
#else
return get_data2d();
#endif
}
/**
* Returns the data associated with the read row, expressed as a 3-component
* value, and advances the read row.
*/
INLINE const LVecBase3 &GeomVertexReader::
get_data3() {
#ifndef STDFLOAT_DOUBLE
return get_data3f();
#else
return get_data3d();
#endif
}
/**
* Returns the data associated with the read row, expressed as a 4-component
* value, and advances the read row.
*/
INLINE const LVecBase4 &GeomVertexReader::
get_data4() {
#ifndef STDFLOAT_DOUBLE
return get_data4f();
#else
return get_data4d();
#endif
}
/**
* Returns the 3-by-3 matrix associated with the read row and advances the
* read row. This is a special method that only works when the column in
* question contains a matrix of an appropriate size.
*/
INLINE LMatrix3 GeomVertexReader::
get_matrix3() {
#ifndef STDFLOAT_DOUBLE
return get_matrix3f();
#else
return get_matrix3d();
#endif
}
/**
* Returns the 4-by-4 matrix associated with the read row and advances the
* read row. This is a special method that only works when the column in
* question contains a matrix of an appropriate size.
*/
INLINE LMatrix4 GeomVertexReader::
get_matrix4() {
#ifndef STDFLOAT_DOUBLE
return get_matrix4f();
#else
return get_matrix4d();
#endif
}
/**
* Returns the data associated with the read row, expressed as a 1-component
* value, and advances the read row.
*/
INLINE int GeomVertexReader::
get_data1i() {
nassertr(has_column(), 0);
return _packer->get_data1i(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 2-component
* value, and advances the read row.
*/
INLINE const LVecBase2i &GeomVertexReader::
get_data2i() {
nassertr(has_column(), LVecBase2i::zero());
return _packer->get_data2i(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 3-component
* value, and advances the read row.
*/
INLINE const LVecBase3i &GeomVertexReader::
get_data3i() {
nassertr(has_column(), LVecBase3i::zero());
return _packer->get_data3i(inc_pointer());
}
/**
* Returns the data associated with the read row, expressed as a 4-component
* value, and advances the read row.
*/
INLINE const LVecBase4i &GeomVertexReader::
get_data4i() {
nassertr(has_column(), LVecBase4i::zero());
return _packer->get_data4i(inc_pointer());
}
/**
* Returns the reader's Packer object.
*/
INLINE GeomVertexColumn::Packer *GeomVertexReader::
get_packer() const {
return _packer;
}
/**
* Sets up the array pointers freshly from the source object (in case they
* have been reallocated recently), and sets the internal pointer to the
* indicated row.
*
* Returns true if successful, or false if the vertex data is not resident.
* If it returns false, the reader's internal column spec is cleared. It is
* only possible to return false if get_force() is false.
*/
INLINE bool GeomVertexReader::
set_pointer(int row) {
_pointer_begin = _handle->get_read_pointer(_force);
if (_pointer_begin == nullptr && _handle->get_data_size_bytes() != 0) {
// Vertex data is not resident.
set_column(0, nullptr);
return false;
}
// Vertex data is resident, or just empty.
_pointer_end = _pointer_begin + _handle->get_data_size_bytes();
quick_set_pointer(row);
return true;
}
/**
* Sets up the internal pointer to the indicated row, without first verifying
* that arrays haven't been reallocated.
*/
INLINE void GeomVertexReader::
quick_set_pointer(int row) {
nassertv(has_column() && (_pointer_begin != nullptr || row == 0));
#if defined(_DEBUG)
// Make sure we still have the same pointer as stored in the array.
nassertv(_pointer_begin == _handle->get_read_pointer(true));
#endif
_pointer = _pointer_begin + _packer->_column->get_start() + _stride * row;
#if defined(_DEBUG)
// We have to allow the pointer to exceed the end by up to one row's width.
// This wouldn't be legal on a plain GeomVertexReader, but it *is* legal for
// a GeomVertexRewriter.
nassertv(_pointer_begin == _pointer_end || (_pointer - _packer->_column->get_start()) <= _pointer_end);
#endif
}
/**
* Increments to the next row, and returns the data pointer as it was before
* incrementing.
*/
INLINE const unsigned char *GeomVertexReader::
inc_pointer() {
#if defined(_DEBUG)
nassertr(_pointer < _pointer_end, empty_buffer);
// Make sure we still have the same pointer as stored in the array.
nassertr(_pointer_begin == _handle->get_read_pointer(true), empty_buffer);
nassertr(_pointer < _pointer_begin + _handle->get_data_size_bytes(), empty_buffer);
#endif
const unsigned char *orig_pointer = _pointer;
_pointer += _stride;
return orig_pointer;
}