From 29b2dbc7423c20448de68209fec20cd7e38e1025 Mon Sep 17 00:00:00 2001 From: David Rose Date: Thu, 21 Apr 2005 22:20:33 +0000 Subject: [PATCH] transform palette -> transform table --- panda/src/char/character.cxx | 30 ++--- panda/src/char/character.h | 8 +- panda/src/display/graphicsStateGuardian.I | 2 +- panda/src/display/standardMunger.cxx | 22 +-- panda/src/dxgsg8/dxGeomMunger8.cxx | 2 +- panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx | 12 +- panda/src/egg2pg/eggLoader.cxx | 16 +-- panda/src/glstuff/glGeomMunger_src.cxx | 4 +- .../glstuff/glGraphicsStateGuardian_src.cxx | 20 +-- panda/src/gobj/Sources.pp | 12 +- panda/src/gobj/config_gobj.cxx | 12 +- panda/src/gobj/gobj_composite2.cxx | 4 +- panda/src/gobj/internalName.I | 6 +- panda/src/gobj/qpgeomVertexAnimationSpec.I | 4 +- panda/src/gobj/qpgeomVertexData.I | 64 ++++----- panda/src/gobj/qpgeomVertexData.cxx | 126 +++++++++--------- panda/src/gobj/qpgeomVertexData.h | 26 ++-- panda/src/gobj/sliderTable.I | 4 +- panda/src/gobj/sliderTable.h | 2 +- panda/src/gobj/transformBlend.h | 2 +- ...rmBlendPalette.I => transformBlendTable.I} | 52 ++++---- ...endPalette.cxx => transformBlendTable.cxx} | 114 ++++++++-------- ...rmBlendPalette.h => transformBlendTable.h} | 34 ++--- .../{transformPalette.I => transformTable.I} | 68 +++++----- ...ransformPalette.cxx => transformTable.cxx} | 114 ++++++++-------- .../{transformPalette.h => transformTable.h} | 28 ++-- panda/src/gobj/vertexTransform.cxx | 6 +- panda/src/gobj/vertexTransform.h | 8 +- 28 files changed, 402 insertions(+), 400 deletions(-) rename panda/src/gobj/{transformBlendPalette.I => transformBlendTable.I} (71%) rename panda/src/gobj/{transformBlendPalette.cxx => transformBlendTable.cxx} (78%) rename panda/src/gobj/{transformBlendPalette.h => transformBlendTable.h} (83%) rename panda/src/gobj/{transformPalette.I => transformTable.I} (68%) rename panda/src/gobj/{transformPalette.cxx => transformTable.cxx} (77%) rename panda/src/gobj/{transformPalette.h => transformTable.h} (83%) diff --git a/panda/src/char/character.cxx b/panda/src/char/character.cxx index 3c64b682e5..3515bef04a 100644 --- a/panda/src/char/character.cxx +++ b/panda/src/char/character.cxx @@ -388,8 +388,8 @@ copy_geom(const Geom *source, const Character *from) { PT(qpGeom) dest = new qpGeom(*qpsource); PT(qpGeomVertexData) vdata = dest->modify_vertex_data(); - vdata->set_transform_palette(redirect_transform_palette(vdata->get_transform_palette())); - vdata->set_transform_blend_palette(redirect_transform_blend_palette(vdata->get_transform_blend_palette())); + vdata->set_transform_table(redirect_transform_table(vdata->get_transform_table())); + vdata->set_transform_blend_table(redirect_transform_blend_table(vdata->get_transform_blend_table())); vdata->set_slider_table(redirect_slider_table(vdata->get_slider_table())); return dest.p(); @@ -498,19 +498,19 @@ copy_node_pointers(const Character *from, const Character::NodeMap &node_map) { } //////////////////////////////////////////////////////////////////// -// Function: Character::redirect_transform_palette +// Function: Character::redirect_transform_table // Access: Public -// Description: Creates a new TransformPalette, similar to the +// Description: Creates a new TransformTable, similar to the // indicated one, with the joint and slider pointers // redirected into this object. //////////////////////////////////////////////////////////////////// -CPT(TransformPalette) Character:: -redirect_transform_palette(const TransformPalette *source) { - if (source == (TransformPalette *)NULL) { +CPT(TransformTable) Character:: +redirect_transform_table(const TransformTable *source) { + if (source == (TransformTable *)NULL) { return NULL; } - PT(TransformPalette) dest = new TransformPalette(*source); + PT(TransformTable) dest = new TransformTable(*source); int num_transforms = dest->get_num_transforms(); for (int i = 0; i < num_transforms; ++i) { @@ -525,23 +525,23 @@ redirect_transform_palette(const TransformPalette *source) { } } - return TransformPalette::register_palette(dest); + return TransformTable::register_table(dest); } //////////////////////////////////////////////////////////////////// -// Function: Character::redirect_transform_blend_palette +// Function: Character::redirect_transform_blend_table // Access: Public -// Description: Creates a new TransformBlendPalette, similar to the +// Description: Creates a new TransformBlendTable, similar to the // indicated one, with the joint and slider pointers // redirected into this object. //////////////////////////////////////////////////////////////////// -CPT(TransformBlendPalette) Character:: -redirect_transform_blend_palette(const TransformBlendPalette *source) { - if (source == (TransformBlendPalette *)NULL) { +CPT(TransformBlendTable) Character:: +redirect_transform_blend_table(const TransformBlendTable *source) { + if (source == (TransformBlendTable *)NULL) { return NULL; } - PT(TransformBlendPalette) dest = new TransformBlendPalette(*source); + PT(TransformBlendTable) dest = new TransformBlendTable(*source); int num_blends = dest->get_num_blends(); for (int i = 0; i < num_blends; ++i) { diff --git a/panda/src/char/character.h b/panda/src/char/character.h index b1d1739594..5e2d7ce456 100644 --- a/panda/src/char/character.h +++ b/panda/src/char/character.h @@ -29,8 +29,8 @@ #include "pointerTo.h" #include "geom.h" #include "pStatCollector.h" -#include "transformPalette.h" -#include "transformBlendPalette.h" +#include "transformTable.h" +#include "transformBlendTable.h" #include "sliderTable.h" class CharacterJointBundle; @@ -84,8 +84,8 @@ private: const Character *from, NodeMap &node_map); PT(Geom) copy_geom(const Geom *source, const Character *from); void copy_node_pointers(const Character *from, const NodeMap &node_map); - CPT(TransformPalette) redirect_transform_palette(const TransformPalette *source); - CPT(TransformBlendPalette) redirect_transform_blend_palette(const TransformBlendPalette *source); + CPT(TransformTable) redirect_transform_table(const TransformTable *source); + CPT(TransformBlendTable) redirect_transform_blend_table(const TransformBlendTable *source); CPT(SliderTable) redirect_slider_table(const SliderTable *source); // These are the actual dynamic vertex pools for this Character's diff --git a/panda/src/display/graphicsStateGuardian.I b/panda/src/display/graphicsStateGuardian.I index de95fe96c7..b171c29c1e 100644 --- a/panda/src/display/graphicsStateGuardian.I +++ b/panda/src/display/graphicsStateGuardian.I @@ -246,7 +246,7 @@ get_max_vertex_transforms() const { // Function: GraphicsStateGuardian::get_max_vertex_transform_indices // Access: Published // Description: Returns the maximum number of transforms there may be -// in a single TransformPalette for this graphics +// in a single TransformTable for this graphics // hardware. If this number is 0 (but // get_max_transforms() is nonzero), then the graphics // hardware (or API) doesn't support indexed transforms, diff --git a/panda/src/display/standardMunger.cxx b/panda/src/display/standardMunger.cxx index 0e820ac258..74b86033d1 100644 --- a/panda/src/display/standardMunger.cxx +++ b/panda/src/display/standardMunger.cxx @@ -93,31 +93,31 @@ munge_data_impl(const qpGeomVertexData *data) { animation.get_animation_type() == AT_panda && new_data->get_slider_table() == (SliderTable *)NULL) { // Maybe we can animate the vertices with hardware. - const TransformBlendPalette *palette = new_data->get_transform_blend_palette(); - if (palette != (TransformBlendPalette *)NULL && - palette->get_max_simultaneous_transforms() <= + const TransformBlendTable *table = new_data->get_transform_blend_table(); + if (table != (TransformBlendTable *)NULL && + table->get_max_simultaneous_transforms() <= _gsg->get_max_vertex_transforms()) { if (matrix_palette && - palette->get_num_transforms() <= _gsg->get_max_vertex_transform_indices()) { + table->get_num_transforms() <= _gsg->get_max_vertex_transform_indices()) { - if (palette->get_num_transforms() == palette->get_max_simultaneous_transforms()) { + if (table->get_num_transforms() == table->get_max_simultaneous_transforms()) { // We can support an indexed palette, but since that won't // save us any per-vertex blends, go ahead and do a plain - // old nonindexed palette instead. - animation.set_hardware(palette->get_num_transforms(), false); + // old nonindexed table instead. + animation.set_hardware(table->get_num_transforms(), false); } else { // We can support an indexed palette, and that means we can // reduce the number of blends we have to specify for each // vertex. - animation.set_hardware(palette->get_max_simultaneous_transforms(), true); + animation.set_hardware(table->get_max_simultaneous_transforms(), true); } - } else if (palette->get_num_transforms() <= + } else if (table->get_num_transforms() <= _gsg->get_max_vertex_transforms()) { // We can't support an indexed palette, but we have few enough - // transforms that we can do a nonindexed palette. - animation.set_hardware(palette->get_num_transforms(), false); + // transforms that we can do a nonindexed table. + animation.set_hardware(table->get_num_transforms(), false); } } } diff --git a/panda/src/dxgsg8/dxGeomMunger8.cxx b/panda/src/dxgsg8/dxGeomMunger8.cxx index 0d9a3a5b8d..c205be5a4a 100644 --- a/panda/src/dxgsg8/dxGeomMunger8.cxx +++ b/panda/src/dxgsg8/dxGeomMunger8.cxx @@ -74,7 +74,7 @@ munge_format_impl(const qpGeomVertexFormat *orig, } if (animation.get_indexed_transforms()) { - // Also, if we'll be indexing into the transfom palette, reserve + // Also, if we'll be indexing into the transform table, reserve // space for the index. new_array_format->add_column (InternalName::get_transform_index(), 1, diff --git a/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx b/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx index fb378c07d7..8e6e67cf6e 100644 --- a/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx +++ b/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx @@ -2684,17 +2684,17 @@ begin_draw_primitives(const qpGeom *geom, const qpGeomMunger *munger, _pD3DDevice->SetRenderState(D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE); } - const TransformPalette *palette = vertex_data->get_transform_palette(); - if (palette != (TransformPalette *)NULL) { - for (int i = 0; i < palette->get_num_transforms(); i++) { + const TransformTable *table = vertex_data->get_transform_table(); + if (table != (TransformTable *)NULL) { + for (int i = 0; i < table->get_num_transforms(); i++) { LMatrix4f mat; - palette->get_transform(i)->mult_matrix(mat, _transform->get_mat()); + table->get_transform(i)->mult_matrix(mat, _transform->get_mat()); const D3DMATRIX *d3d_mat = (const D3DMATRIX *)mat.get_data(); _pD3DDevice->SetTransform(D3DTS_WORLDMATRIX(i), d3d_mat); } - // Setting the palette transforms steps on the world matrix, so - // we have to set a flag to reload the world matrix later. + // Setting the first animation matrix steps on the world matrix, + // so we have to set a flag to reload the world matrix later. _transform_stale = true; } _vertex_blending_enabled = true; diff --git a/panda/src/egg2pg/eggLoader.cxx b/panda/src/egg2pg/eggLoader.cxx index 8c39b3c825..dfcf007f49 100644 --- a/panda/src/egg2pg/eggLoader.cxx +++ b/panda/src/egg2pg/eggLoader.cxx @@ -89,7 +89,7 @@ #include "sheetNode.h" #include "look_at.h" #include "configVariableString.h" -#include "transformBlendPalette.h" +#include "transformBlendTable.h" #include "transformBlend.h" #include @@ -2037,14 +2037,14 @@ make_vertex_data(const EggRenderState *render_state, PT(qpGeomVertexFormat) temp_format = new qpGeomVertexFormat(array_format); - PT(TransformBlendPalette) blend_palette; + PT(TransformBlendTable) blend_table; PT(SliderTable) slider_table; string name = _data->get_egg_filename().get_basename_wo_extension(); if (is_dynamic) { - // If it's a dynamic object, we need a TransformBlendPalette and + // If it's a dynamic object, we need a TransformBlendTable and // maybe a SliderTable, and additional columns in the vertex data: - // one that indexes into the blend palette per vertex, and also + // one that indexes into the blend table per vertex, and also // one for each different type of morph delta. // Tell the format that we're setting it up for Panda-based @@ -2053,7 +2053,7 @@ make_vertex_data(const EggRenderState *render_state, animation.set_panda(); temp_format->set_animation(animation); - blend_palette = new TransformBlendPalette; + blend_table = new TransformBlendTable; PT(qpGeomVertexArrayFormat) anim_array_format = new qpGeomVertexArrayFormat; anim_array_format->add_column @@ -2134,7 +2134,7 @@ make_vertex_data(const EggRenderState *render_state, PT(qpGeomVertexData) vertex_data = new qpGeomVertexData(name, format, qpGeom::UH_static); - vertex_data->set_transform_blend_palette(blend_palette); + vertex_data->set_transform_blend_table(blend_table); if (slider_table != (SliderTable *)NULL) { vertex_data->set_slider_table(SliderTable::register_table(slider_table)); } @@ -2245,9 +2245,9 @@ make_vertex_data(const EggRenderState *render_state, } blend.normalize_weights(); - int palette_index = blend_palette->add_blend(blend); + int table_index = blend_table->add_blend(blend); gvw.set_column(InternalName::get_transform_blend()); - gvw.set_data1i(palette_index); + gvw.set_data1i(table_index); } } diff --git a/panda/src/glstuff/glGeomMunger_src.cxx b/panda/src/glstuff/glGeomMunger_src.cxx index e293856157..442ef46085 100644 --- a/panda/src/glstuff/glGeomMunger_src.cxx +++ b/panda/src/glstuff/glGeomMunger_src.cxx @@ -75,12 +75,14 @@ munge_format_impl(const qpGeomVertexFormat *orig, NT_float32, C_other); if (animation.get_indexed_transforms()) { - // Also, if we'll be indexing into the transform palette, reserve + // Also, if we'll be indexing into the transform table, reserve // space for the index. // TODO: We should examine the maximum palette index so we can // decide whether we need 16-bit indices. That implies saving // the maximum palette index, presumably in the AnimationSpec. + // At the moment, I don't think any existing hardware supports + // more than 255 indices anyway. new_array_format->add_column (InternalName::get_transform_index(), animation.get_num_transforms(), NT_uint8, C_index); diff --git a/panda/src/glstuff/glGraphicsStateGuardian_src.cxx b/panda/src/glstuff/glGraphicsStateGuardian_src.cxx index 13e7970b6c..13ea24317c 100644 --- a/panda/src/glstuff/glGraphicsStateGuardian_src.cxx +++ b/panda/src/glstuff/glGraphicsStateGuardian_src.cxx @@ -2221,8 +2221,8 @@ begin_draw_primitives(const qpGeom *geom, const qpGeomMunger *munger, GLP(Enable)(GL_VERTEX_BLEND_ARB); _glVertexBlendARB(animation.get_num_transforms() - 1); - const TransformPalette *palette = vertex_data->get_transform_palette(); - if (palette != (TransformPalette *)NULL) { + const TransformTable *table = vertex_data->get_transform_table(); + if (table != (TransformTable *)NULL) { if (animation.get_indexed_transforms()) { // We are loading the indexed matrix palette. The ARB decided // to change this interface from that for the list of @@ -2232,9 +2232,9 @@ begin_draw_primitives(const qpGeom *geom, const qpGeomMunger *munger, GLP(MatrixMode)(GL_MATRIX_PALETTE_ARB); - for (int i = 0; i < palette->get_num_transforms(); ++i) { + for (int i = 0; i < table->get_num_transforms(); ++i) { LMatrix4f mat; - palette->get_transform(i)->mult_matrix(mat, _transform->get_mat()); + table->get_transform(i)->mult_matrix(mat, _transform->get_mat()); _glCurrentPaletteMatrixARB(i); GLP(LoadMatrixf)(mat.get_data()); } @@ -2252,23 +2252,23 @@ begin_draw_primitives(const qpGeom *geom, const qpGeomMunger *munger, // GL_MODELVIEW0 and 1 are different than the rest. int i = 0; - if (i < palette->get_num_transforms()) { + if (i < table->get_num_transforms()) { LMatrix4f mat; - palette->get_transform(i)->mult_matrix(mat, _transform->get_mat()); + table->get_transform(i)->mult_matrix(mat, _transform->get_mat()); GLP(MatrixMode)(GL_MODELVIEW0_ARB); GLP(LoadMatrixf)(mat.get_data()); ++i; } - if (i < palette->get_num_transforms()) { + if (i < table->get_num_transforms()) { LMatrix4f mat; - palette->get_transform(i)->mult_matrix(mat, _transform->get_mat()); + table->get_transform(i)->mult_matrix(mat, _transform->get_mat()); GLP(MatrixMode)(GL_MODELVIEW1_ARB); GLP(LoadMatrixf)(mat.get_data()); ++i; } - while (i < palette->get_num_transforms()) { + while (i < table->get_num_transforms()) { LMatrix4f mat; - palette->get_transform(i)->mult_matrix(mat, _transform->get_mat()); + table->get_transform(i)->mult_matrix(mat, _transform->get_mat()); GLP(MatrixMode)(GL_MODELVIEW2_ARB + i - 2); GLP(LoadMatrixf)(mat.get_data()); ++i; diff --git a/panda/src/gobj/Sources.pp b/panda/src/gobj/Sources.pp index d4e70173e4..05b0fb0dc9 100644 --- a/panda/src/gobj/Sources.pp +++ b/panda/src/gobj/Sources.pp @@ -54,8 +54,8 @@ texturePool.I texturePool.h \ textureStage.I textureStage.h \ transformBlend.I transformBlend.h \ - transformBlendPalette.I transformBlendPalette.h \ - transformPalette.I transformPalette.h \ + transformBlendTable.I transformBlendTable.h \ + transformTable.I transformTable.h \ userVertexSlider.I userVertexSlider.h \ userVertexTransform.I userVertexTransform.h \ vertexBufferContext.I vertexBufferContext.h \ @@ -103,8 +103,8 @@ texture.cxx textureContext.cxx texturePool.cxx \ textureStage.cxx \ transformBlend.cxx \ - transformBlendPalette.cxx \ - transformPalette.cxx \ + transformBlendTable.cxx \ + transformTable.cxx \ userVertexSlider.cxx \ userVertexTransform.cxx \ vertexBufferContext.cxx \ @@ -156,8 +156,8 @@ texturePool.I texturePool.h \ textureStage.I textureStage.h \ transformBlend.I transformBlend.h \ - transformBlendPalette.I transformBlendPalette.h \ - transformPalette.I transformPalette.h \ + transformBlendTable.I transformBlendTable.h \ + transformTable.I transformTable.h \ userVertexSlider.I userVertexSlider.h \ userVertexTransform.I userVertexTransform.h \ vertexBufferContext.I vertexBufferContext.h \ diff --git a/panda/src/gobj/config_gobj.cxx b/panda/src/gobj/config_gobj.cxx index 1a1ff3c6a3..3a0040c0d9 100644 --- a/panda/src/gobj/config_gobj.cxx +++ b/panda/src/gobj/config_gobj.cxx @@ -44,8 +44,8 @@ #include "texture.h" #include "textureStage.h" #include "textureContext.h" -#include "transformBlendPalette.h" -#include "transformPalette.h" +#include "transformBlendTable.h" +#include "transformTable.h" #include "userVertexSlider.h" #include "userVertexTransform.h" #include "vertexTransform.h" @@ -278,8 +278,8 @@ ConfigureFn(config_gobj) { Texture::init_type(); dDrawable::init_type(); TextureStage::init_type(); - TransformBlendPalette::init_type(); - TransformPalette::init_type(); + TransformBlendTable::init_type(); + TransformTable::init_type(); UserVertexSlider::init_type(); UserVertexTransform::init_type(); VertexTransform::init_type(); @@ -316,8 +316,8 @@ ConfigureFn(config_gobj) { SliderTable::register_with_read_factory(); Texture::register_with_read_factory(); TextureStage::register_with_read_factory(); - TransformBlendPalette::register_with_read_factory(); - TransformPalette::register_with_read_factory(); + TransformBlendTable::register_with_read_factory(); + TransformTable::register_with_read_factory(); UserVertexSlider::register_with_read_factory(); UserVertexTransform::register_with_read_factory(); InternalName::register_with_read_factory(); diff --git a/panda/src/gobj/gobj_composite2.cxx b/panda/src/gobj/gobj_composite2.cxx index 3b3a0ed3b3..601c493ffc 100644 --- a/panda/src/gobj/gobj_composite2.cxx +++ b/panda/src/gobj/gobj_composite2.cxx @@ -18,8 +18,8 @@ #include "texturePool.cxx" #include "textureStage.cxx" #include "transformBlend.cxx" -#include "transformBlendPalette.cxx" -#include "transformPalette.cxx" +#include "transformBlendTable.cxx" +#include "transformTable.cxx" #include "userVertexSlider.cxx" #include "userVertexTransform.cxx" #include "vertexBufferContext.cxx" diff --git a/panda/src/gobj/internalName.I b/panda/src/gobj/internalName.I index f19527df3a..3dfa8aec0f 100644 --- a/panda/src/gobj/internalName.I +++ b/panda/src/gobj/internalName.I @@ -259,7 +259,7 @@ get_aspect_ratio() { // This is the column header for the integer // transform_blend index, which is used to define vertex // animation on the CPU by indexing to a particular -// vertex weighting from the TransformBlendPalette. +// vertex weighting from the TransformBlendTable. //////////////////////////////////////////////////////////////////// INLINE PT(InternalName) InternalName:: get_transform_blend() { @@ -299,9 +299,9 @@ get_transform_weight() { // with "transform_weight" to define vertex animation on // the graphics card. The transform_index value // specifies the nth transform, by lookup in the -// TransformPalette. The transform_index column may be +// TransformTable. The transform_index column may be // omitted, in which case the nth transform is the nth -// entry in the palette. +// entry in the table. //////////////////////////////////////////////////////////////////// INLINE PT(InternalName) InternalName:: get_transform_index() { diff --git a/panda/src/gobj/qpgeomVertexAnimationSpec.I b/panda/src/gobj/qpgeomVertexAnimationSpec.I index ed216ea409..2922155bc1 100644 --- a/panda/src/gobj/qpgeomVertexAnimationSpec.I +++ b/panda/src/gobj/qpgeomVertexAnimationSpec.I @@ -84,9 +84,9 @@ get_num_transforms() const { // Access: Published // Description: This is only meaningful for animation_type // AT_hardware. If true, it indicates that the format -// uses indexed animation palettes. It is false if each +// uses indexed animation tables. It is false if each // vertex will reference the first _num_transforms -// palette entries only. +// table entries only. //////////////////////////////////////////////////////////////////// INLINE bool qpGeomVertexAnimationSpec:: get_indexed_transforms() const { diff --git a/panda/src/gobj/qpgeomVertexData.I b/panda/src/gobj/qpgeomVertexData.I index 0fdd3b999a..7ab4d36a2b 100644 --- a/panda/src/gobj/qpgeomVertexData.I +++ b/panda/src/gobj/qpgeomVertexData.I @@ -142,69 +142,69 @@ get_array(int i) const { } //////////////////////////////////////////////////////////////////// -// Function: qpGeomVertexData::get_transform_palette +// Function: qpGeomVertexData::get_transform_table // Access: Published -// Description: Returns a const pointer to the TransformPalette +// Description: Returns a const pointer to the TransformTable // assigned to this data. Vertices within the table -// will index into this palette to indicate their +// will index into this table to indicate their // dynamic skinning information; this table is used when // the vertex animation is to be performed by the // graphics hardware (but also see -// get_transform_blend_palette()). +// get_transform_blend_table()). // // This will return NULL if the vertex data does not -// have a TransformPalette assigned (which implies the +// have a TransformTable assigned (which implies the // vertices will not be animated by the graphics // hardware). //////////////////////////////////////////////////////////////////// -INLINE const TransformPalette *qpGeomVertexData:: -get_transform_palette() const { +INLINE const TransformTable *qpGeomVertexData:: +get_transform_table() const { CDReader cdata(_cycler); - return cdata->_transform_palette; + return cdata->_transform_table; } //////////////////////////////////////////////////////////////////// -// Function: qpGeomVertexData::clear_transform_palette +// Function: qpGeomVertexData::clear_transform_table // Access: Published -// Description: Sets the TransformPalette pointer to NULL, -// removing the palette from the vertex data. This +// Description: Sets the TransformTable pointer to NULL, +// removing the table from the vertex data. This // disables hardware-driven vertex animation. //////////////////////////////////////////////////////////////////// INLINE void qpGeomVertexData:: -clear_transform_palette() { - set_transform_palette(NULL); +clear_transform_table() { + set_transform_table(NULL); } //////////////////////////////////////////////////////////////////// -// Function: qpGeomVertexData::get_transform_blend_palette +// Function: qpGeomVertexData::get_transform_blend_table // Access: Published -// Description: Returns a const pointer to the TransformBlendPalette +// Description: Returns a const pointer to the TransformBlendTable // assigned to this data. Vertices within the table -// will index into this palette to indicate their +// will index into this table to indicate their // dynamic skinning information; this table is used when // the vertex animation is to be performed by the CPU -// (but also see get_transform_palette()). +// (but also see get_transform_table()). // // This will return NULL if the vertex data does not -// have a TransformBlendPalette assigned (which implies +// have a TransformBlendTable assigned (which implies // the vertices will not be animated by the CPU). //////////////////////////////////////////////////////////////////// -INLINE const TransformBlendPalette *qpGeomVertexData:: -get_transform_blend_palette() const { +INLINE const TransformBlendTable *qpGeomVertexData:: +get_transform_blend_table() const { CDReader cdata(_cycler); - return cdata->_transform_blend_palette; + return cdata->_transform_blend_table; } //////////////////////////////////////////////////////////////////// -// Function: qpGeomVertexData::clear_transform_blend_palette +// Function: qpGeomVertexData::clear_transform_blend_table // Access: Published -// Description: Sets the TransformBlendPalette pointer to NULL, -// removing the palette from the vertex data. This +// Description: Sets the TransformBlendTable pointer to NULL, +// removing the table from the vertex data. This // disables CPU-driven vertex animation. //////////////////////////////////////////////////////////////////// INLINE void qpGeomVertexData:: -clear_transform_blend_palette() { - set_transform_blend_palette(NULL); +clear_transform_blend_table() { + set_transform_blend_table(NULL); } //////////////////////////////////////////////////////////////////// @@ -399,16 +399,16 @@ unpack_abcd_d(PN_uint32 data) { //////////////////////////////////////////////////////////////////// // Function: qpGeomVertexData::add_transform // Access: Private, Static -// Description: Adds the indicated transform to the palette, if it is +// Description: Adds the indicated transform to the table, if it is // not already there, and returns its index number. //////////////////////////////////////////////////////////////////// INLINE int qpGeomVertexData:: -add_transform(TransformPalette *palette, const VertexTransform *transform, +add_transform(TransformTable *table, const VertexTransform *transform, TransformMap &already_added) { - pair result = already_added.insert(TransformMap::value_type(transform, palette->get_num_transforms())); + pair result = already_added.insert(TransformMap::value_type(transform, table->get_num_transforms())); if (result.second) { - palette->add_transform(transform); + table->add_transform(transform); } return (*(result.first)).second; @@ -472,8 +472,8 @@ INLINE qpGeomVertexData::CData:: CData(const qpGeomVertexData::CData ©) : _usage_hint(copy._usage_hint), _arrays(copy._arrays), - _transform_palette(copy._transform_palette), - _transform_blend_palette(copy._transform_blend_palette), + _transform_table(copy._transform_table), + _transform_blend_table(copy._transform_blend_table), _slider_table(copy._slider_table), _animated_vertices(copy._animated_vertices), _animated_vertices_modified(copy._animated_vertices_modified), diff --git a/panda/src/gobj/qpgeomVertexData.cxx b/panda/src/gobj/qpgeomVertexData.cxx index f5545b61e1..a888af926e 100644 --- a/panda/src/gobj/qpgeomVertexData.cxx +++ b/panda/src/gobj/qpgeomVertexData.cxx @@ -258,63 +258,63 @@ set_array(int i, const qpGeomVertexArrayData *array) { } //////////////////////////////////////////////////////////////////// -// Function: qpGeomVertexData::set_transform_palette +// Function: qpGeomVertexData::set_transform_table // Access: Published -// Description: Replaces the TransformPalette on this vertex -// data with the indicated palette. The length of this -// palette should be consistent with the maximum palette +// Description: Replaces the TransformTable on this vertex +// data with the indicated table. The length of this +// table should be consistent with the maximum table // index assigned to the vertices under the // "transform_index" name. //////////////////////////////////////////////////////////////////// void qpGeomVertexData:: -set_transform_palette(const TransformPalette *palette) { - nassertv(palette == (TransformPalette *)NULL || palette->is_registered()); +set_transform_table(const TransformTable *table) { + nassertv(table == (TransformTable *)NULL || table->is_registered()); CDWriter cdata(_cycler); - cdata->_transform_palette = (TransformPalette *)palette; + cdata->_transform_table = (TransformTable *)table; clear_cache(); cdata->_modified = qpGeom::get_next_modified(); cdata->_animated_vertices_modified = UpdateSeq(); } //////////////////////////////////////////////////////////////////// -// Function: qpGeomVertexData::modify_transform_blend_palette +// Function: qpGeomVertexData::modify_transform_blend_table // Access: Published // Description: Returns a modifiable pointer to the current -// TransformBlendPalette on this vertex data, if any, or -// NULL if there is not a TransformBlendPalette. See -// get_transform_blend_palette(). +// TransformBlendTable on this vertex data, if any, or +// NULL if there is not a TransformBlendTable. See +// get_transform_blend_table(). //////////////////////////////////////////////////////////////////// -TransformBlendPalette *qpGeomVertexData:: -modify_transform_blend_palette() { - // Perform copy-on-write: if the reference count on the palette is +TransformBlendTable *qpGeomVertexData:: +modify_transform_blend_table() { + // Perform copy-on-write: if the reference count on the table is // greater than 1, assume some other GeomVertexData has the same // pointer, so make a copy of it first. CDWriter cdata(_cycler); - if (cdata->_transform_blend_palette->get_ref_count() > 1) { - cdata->_transform_blend_palette = new TransformBlendPalette(*cdata->_transform_blend_palette); + if (cdata->_transform_blend_table->get_ref_count() > 1) { + cdata->_transform_blend_table = new TransformBlendTable(*cdata->_transform_blend_table); } clear_cache(); cdata->_modified = qpGeom::get_next_modified(); cdata->_animated_vertices_modified = UpdateSeq(); - return cdata->_transform_blend_palette; + return cdata->_transform_blend_table; } //////////////////////////////////////////////////////////////////// -// Function: qpGeomVertexData::set_transform_blend_palette +// Function: qpGeomVertexData::set_transform_blend_table // Access: Published -// Description: Replaces the TransformBlendPalette on this vertex -// data with the indicated palette. The length of this -// palette should be consistent with the maximum palette +// Description: Replaces the TransformBlendTable on this vertex +// data with the indicated table. The length of this +// table should be consistent with the maximum table // index assigned to the vertices under the // "transform_blend" name. //////////////////////////////////////////////////////////////////// void qpGeomVertexData:: -set_transform_blend_palette(const TransformBlendPalette *palette) { +set_transform_blend_table(const TransformBlendTable *table) { CDWriter cdata(_cycler); - cdata->_transform_blend_palette = (TransformBlendPalette *)palette; + cdata->_transform_blend_table = (TransformBlendTable *)table; clear_cache(); cdata->_modified = qpGeom::get_next_modified(); cdata->_animated_vertices_modified = UpdateSeq(); @@ -506,9 +506,9 @@ copy_from(const qpGeomVertexData *source, bool keep_data_objects) { if (dest_animation.get_animation_type() == AT_hardware) { // Convert Panda-style animation tables to hardware-style // animation tables. - CPT(TransformBlendPalette) blend_palette = source->get_transform_blend_palette(); - if (blend_palette != (TransformBlendPalette *)NULL) { - PT(TransformPalette) transform_palette = new TransformPalette; + CPT(TransformBlendTable) blend_table = source->get_transform_blend_table(); + if (blend_table != (TransformBlendTable *)NULL) { + PT(TransformTable) transform_table = new TransformTable; TransformMap already_added; if (dest_animation.get_indexed_transforms()) { @@ -519,14 +519,14 @@ copy_from(const qpGeomVertexData *source, bool keep_data_objects) { qpGeomVertexReader from(source, InternalName::get_transform_blend()); while (!from.is_at_end()) { - const TransformBlend &blend = blend_palette->get_blend(from.get_data1i()); + const TransformBlend &blend = blend_table->get_blend(from.get_data1i()); LVecBase4f weights = LVecBase4f::zero(); int indices[4] = {0, 0, 0, 0}; nassertv(blend.get_num_transforms() <= 4); for (int i = 0; i < blend.get_num_transforms(); i++) { weights[i] = blend.get_weight(i); - indices[i] = add_transform(transform_palette, blend.get_transform(i), + indices[i] = add_transform(transform_table, blend.get_transform(i), already_added); } if (weight.has_column()) { @@ -541,11 +541,11 @@ copy_from(const qpGeomVertexData *source, bool keep_data_objects) { qpGeomVertexReader from(source, InternalName::get_transform_blend()); while (!from.is_at_end()) { - const TransformBlend &blend = blend_palette->get_blend(from.get_data1i()); + const TransformBlend &blend = blend_table->get_blend(from.get_data1i()); LVecBase4f weights = LVecBase4f::zero(); for (int i = 0; i < blend.get_num_transforms(); i++) { - int index = add_transform(transform_palette, blend.get_transform(i), + int index = add_transform(transform_table, blend.get_transform(i), already_added); nassertv(index <= 4); weights[index] = blend.get_weight(i); @@ -556,8 +556,8 @@ copy_from(const qpGeomVertexData *source, bool keep_data_objects) { } } - clear_transform_blend_palette(); - set_transform_palette(TransformPalette::register_palette(transform_palette)); + clear_transform_blend_table(); + set_transform_table(TransformTable::register_table(transform_table)); } } } @@ -638,7 +638,7 @@ convert_to(const qpGeomVertexFormat *new_format) const { PT(qpGeomVertexData) new_data = new qpGeomVertexData(get_name(), new_format, get_usage_hint()); - new_data->set_transform_blend_palette(get_transform_blend_palette()); + new_data->set_transform_blend_table(get_transform_blend_table()); new_data->set_slider_table(get_slider_table()); new_data->copy_from(this, false); @@ -862,7 +862,7 @@ replace_column(const InternalName *name, int num_components, PT(qpGeomVertexData) new_data = new qpGeomVertexData(get_name(), format, usage_hint); if (keep_animation) { - new_data->set_transform_blend_palette(get_transform_blend_palette()); + new_data->set_transform_blend_table(get_transform_blend_table()); new_data->set_slider_table(get_slider_table()); } @@ -922,10 +922,10 @@ write(ostream &out, int indent_level) const { indent(out, indent_level) << get_name() << "\n"; } _format->write_with_data(out, indent_level + 2, this); - if (get_transform_blend_palette() != (TransformBlendPalette *)NULL) { + if (get_transform_blend_table() != (TransformBlendTable *)NULL) { indent(out, indent_level) - << "Transform blend palette:\n"; - get_transform_blend_palette()->write(out, indent_level + 2); + << "Transform blend table:\n"; + get_transform_blend_table()->write(out, indent_level + 2); } } @@ -1076,20 +1076,20 @@ do_animate_vertices(bool from_app) const { } UpdateSeq modified; - if (cdata->_transform_blend_palette != (TransformBlendPalette *)NULL) { + if (cdata->_transform_blend_table != (TransformBlendTable *)NULL) { if (cdata->_slider_table != (SliderTable *)NULL) { modified = - max(cdata->_transform_blend_palette->get_modified(), + max(cdata->_transform_blend_table->get_modified(), cdata->_slider_table->get_modified()); } else { - modified = cdata->_transform_blend_palette->get_modified(); + modified = cdata->_transform_blend_table->get_modified(); } } else if (cdata->_slider_table != (SliderTable *)NULL) { modified = cdata->_slider_table->get_modified(); } else { - // No transform blend palette or slider table--ergo, no vertex + // No transform blend table or slider table--ergo, no vertex // animation. return this; } @@ -1308,12 +1308,12 @@ update_animated_vertices(qpGeomVertexData::CDWriter &cdata, bool from_app) { new_data->copy_from(this, true); // First, apply all of the morphs. - CPT(SliderTable) table = cdata->_slider_table; - if (table != (SliderTable *)NULL) { + CPT(SliderTable) slider_table = cdata->_slider_table; + if (slider_table != (SliderTable *)NULL) { int num_morphs = _format->get_num_morphs(); for (int mi = 0; mi < num_morphs; mi++) { CPT(InternalName) slider_name = _format->get_morph_slider(mi); - const VertexSlider *slider = table->find_slider(slider_name); + const VertexSlider *slider = slider_table->find_slider(slider_name); if (slider != (VertexSlider *)NULL) { float slider_value = slider->get_slider(); if (slider_value != 0.0f) { @@ -1358,15 +1358,15 @@ update_animated_vertices(qpGeomVertexData::CDWriter &cdata, bool from_app) { } // Then apply the transforms. - CPT(TransformBlendPalette) palette = cdata->_transform_blend_palette; - if (palette != (TransformBlendPalette *)NULL) { + CPT(TransformBlendTable) tb_table = cdata->_transform_blend_table; + if (tb_table != (TransformBlendTable *)NULL) { // Recompute all the blends up front, so we don't have to test // each one for staleness at each vertex. - int num_blends = palette->get_num_blends(); + int num_blends = tb_table->get_num_blends(); int bi; for (bi = 0; bi < num_blends; bi++) { - palette->get_blend(bi).update_blend(); + tb_table->get_blend(bi).update_blend(); } // Now go through and apply the transforms. @@ -1378,7 +1378,7 @@ update_animated_vertices(qpGeomVertexData::CDWriter &cdata, bool from_app) { if (!blendi.has_column()) { gobj_cat.warning() << "Vertex data " << get_name() - << " has a transform_blend_palette, but no transform_blend data.\n"; + << " has a transform_blend_table, but no transform_blend data.\n"; return; } @@ -1386,14 +1386,14 @@ update_animated_vertices(qpGeomVertexData::CDWriter &cdata, bool from_app) { for (int i = 0; i < num_rows; i++) { LPoint4f vertex = data.get_data4f(); int bi = blendi.get_data1i(); - palette->get_blend(bi).transform_point(vertex); + tb_table->get_blend(bi).transform_point(vertex); data.set_data4f(vertex); } } else { for (int i = 0; i < num_rows; i++) { LPoint3f vertex = data.get_data3f(); int bi = blendi.get_data1i(); - palette->get_blend(bi).transform_point(vertex); + tb_table->get_blend(bi).transform_point(vertex); data.set_data3f(vertex); } } @@ -1405,14 +1405,14 @@ update_animated_vertices(qpGeomVertexData::CDWriter &cdata, bool from_app) { if (!blendi.has_column()) { gobj_cat.warning() << "Vertex data " << get_name() - << " has a transform_blend_palette, but no transform_blend data.\n"; + << " has a transform_blend_table, but no transform_blend data.\n"; return; } for (int i = 0; i < num_rows; i++) { LVector3f vertex = data.get_data3f(); int bi = blendi.get_data1i(); - palette->get_blend(bi).transform_vector(vertex); + tb_table->get_blend(bi).transform_vector(vertex); data.set_data3f(vertex); } } @@ -1523,7 +1523,7 @@ finalize(BamReader *manager) { // the BamReader to return the new object from now on. // This extends to the nested array datas, as well as the transform - // palette and slider tables, as well. + // table and slider tables, as well. CDWriter cdata(_cycler); @@ -1541,11 +1541,11 @@ finalize(BamReader *manager) { manager->change_pointer(_format, new_format); _format = new_format; - if (cdata->_transform_palette != (TransformPalette *)NULL) { - CPT(TransformPalette) new_transform_palette = - TransformPalette::register_palette(cdata->_transform_palette); - manager->change_pointer(cdata->_transform_palette, new_transform_palette); - cdata->_transform_palette = new_transform_palette; + if (cdata->_transform_table != (TransformTable *)NULL) { + CPT(TransformTable) new_transform_table = + TransformTable::register_table(cdata->_transform_table); + manager->change_pointer(cdata->_transform_table, new_transform_table); + cdata->_transform_table = new_transform_table; } if (cdata->_slider_table != (SliderTable *)NULL) { @@ -1630,8 +1630,8 @@ write_datagram(BamWriter *manager, Datagram &dg) const { manager->write_pointer(dg, *ai); } - manager->write_pointer(dg, _transform_palette); - manager->write_pointer(dg, _transform_blend_palette); + manager->write_pointer(dg, _transform_table); + manager->write_pointer(dg, _transform_blend_table); manager->write_pointer(dg, _slider_table); } @@ -1651,8 +1651,8 @@ complete_pointers(TypedWritable **p_list, BamReader *manager) { (*ai) = DCAST(qpGeomVertexArrayData, p_list[pi++]); } - _transform_palette = DCAST(TransformPalette, p_list[pi++]); - _transform_blend_palette = DCAST(TransformBlendPalette, p_list[pi++]); + _transform_table = DCAST(TransformTable, p_list[pi++]); + _transform_blend_table = DCAST(TransformBlendTable, p_list[pi++]); _slider_table = DCAST(SliderTable, p_list[pi++]); _modified = qpGeom::get_next_modified(); diff --git a/panda/src/gobj/qpgeomVertexData.h b/panda/src/gobj/qpgeomVertexData.h index 83e7ff8c1f..ba8b7330db 100644 --- a/panda/src/gobj/qpgeomVertexData.h +++ b/panda/src/gobj/qpgeomVertexData.h @@ -26,8 +26,8 @@ #include "qpgeomVertexArrayData.h" #include "qpgeomEnums.h" #include "qpgeomCacheEntry.h" -#include "transformPalette.h" -#include "transformBlendPalette.h" +#include "transformTable.h" +#include "transformBlendTable.h" #include "sliderTable.h" #include "internalName.h" #include "cycleData.h" @@ -102,17 +102,17 @@ PUBLISHED: qpGeomVertexArrayData *modify_array(int i); void set_array(int i, const qpGeomVertexArrayData *array); - INLINE const TransformPalette *get_transform_palette() const; - void set_transform_palette(const TransformPalette *palette); - INLINE void clear_transform_palette(); + INLINE const TransformTable *get_transform_table() const; + void set_transform_table(const TransformTable *table); + INLINE void clear_transform_table(); - INLINE const TransformBlendPalette *get_transform_blend_palette() const; - TransformBlendPalette *modify_transform_blend_palette(); - void set_transform_blend_palette(const TransformBlendPalette *palette); - INLINE void clear_transform_blend_palette(); + INLINE const TransformBlendTable *get_transform_blend_table() const; + TransformBlendTable *modify_transform_blend_table(); + void set_transform_blend_table(const TransformBlendTable *table); + INLINE void clear_transform_blend_table(); INLINE const SliderTable *get_slider_table() const; - void set_slider_table(const SliderTable *palette); + void set_slider_table(const SliderTable *table); INLINE void clear_slider_table(); int get_num_bytes() const; @@ -194,7 +194,7 @@ private: typedef pmap TransformMap; INLINE static int - add_transform(TransformPalette *palette, const VertexTransform *transform, + add_transform(TransformTable *table, const VertexTransform *transform, TransformMap &already_added); private: @@ -232,8 +232,8 @@ private: UsageHint _usage_hint; Arrays _arrays; - CPT(TransformPalette) _transform_palette; - PT(TransformBlendPalette) _transform_blend_palette; + CPT(TransformTable) _transform_table; + PT(TransformBlendTable) _transform_blend_table; CPT(SliderTable) _slider_table; PT(qpGeomVertexData) _animated_vertices; UpdateSeq _animated_vertices_modified; diff --git a/panda/src/gobj/sliderTable.I b/panda/src/gobj/sliderTable.I index 7c3ab7f4e9..f8f8bbc398 100644 --- a/panda/src/gobj/sliderTable.I +++ b/panda/src/gobj/sliderTable.I @@ -64,7 +64,7 @@ register_table(const SliderTable *table) { //////////////////////////////////////////////////////////////////// // Function: SliderTable::get_num_sliders // Access: Published -// Description: Returns the number of sliders in the palette. +// Description: Returns the number of sliders in the table. //////////////////////////////////////////////////////////////////// INLINE int SliderTable:: get_num_sliders() const { @@ -74,7 +74,7 @@ get_num_sliders() const { //////////////////////////////////////////////////////////////////// // Function: SliderTable::get_slider // Access: Published -// Description: Returns the nth slider in the palette. +// Description: Returns the nth slider in the table. //////////////////////////////////////////////////////////////////// INLINE const VertexSlider *SliderTable:: get_slider(int n) const { diff --git a/panda/src/gobj/sliderTable.h b/panda/src/gobj/sliderTable.h index ba9f9023fd..d13672b0ae 100644 --- a/panda/src/gobj/sliderTable.h +++ b/panda/src/gobj/sliderTable.h @@ -36,7 +36,7 @@ // vertices in a particular GeomVertexData object might // depend on. // -// This is similar to a TransformPalette, but it stores +// This is similar to a TransformTable, but it stores // VertexSliders instead of VertexTransforms, and it // stores them by name instead of by index number. // Also, it is only used when animating vertices on the diff --git a/panda/src/gobj/transformBlend.h b/panda/src/gobj/transformBlend.h index 7c529f8be0..fda1000dba 100644 --- a/panda/src/gobj/transformBlend.h +++ b/panda/src/gobj/transformBlend.h @@ -32,7 +32,7 @@ //////////////////////////////////////////////////////////////////// // Class : TransformBlend // Description : This defines a single entry in a -// TransformBlendPalette. It represents a unique +// TransformBlendTable. It represents a unique // combination of VertexTransform pointers and blend // amounts. // diff --git a/panda/src/gobj/transformBlendPalette.I b/panda/src/gobj/transformBlendTable.I similarity index 71% rename from panda/src/gobj/transformBlendPalette.I rename to panda/src/gobj/transformBlendTable.I index 214c9d408d..d2a295b6f5 100644 --- a/panda/src/gobj/transformBlendPalette.I +++ b/panda/src/gobj/transformBlendTable.I @@ -1,4 +1,4 @@ -// Filename: transformBlendPalette.I +// Filename: transformBlendTable.I // Created by: drose (24Mar05) // //////////////////////////////////////////////////////////////////// @@ -18,40 +18,40 @@ //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::get_num_blends +// Function: TransformBlendTable::get_num_blends // Access: Published // Description: Returns the total number of different blend -// combinations in the palette. +// combinations in the table. //////////////////////////////////////////////////////////////////// -INLINE int TransformBlendPalette:: +INLINE int TransformBlendTable:: get_num_blends() const { return _blends.size(); } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::get_blend +// Function: TransformBlendTable::get_blend // Access: Published -// Description: Returns the nth blend in the palette. +// Description: Returns the nth blend in the table. //////////////////////////////////////////////////////////////////// -INLINE const TransformBlend &TransformBlendPalette:: +INLINE const TransformBlend &TransformBlendTable:: get_blend(int n) const { nassertr(n >= 0 && n < (int)_blends.size(), _blends[0]); return _blends[n]; } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::get_modified +// Function: TransformBlendTable::get_modified // Access: Published // Description: Returns a counter which is guaranteed to increment at -// least when any TransformBlends within the palette +// least when any TransformBlends within the table // have changed. //////////////////////////////////////////////////////////////////// -INLINE UpdateSeq TransformBlendPalette:: +INLINE UpdateSeq TransformBlendTable:: get_modified() const { CDReader cdata(_cycler); if (cdata->_global_modified != VertexTransform::get_global_modified()) { - CDWriter cdataw(((TransformBlendPalette *)this)->_cycler, cdata); - ((TransformBlendPalette *)this)->recompute_modified(cdataw); + CDWriter cdataw(((TransformBlendTable *)this)->_cycler, cdata); + ((TransformBlendTable *)this)->recompute_modified(cdataw); return cdataw->_modified; } else { return cdata->_modified; @@ -59,64 +59,64 @@ get_modified() const { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::get_num_transforms +// Function: TransformBlendTable::get_num_transforms // Access: Published // Description: Returns the number of unique VertexTransform objects -// represented in the palette. This will correspond to -// the size of the TransformPalette object that would +// represented in the table. This will correspond to +// the size of the TransformTable object that would // represent the same table. This is also the same // limit reflected by // GraphicsStateGuardian::get_max_vertex_transform_indices(). //////////////////////////////////////////////////////////////////// -INLINE int TransformBlendPalette:: +INLINE int TransformBlendTable:: get_num_transforms() const { consider_rebuild_index(); return _num_transforms; } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::get_max_simultaneous_transforms +// Function: TransformBlendTable::get_max_simultaneous_transforms // Access: Published // Description: Returns the maximum number of unique VertexTransform // objects that are applied to any one vertex // simultaneously. This is the same limit reflected by // GraphicsStateGuardian::get_max_vertex_transforms(). //////////////////////////////////////////////////////////////////// -INLINE int TransformBlendPalette:: +INLINE int TransformBlendTable:: get_max_simultaneous_transforms() const { consider_rebuild_index(); return _max_simultaneous_transforms; } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::consider_rebuild_index +// Function: TransformBlendTable::consider_rebuild_index // Access: Private // Description: Calls rebuild_index() if the index needs to be // rebuilt. //////////////////////////////////////////////////////////////////// -INLINE void TransformBlendPalette:: +INLINE void TransformBlendTable:: consider_rebuild_index() const { if (_blend_index.empty()) { - ((TransformBlendPalette *)this)->rebuild_index(); + ((TransformBlendTable *)this)->rebuild_index(); } } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::CData::Constructor +// Function: TransformBlendTable::CData::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -INLINE TransformBlendPalette::CData:: +INLINE TransformBlendTable::CData:: CData() { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::CData::Copy Constructor +// Function: TransformBlendTable::CData::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -INLINE TransformBlendPalette::CData:: -CData(const TransformBlendPalette::CData ©) : +INLINE TransformBlendTable::CData:: +CData(const TransformBlendTable::CData ©) : _modified(copy._modified), _global_modified(copy._global_modified) { diff --git a/panda/src/gobj/transformBlendPalette.cxx b/panda/src/gobj/transformBlendTable.cxx similarity index 78% rename from panda/src/gobj/transformBlendPalette.cxx rename to panda/src/gobj/transformBlendTable.cxx index 5b5bad302f..9f78155b10 100644 --- a/panda/src/gobj/transformBlendPalette.cxx +++ b/panda/src/gobj/transformBlendTable.cxx @@ -1,4 +1,4 @@ -// Filename: transformBlendPalette.cxx +// Filename: transformBlendTable.cxx // Created by: drose (24Mar05) // //////////////////////////////////////////////////////////////////// @@ -16,84 +16,84 @@ // //////////////////////////////////////////////////////////////////// -#include "transformBlendPalette.h" +#include "transformBlendTable.h" #include "indent.h" #include "bamReader.h" #include "bamWriter.h" -TypeHandle TransformBlendPalette::_type_handle; +TypeHandle TransformBlendTable::_type_handle; //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::Constructor +// Function: TransformBlendTable::Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// -TransformBlendPalette:: -TransformBlendPalette() { +TransformBlendTable:: +TransformBlendTable() { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::Copy Constructor +// Function: TransformBlendTable::Copy Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// -TransformBlendPalette:: -TransformBlendPalette(const TransformBlendPalette ©) : +TransformBlendTable:: +TransformBlendTable(const TransformBlendTable ©) : _blends(copy._blends) { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::Copy Assignment Operator +// Function: TransformBlendTable::Copy Assignment Operator // Access: Published // Description: //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: -operator = (const TransformBlendPalette ©) { +void TransformBlendTable:: +operator = (const TransformBlendTable ©) { _blends = copy._blends; clear_index(); } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::Destructor +// Function: TransformBlendTable::Destructor // Access: Published, Virtual // Description: //////////////////////////////////////////////////////////////////// -TransformBlendPalette:: -~TransformBlendPalette() { +TransformBlendTable:: +~TransformBlendTable() { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::set_blend +// Function: TransformBlendTable::set_blend // Access: Published // Description: Replaces the blend at the nth position with the // indicated value. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: set_blend(int n, const TransformBlend &blend) { nassertv(n >= 0 && n < (int)_blends.size()); _blends[n] = blend; } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::remove_blend +// Function: TransformBlendTable::remove_blend // Access: Published // Description: Removes the blend at the nth position. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: remove_blend(int n) { nassertv(n >= 0 && n < (int)_blends.size()); _blends.erase(_blends.begin() + n); } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::add_blend +// Function: TransformBlendTable::add_blend // Access: Published -// Description: Adds a new blend to the palette, and returns its +// Description: Adds a new blend to the table, and returns its // index number. If there is already an identical blend -// in the palette, simply returns that number instead. +// in the table, simply returns that number instead. //////////////////////////////////////////////////////////////////// -int TransformBlendPalette:: +int TransformBlendTable:: add_blend(const TransformBlend &blend) { consider_rebuild_index(); @@ -112,11 +112,11 @@ add_blend(const TransformBlend &blend) { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::write +// Function: TransformBlendTable::write // Access: Published // Description: //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: write(ostream &out, int indent_level) const { for (int i = 0; i < (int)_blends.size(); i++) { indent(out, indent_level) @@ -125,24 +125,24 @@ write(ostream &out, int indent_level) const { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::clear_index +// Function: TransformBlendTable::clear_index // Access: Private // Description: Resets the index so that it will be rebuilt next time // it is needed. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: clear_index() { _blend_index.clear(); } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::rebuild_index +// Function: TransformBlendTable::rebuild_index // Access: Private // Description: Rebuilds the index so that we can easily determine // what blend combinations are already present in the -// palette. +// table. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: rebuild_index() { _blend_index.clear(); @@ -168,13 +168,13 @@ rebuild_index() { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::recompute_modified +// Function: TransformBlendTable::recompute_modified // Access: Private // Description: Recomputes the modified stamp from the various // TransformBlend objects, if necessary. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: -recompute_modified(TransformBlendPalette::CDWriter &cdata) { +void TransformBlendTable:: +recompute_modified(TransformBlendTable::CDWriter &cdata) { // Update the global_modified sequence number first, to prevent race // conditions. cdata->_global_modified = VertexTransform::get_global_modified(); @@ -190,12 +190,12 @@ recompute_modified(TransformBlendPalette::CDWriter &cdata) { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::clear_modified +// Function: TransformBlendTable::clear_modified // Access: Private // Description: Clears the modified stamp to force it to be // recomputed. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: clear_modified() { CDWriter cdata(_cycler); cdata->_global_modified = UpdateSeq(); @@ -203,23 +203,23 @@ clear_modified() { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::register_with_read_factory +// Function: TransformBlendTable::register_with_read_factory // Access: Public, Static // Description: Tells the BamReader how to create objects of type -// TransformBlendPalette. +// TransformBlendTable. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: register_with_read_factory() { BamReader::get_factory()->register_factory(get_class_type(), make_from_bam); } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::write_datagram +// Function: TransformBlendTable::write_datagram // Access: Public, Virtual // Description: Writes the contents of this object to the datagram // for shipping out to a Bam file. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: write_datagram(BamWriter *manager, Datagram &dg) { TypedWritable::write_datagram(manager, dg); @@ -233,13 +233,13 @@ write_datagram(BamWriter *manager, Datagram &dg) { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::complete_pointers +// Function: TransformBlendTable::complete_pointers // Access: Public, Virtual // Description: Receives an array of pointers, one for each time // manager->read_pointer() was called in fillin(). // Returns the number of pointers processed. //////////////////////////////////////////////////////////////////// -int TransformBlendPalette:: +int TransformBlendTable:: complete_pointers(TypedWritable **p_list, BamReader *manager) { int pi = TypedWritable::complete_pointers(p_list, manager); @@ -252,16 +252,16 @@ complete_pointers(TypedWritable **p_list, BamReader *manager) { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::make_from_bam +// Function: TransformBlendTable::make_from_bam // Access: Protected, Static // Description: This function is called by the BamReader's factory -// when a new object of type TransformBlendPalette is encountered -// in the Bam file. It should create the TransformBlendPalette +// when a new object of type TransformBlendTable is encountered +// in the Bam file. It should create the TransformBlendTable // and extract its information from the file. //////////////////////////////////////////////////////////////////// -TypedWritable *TransformBlendPalette:: +TypedWritable *TransformBlendTable:: make_from_bam(const FactoryParams ¶ms) { - TransformBlendPalette *object = new TransformBlendPalette; + TransformBlendTable *object = new TransformBlendTable; DatagramIterator scan; BamReader *manager; @@ -272,13 +272,13 @@ make_from_bam(const FactoryParams ¶ms) { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::fillin +// Function: TransformBlendTable::fillin // Access: Protected // Description: This internal function is called by make_from_bam to // read in all of the relevant data from the BamFile for -// the new TransformBlendPalette. +// the new TransformBlendTable. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette:: +void TransformBlendTable:: fillin(DatagramIterator &scan, BamReader *manager) { TypedWritable::fillin(scan, manager); @@ -295,33 +295,33 @@ fillin(DatagramIterator &scan, BamReader *manager) { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::CData::make_copy +// Function: TransformBlendTable::CData::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -CycleData *TransformBlendPalette::CData:: +CycleData *TransformBlendTable::CData:: make_copy() const { return new CData(*this); } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::CData::write_datagram +// Function: TransformBlendTable::CData::write_datagram // Access: Public, Virtual // Description: Writes the contents of this object to the datagram // for shipping out to a Bam file. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette::CData:: +void TransformBlendTable::CData:: write_datagram(BamWriter *manager, Datagram &dg) const { } //////////////////////////////////////////////////////////////////// -// Function: TransformBlendPalette::CData::fillin +// Function: TransformBlendTable::CData::fillin // Access: Public, Virtual // Description: This internal function is called by make_from_bam to // read in all of the relevant data from the BamFile for -// the new TransformBlendPalette. +// the new TransformBlendTable. //////////////////////////////////////////////////////////////////// -void TransformBlendPalette::CData:: +void TransformBlendTable::CData:: fillin(DatagramIterator &scan, BamReader *manager) { _modified = VertexTransform::get_next_modified(); _global_modified = VertexTransform::get_global_modified(); diff --git a/panda/src/gobj/transformBlendPalette.h b/panda/src/gobj/transformBlendTable.h similarity index 83% rename from panda/src/gobj/transformBlendPalette.h rename to panda/src/gobj/transformBlendTable.h index 4c9ed5d533..1024160188 100644 --- a/panda/src/gobj/transformBlendPalette.h +++ b/panda/src/gobj/transformBlendTable.h @@ -1,4 +1,4 @@ -// Filename: transformBlendPalette.h +// Filename: transformBlendTable.h // Created by: drose (24Mar05) // //////////////////////////////////////////////////////////////////// @@ -16,8 +16,8 @@ // //////////////////////////////////////////////////////////////////// -#ifndef TRANSFORMBLENDPALETTE_H -#define TRANSFORMBLENDPALETTE_H +#ifndef TRANSFORMBLENDTABLE_H +#define TRANSFORMBLENDTABLE_H #include "pandabase.h" #include "transformBlend.h" @@ -33,28 +33,28 @@ #include "pipelineCycler.h" //////////////////////////////////////////////////////////////////// -// Class : TransformBlendPalette +// Class : TransformBlendTable // Description : This structure collects together the different // combinations of transforms and blend amounts used by // a GeomVertexData, to facilitate computing dynamic // vertices on the CPU at runtime. Each vertex has a -// pointer to exactly one of entries in this palette, +// pointer to exactly one of entries in this table, // and each entry defines a number of transform/blend // combinations. // // This structure is used for a GeomVertexData set up to // compute its dynamic vertices on the CPU. See -// TransformPalette for one set up to compute its +// TransformTable for one set up to compute its // dynamic vertices on the graphics card. // // This is part of the experimental Geom rewrite. //////////////////////////////////////////////////////////////////// -class EXPCL_PANDA TransformBlendPalette : public TypedWritableReferenceCount { +class EXPCL_PANDA TransformBlendTable : public TypedWritableReferenceCount { PUBLISHED: - TransformBlendPalette(); - TransformBlendPalette(const TransformBlendPalette ©); - void operator = (const TransformBlendPalette ©); - virtual ~TransformBlendPalette(); + TransformBlendTable(); + TransformBlendTable(const TransformBlendTable ©); + void operator = (const TransformBlendTable ©); + virtual ~TransformBlendTable(); INLINE int get_num_blends() const; INLINE const TransformBlend &get_blend(int n) const; @@ -75,10 +75,10 @@ private: void rebuild_index(); private: - // We don't bother with registering the palette, or protecting its + // We don't bother with registering the table, or protecting its // data in a CycleData structure--the interface on GeomVertexData // guarantees that the pointer will be copied if we modify the - // palette. + // table. typedef pvector Blends; Blends _blends; @@ -91,7 +91,7 @@ private: int _num_transforms; int _max_simultaneous_transforms; - // Even though we don't store the actual blend palette data in a + // Even though we don't store the actual blend table data in a // CycleData structure, we do need to keep a local cache of the // relevant modified stamps there, so it can be updated per-thread. class EXPCL_PANDA CData : public CycleData { @@ -128,7 +128,7 @@ public: } static void init_type() { TypedWritableReferenceCount::init_type(); - register_type(_type_handle, "TransformBlendPalette", + register_type(_type_handle, "TransformBlendTable", TypedWritableReferenceCount::get_class_type()); } virtual TypeHandle get_type() const { @@ -142,8 +142,8 @@ private: friend class VertexTransform; }; -INLINE ostream &operator << (ostream &out, const TransformBlendPalette &obj); +INLINE ostream &operator << (ostream &out, const TransformBlendTable &obj); -#include "transformBlendPalette.I" +#include "transformBlendTable.I" #endif diff --git a/panda/src/gobj/transformPalette.I b/panda/src/gobj/transformTable.I similarity index 68% rename from panda/src/gobj/transformPalette.I rename to panda/src/gobj/transformTable.I index e871f4adcf..409995fe5f 100644 --- a/panda/src/gobj/transformPalette.I +++ b/panda/src/gobj/transformTable.I @@ -1,4 +1,4 @@ -// Filename: transformPalette.I +// Filename: transformTable.I // Created by: drose (23Mar05) // //////////////////////////////////////////////////////////////////// @@ -18,114 +18,114 @@ //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::is_registered +// Function: TransformTable::is_registered // Access: Published -// Description: Returns true if this palette has been registered. +// Description: Returns true if this table has been registered. // Once it has been registered, the set of transforms in -// a TransformPalette may not be further modified; but +// a TransformTable may not be further modified; but // it must be registered before it can be assigned to a // Geom. //////////////////////////////////////////////////////////////////// -INLINE bool TransformPalette:: +INLINE bool TransformTable:: is_registered() const { return _is_registered; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::register_palette +// Function: TransformTable::register_table // Access: Published, Static -// Description: Registers a TransformPalette for use. This is +// Description: Registers a TransformTable for use. This is // similar to GeomVertexFormat::register_format(). Once -// registered, a TransformPalette may no longer be +// registered, a TransformTable may no longer be // modified (although the individual VertexTransform // objects may modify their reported transforms). // -// This must be called before a palette may be used in a +// This must be called before a table may be used in a // Geom. After this call, you should discard the // original pointer you passed in (which may or may not // now be invalid) and let its reference count decrement // normally; you should use only the returned value from // this point on. //////////////////////////////////////////////////////////////////// -INLINE CPT(TransformPalette) TransformPalette:: -register_palette(const TransformPalette *palette) { - // We don't actually bother adding the palette object to a registry. +INLINE CPT(TransformTable) TransformTable:: +register_table(const TransformTable *table) { + // We don't actually bother adding the table object to a registry. // This means there may be multiple copies of identical registered - // TransformPalettes. Big deal. We can always go back and make a + // TransformTables. Big deal. We can always go back and make a // registry later if we really need it. - if (palette->is_registered()) { - return palette; + if (table->is_registered()) { + return table; } - ((TransformPalette *)palette)->do_register(); - return palette; + ((TransformTable *)table)->do_register(); + return table; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::get_num_transforms +// Function: TransformTable::get_num_transforms // Access: Published -// Description: Returns the number of transforms in the palette. +// Description: Returns the number of transforms in the table. //////////////////////////////////////////////////////////////////// -INLINE int TransformPalette:: +INLINE int TransformTable:: get_num_transforms() const { return _transforms.size(); } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::get_transform +// Function: TransformTable::get_transform // Access: Published -// Description: Returns the nth transform in the palette. +// Description: Returns the nth transform in the table. //////////////////////////////////////////////////////////////////// -INLINE const VertexTransform *TransformPalette:: +INLINE const VertexTransform *TransformTable:: get_transform(int n) const { nassertr(n >= 0 && n < (int)_transforms.size(), NULL); return _transforms[n]; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::get_modified +// Function: TransformTable::get_modified // Access: Published // Description: Returns a sequence number that's guaranteed to change -// at least when any VertexTransforms in the palette +// at least when any VertexTransforms in the table // change. (However, this is only true for a registered -// palette. An unregistered palette may or may not +// table. An unregistered table may or may not // reflect an update here when a VertexTransform // changes.) //////////////////////////////////////////////////////////////////// -INLINE UpdateSeq TransformPalette:: +INLINE UpdateSeq TransformTable:: get_modified() const { CDReader cdata(_cycler); return cdata->_modified; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::update_modified +// Function: TransformTable::update_modified // Access: Private // Description: Called internally whenever a nested VertexTransform // reports that it has been modified. //////////////////////////////////////////////////////////////////// -INLINE void TransformPalette:: +INLINE void TransformTable:: update_modified(UpdateSeq modified) { CDWriter cdata(_cycler); cdata->_modified = modified; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::CData::Constructor +// Function: TransformTable::CData::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -INLINE TransformPalette::CData:: +INLINE TransformTable::CData:: CData() { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::CData::Copy Constructor +// Function: TransformTable::CData::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -INLINE TransformPalette::CData:: -CData(const TransformPalette::CData ©) : +INLINE TransformTable::CData:: +CData(const TransformTable::CData ©) : _modified(copy._modified) { } diff --git a/panda/src/gobj/transformPalette.cxx b/panda/src/gobj/transformTable.cxx similarity index 77% rename from panda/src/gobj/transformPalette.cxx rename to panda/src/gobj/transformTable.cxx index 25c34aaac7..75370b0ee9 100644 --- a/panda/src/gobj/transformPalette.cxx +++ b/panda/src/gobj/transformTable.cxx @@ -1,4 +1,4 @@ -// Filename: transformPalette.cxx +// Filename: transformTable.cxx // Created by: drose (23Mar05) // //////////////////////////////////////////////////////////////////// @@ -16,65 +16,65 @@ // //////////////////////////////////////////////////////////////////// -#include "transformPalette.h" +#include "transformTable.h" #include "bamReader.h" #include "bamWriter.h" -TypeHandle TransformPalette::_type_handle; +TypeHandle TransformTable::_type_handle; //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::Constructor +// Function: TransformTable::Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// -TransformPalette:: -TransformPalette() : +TransformTable:: +TransformTable() : _is_registered(false) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::Copy Constructor +// Function: TransformTable::Copy Constructor // Access: Published // Description: //////////////////////////////////////////////////////////////////// -TransformPalette:: -TransformPalette(const TransformPalette ©) : +TransformTable:: +TransformTable(const TransformTable ©) : _is_registered(false), _transforms(copy._transforms) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::Copy Assignment Operator +// Function: TransformTable::Copy Assignment Operator // Access: Published // Description: //////////////////////////////////////////////////////////////////// -void TransformPalette:: -operator = (const TransformPalette ©) { +void TransformTable:: +operator = (const TransformTable ©) { nassertv(!_is_registered); _transforms = copy._transforms; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::Destructor +// Function: TransformTable::Destructor // Access: Published, Virtual // Description: //////////////////////////////////////////////////////////////////// -TransformPalette:: -~TransformPalette() { +TransformTable:: +~TransformTable() { if (_is_registered) { do_unregister(); } } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::set_transform +// Function: TransformTable::set_transform // Access: Published // Description: Replaces the nth transform. Only valid for -// unregistered palettes. +// unregistered tables. //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: set_transform(int n, const VertexTransform *transform) { nassertv(!_is_registered); nassertv(n >= 0 && n < (int)_transforms.size()); @@ -82,12 +82,12 @@ set_transform(int n, const VertexTransform *transform) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::remove_transform +// Function: TransformTable::remove_transform // Access: Published // Description: Removes the nth transform. Only valid for -// unregistered palettes. +// unregistered tables. //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: remove_transform(int n) { nassertv(!_is_registered); nassertv(n >= 0 && n < (int)_transforms.size()); @@ -95,13 +95,13 @@ remove_transform(int n) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::add_transform +// Function: TransformTable::add_transform // Access: Published -// Description: Adds a new transform to the palette and returns the +// Description: Adds a new transform to the table and returns the // index number of the new transform. Only valid for -// unregistered palettes. +// unregistered tables. //////////////////////////////////////////////////////////////////// -int TransformPalette:: +int TransformTable:: add_transform(const VertexTransform *transform) { nassertr(!_is_registered, -1); int new_index = (int)_transforms.size(); @@ -110,11 +110,11 @@ add_transform(const VertexTransform *transform) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::write +// Function: TransformTable::write // Access: Published // Description: //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: write(ostream &out) const { for (size_t i = 0; i < _transforms.size(); ++i) { out << i << ". " << *_transforms[i] << "\n"; @@ -122,59 +122,59 @@ write(ostream &out) const { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::do_register +// Function: TransformTable::do_register // Access: Private -// Description: Called internally when the palette is registered. +// Description: Called internally when the table is registered. //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: do_register() { nassertv(!_is_registered); Transforms::iterator ti; for (ti = _transforms.begin(); ti != _transforms.end(); ++ti) { VertexTransform *transform = (VertexTransform *)(*ti).p(); - bool inserted = transform->_palettes.insert(this).second; + bool inserted = transform->_tables.insert(this).second; nassertv(inserted); } _is_registered = true; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::do_unregister +// Function: TransformTable::do_unregister // Access: Private -// Description: Called internally when the palette is unregistered +// Description: Called internally when the table is unregistered // (i.e. right before destruction). //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: do_unregister() { nassertv(_is_registered); Transforms::iterator ti; for (ti = _transforms.begin(); ti != _transforms.end(); ++ti) { VertexTransform *transform = (VertexTransform *)(*ti).p(); - transform->_palettes.erase(this); + transform->_tables.erase(this); } _is_registered = false; } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::register_with_read_factory +// Function: TransformTable::register_with_read_factory // Access: Public, Static // Description: Tells the BamReader how to create objects of type -// TransformPalette. +// TransformTable. //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: register_with_read_factory() { BamReader::get_factory()->register_factory(get_class_type(), make_from_bam); } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::write_datagram +// Function: TransformTable::write_datagram // Access: Public, Virtual // Description: Writes the contents of this object to the datagram // for shipping out to a Bam file. //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: write_datagram(BamWriter *manager, Datagram &dg) { TypedWritableReferenceCount::write_datagram(manager, dg); @@ -189,13 +189,13 @@ write_datagram(BamWriter *manager, Datagram &dg) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::complete_pointers +// Function: TransformTable::complete_pointers // Access: Public, Virtual // Description: Receives an array of pointers, one for each time // manager->read_pointer() was called in fillin(). // Returns the number of pointers processed. //////////////////////////////////////////////////////////////////// -int TransformPalette:: +int TransformTable:: complete_pointers(TypedWritable **p_list, BamReader *manager) { int pi = TypedWritableReferenceCount::complete_pointers(p_list, manager); @@ -209,16 +209,16 @@ complete_pointers(TypedWritable **p_list, BamReader *manager) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::make_from_bam +// Function: TransformTable::make_from_bam // Access: Protected, Static // Description: This function is called by the BamReader's factory -// when a new object of type TransformPalette is encountered -// in the Bam file. It should create the TransformPalette +// when a new object of type TransformTable is encountered +// in the Bam file. It should create the TransformTable // and extract its information from the file. //////////////////////////////////////////////////////////////////// -TypedWritable *TransformPalette:: +TypedWritable *TransformTable:: make_from_bam(const FactoryParams ¶ms) { - TransformPalette *object = new TransformPalette; + TransformTable *object = new TransformTable; DatagramIterator scan; BamReader *manager; @@ -229,13 +229,13 @@ make_from_bam(const FactoryParams ¶ms) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::fillin +// Function: TransformTable::fillin // Access: Protected // Description: This internal function is called by make_from_bam to // read in all of the relevant data from the BamFile for -// the new TransformPalette. +// the new TransformTable. //////////////////////////////////////////////////////////////////// -void TransformPalette:: +void TransformTable:: fillin(DatagramIterator &scan, BamReader *manager) { TypedWritableReferenceCount::fillin(scan, manager); @@ -250,33 +250,33 @@ fillin(DatagramIterator &scan, BamReader *manager) { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::CData::make_copy +// Function: TransformTable::CData::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -CycleData *TransformPalette::CData:: +CycleData *TransformTable::CData:: make_copy() const { return new CData(*this); } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::CData::write_datagram +// Function: TransformTable::CData::write_datagram // Access: Public, Virtual // Description: Writes the contents of this object to the datagram // for shipping out to a Bam file. //////////////////////////////////////////////////////////////////// -void TransformPalette::CData:: +void TransformTable::CData:: write_datagram(BamWriter *manager, Datagram &dg) const { } //////////////////////////////////////////////////////////////////// -// Function: TransformPalette::CData::fillin +// Function: TransformTable::CData::fillin // Access: Public, Virtual // Description: This internal function is called by make_from_bam to // read in all of the relevant data from the BamFile for -// the new TransformPalette. +// the new TransformTable. //////////////////////////////////////////////////////////////////// -void TransformPalette::CData:: +void TransformTable::CData:: fillin(DatagramIterator &scan, BamReader *manager) { _modified = VertexTransform::get_next_modified(); } diff --git a/panda/src/gobj/transformPalette.h b/panda/src/gobj/transformTable.h similarity index 83% rename from panda/src/gobj/transformPalette.h rename to panda/src/gobj/transformTable.h index b8d6b048f5..855be8974c 100644 --- a/panda/src/gobj/transformPalette.h +++ b/panda/src/gobj/transformTable.h @@ -1,4 +1,4 @@ -// Filename: transformPalette.h +// Filename: transformTable.h // Created by: drose (23Mar05) // //////////////////////////////////////////////////////////////////// @@ -16,8 +16,8 @@ // //////////////////////////////////////////////////////////////////// -#ifndef TRANSFORMPALETTE_H -#define TRANSFORMPALETTE_H +#ifndef TRANSFORMTABLE_H +#define TRANSFORMTABLE_H #include "pandabase.h" #include "vertexTransform.h" @@ -32,27 +32,27 @@ //////////////////////////////////////////////////////////////////// -// Class : TransformPalette +// Class : TransformTable // Description : Stores the total set of VertexTransforms that the // vertices in a particular GeomVertexData object might // depend on. // // This structure is used for a GeomVertexData set up to // compute its dynamic vertices on the graphics card. -// See TransformBlendPalette for one set up to compute +// See TransformBlendTable for one set up to compute // its dynamic vertices on the CPU. // // This is part of the experimental Geom rewrite. //////////////////////////////////////////////////////////////////// -class EXPCL_PANDA TransformPalette : public TypedWritableReferenceCount { +class EXPCL_PANDA TransformTable : public TypedWritableReferenceCount { PUBLISHED: - TransformPalette(); - TransformPalette(const TransformPalette ©); - void operator = (const TransformPalette ©); - virtual ~TransformPalette(); + TransformTable(); + TransformTable(const TransformTable ©); + void operator = (const TransformTable ©); + virtual ~TransformTable(); INLINE bool is_registered() const; - INLINE static CPT(TransformPalette) register_palette(const TransformPalette *palette); + INLINE static CPT(TransformTable) register_table(const TransformTable *table); INLINE int get_num_transforms() const; INLINE const VertexTransform *get_transform(int n) const; @@ -106,7 +106,7 @@ public: } static void init_type() { TypedWritableReferenceCount::init_type(); - register_type(_type_handle, "TransformPalette", + register_type(_type_handle, "TransformTable", TypedWritableReferenceCount::get_class_type()); } virtual TypeHandle get_type() const { @@ -120,8 +120,8 @@ private: friend class VertexTransform; }; -INLINE ostream &operator << (ostream &out, const TransformPalette &obj); +INLINE ostream &operator << (ostream &out, const TransformTable &obj); -#include "transformPalette.I" +#include "transformTable.I" #endif diff --git a/panda/src/gobj/vertexTransform.cxx b/panda/src/gobj/vertexTransform.cxx index 155ebcc707..a8b3c3171c 100644 --- a/panda/src/gobj/vertexTransform.cxx +++ b/panda/src/gobj/vertexTransform.cxx @@ -42,9 +42,9 @@ VertexTransform() { //////////////////////////////////////////////////////////////////// VertexTransform:: ~VertexTransform() { - // We shouldn't destruct while any TransformPalettes are holding our + // We shouldn't destruct while any TransformTables are holding our // pointer. - nassertv(_palettes.empty()); + nassertv(_tables.empty()); } //////////////////////////////////////////////////////////////////// @@ -161,7 +161,7 @@ mark_modified() { cdata->_modified = get_next_modified(); Palettes::iterator pi; - for (pi = _palettes.begin(); pi != _palettes.end(); ++pi) { + for (pi = _tables.begin(); pi != _tables.end(); ++pi) { (*pi)->update_modified(cdata->_modified); } } diff --git a/panda/src/gobj/vertexTransform.h b/panda/src/gobj/vertexTransform.h index 9291b1f223..57bfe2d1f9 100644 --- a/panda/src/gobj/vertexTransform.h +++ b/panda/src/gobj/vertexTransform.h @@ -29,7 +29,7 @@ #include "cycleDataWriter.h" #include "pipelineCycler.h" -class TransformPalette; +class TransformTable; //////////////////////////////////////////////////////////////////// // Class : VertexTransform @@ -63,8 +63,8 @@ protected: void mark_modified(); private: - typedef pset Palettes; - Palettes _palettes; + typedef pset Palettes; + Palettes _tables; // This is the data that must be cycled between pipeline stages. class EXPCL_PANDA CData : public CycleData { @@ -109,7 +109,7 @@ public: private: static TypeHandle _type_handle; - friend class TransformPalette; + friend class TransformTable; }; INLINE ostream &operator << (ostream &out, const VertexTransform &obj);