transform palette -> transform table

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) {

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

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,

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);
       }
     }
   }

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,

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;

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 <ctype.h>
@@ -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);
     }
   }
 

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);

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;

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 \

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();

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"

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() {

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 {

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<TransformMap::iterator, bool> result = already_added.insert(TransformMap::value_type(transform, palette->get_num_transforms()));
+  pair<TransformMap::iterator, bool> 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 &copy) :
   _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),

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();

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<const VertexTransform *, int> 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;

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 {

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

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.
 //

panda/src/gobj/transformBlendPalette.I → 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 &copy) :
+INLINE TransformBlendTable::CData::
+CData(const TransformBlendTable::CData &copy) :
   _modified(copy._modified),
   _global_modified(copy._global_modified)
 {

panda/src/gobj/transformBlendPalette.cxx → 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 &copy) :
+TransformBlendTable::
+TransformBlendTable(const TransformBlendTable &copy) :
   _blends(copy._blends)
 {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: TransformBlendPalette::Copy Assignment Operator
+//     Function: TransformBlendTable::Copy Assignment Operator
 //       Access: Published
 //  Description: 
 ////////////////////////////////////////////////////////////////////
-void TransformBlendPalette::
-operator = (const TransformBlendPalette &copy) {
+void TransformBlendTable::
+operator = (const TransformBlendTable &copy) {
   _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 &params) {
-  TransformBlendPalette *object = new TransformBlendPalette;
+  TransformBlendTable *object = new TransformBlendTable;
   DatagramIterator scan;
   BamReader *manager;
 
@@ -272,13 +272,13 @@ make_from_bam(const FactoryParams &params) {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     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();

panda/src/gobj/transformBlendPalette.h → 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 &copy);
-  void operator = (const TransformBlendPalette &copy);
-  virtual ~TransformBlendPalette();
+  TransformBlendTable();
+  TransformBlendTable(const TransformBlendTable &copy);
+  void operator = (const TransformBlendTable &copy);
+  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<TransformBlend> 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

panda/src/gobj/transformPalette.I → 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 &copy) :
+INLINE TransformTable::CData::
+CData(const TransformTable::CData &copy) :
   _modified(copy._modified)
 {
 }

panda/src/gobj/transformPalette.cxx → 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 &copy) :
+TransformTable::
+TransformTable(const TransformTable &copy) :
   _is_registered(false),
   _transforms(copy._transforms)
 {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: TransformPalette::Copy Assignment Operator
+//     Function: TransformTable::Copy Assignment Operator
 //       Access: Published
 //  Description: 
 ////////////////////////////////////////////////////////////////////
-void TransformPalette::
-operator = (const TransformPalette &copy) {
+void TransformTable::
+operator = (const TransformTable &copy) {
   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 &params) {
-  TransformPalette *object = new TransformPalette;
+  TransformTable *object = new TransformTable;
   DatagramIterator scan;
   BamReader *manager;
 
@@ -229,13 +229,13 @@ make_from_bam(const FactoryParams &params) {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     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();
 }

panda/src/gobj/transformPalette.h → 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 &copy);
-  void operator = (const TransformPalette &copy);
-  virtual ~TransformPalette();
+  TransformTable();
+  TransformTable(const TransformTable &copy);
+  void operator = (const TransformTable &copy);
+  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

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);
   }
 }

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<TransformPalette *> Palettes;
-  Palettes _palettes;
+  typedef pset<TransformTable *> 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);