RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

transform palette -> transform table

This commit is contained in:
David Rose 2005-04-21 22:20:33 +00:00
parent a4677868e2
commit 29b2dbc742
28 changed files with 402 additions and 400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
panda/src/char/character.cxx
View File

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

8
panda/src/char/character.h
View File

@ -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

2
panda/src/display/graphicsStateGuardian.I
View File

@ -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,

22
panda/src/display/standardMunger.cxx
View File

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

2
panda/src/dxgsg8/dxGeomMunger8.cxx
View File

@ -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,

12
panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx
View File

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

16
panda/src/egg2pg/eggLoader.cxx
View File

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

4
panda/src/glstuff/glGeomMunger_src.cxx
View File

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

20
panda/src/glstuff/glGraphicsStateGuardian_src.cxx
View File

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

12
panda/src/gobj/Sources.pp
View File

@ -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 \

12
panda/src/gobj/config_gobj.cxx
View File

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

4
panda/src/gobj/gobj_composite2.cxx
View File

@ -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"

6
panda/src/gobj/internalName.I
View File

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

4
panda/src/gobj/qpgeomVertexAnimationSpec.I
View File

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

64
panda/src/gobj/qpgeomVertexData.I
View File

@ -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),

126
panda/src/gobj/qpgeomVertexData.cxx
View File

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

26
panda/src/gobj/qpgeomVertexData.h
View File

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

4
panda/src/gobj/sliderTable.I
View File

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

2
panda/src/gobj/sliderTable.h
View File

@ -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

2
panda/src/gobj/transformBlend.h
View File

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

52
panda/src/gobj/transformBlendPalette.I → panda/src/gobj/transformBlendTable.I
View File

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

114
panda/src/gobj/transformBlendPalette.cxx → panda/src/gobj/transformBlendTable.cxx
View File

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

34
panda/src/gobj/transformBlendPalette.h → panda/src/gobj/transformBlendTable.h
View File

@ -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

68
panda/src/gobj/transformPalette.I → panda/src/gobj/transformTable.I
View File

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

114
panda/src/gobj/transformPalette.cxx → panda/src/gobj/transformTable.cxx
View File

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

28
panda/src/gobj/transformPalette.h → panda/src/gobj/transformTable.h
View File

@ -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

6
panda/src/gobj/vertexTransform.cxx
View File

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

8
panda/src/gobj/vertexTransform.h
View File

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