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

pgraph static char joints to bams

This commit is contained in:
David Rose 2002-03-20 14:01:49 +00:00
parent 91d39e9f11
commit d4482780b5
6 changed files with 127 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
panda/src/char/characterJoint.cxx
View File

@ -383,6 +383,7 @@ void CharacterJoint::
write_datagram(BamWriter *manager, Datagram &me)
{
ArcList::iterator ai;
NodeList::iterator ni;
// First, make sure all of our arcs are still valid, before we try
// to write them out. Remove any invalid arcs.
@ -414,18 +415,35 @@ write_datagram(BamWriter *manager, Datagram &me)
}
MovingPartMatrix::write_datagram(manager, me);
me.add_uint16(_net_transform_arcs.size());
for(ai = _net_transform_arcs.begin(); ai != _net_transform_arcs.end(); ai++) {
me.add_uint16(_net_transform_arcs.size());
for(ai = _net_transform_arcs.begin();
ai != _net_transform_arcs.end();
ai++) {
manager->write_pointer(me, (*ai));
}
me.add_uint16(_local_transform_arcs.size());
for(ai = _local_transform_arcs.begin(); ai != _local_transform_arcs.end(); ai++)
{
for(ai = _local_transform_arcs.begin();
ai != _local_transform_arcs.end();
ai++) {
manager->write_pointer(me, (*ai));
}
me.add_uint16(_net_transform_nodes.size());
for(ni = _net_transform_nodes.begin();
ni != _net_transform_nodes.end();
ni++) {
manager->write_pointer(me, (*ni));
}
me.add_uint16(_local_transform_nodes.size());
for(ni = _local_transform_nodes.begin();
ni != _local_transform_nodes.end();
ni++) {
manager->write_pointer(me, (*ni));
}
_initial_net_transform_inverse.write_datagram(me);
}
@ -438,22 +456,36 @@ write_datagram(BamWriter *manager, Datagram &me)
// place
////////////////////////////////////////////////////////////////////
void CharacterJoint::
fillin(DatagramIterator& scan, BamReader* manager)
{
fillin(DatagramIterator &scan, BamReader *manager) {
int i;
MovingPartMatrix::fillin(scan, manager);
_num_net_arcs = scan.get_uint16();
for(i = 0; i < _num_net_arcs; i++)
{
for(i = 0; i < _num_net_arcs; i++) {
manager->read_pointer(scan);
}
_num_local_arcs = scan.get_uint16();
for(i = 0; i < _num_local_arcs; i++)
{
for(i = 0; i < _num_local_arcs; i++) {
manager->read_pointer(scan);
}
if (manager->get_file_minor_ver() < 7) {
// No _node lists before version 3.7.
_num_net_nodes = 0;
_num_local_nodes = 0;
} else {
_num_net_nodes = scan.get_uint16();
for(i = 0; i < _num_net_nodes; i++) {
manager->read_pointer(scan);
}
_num_local_nodes = scan.get_uint16();
for(i = 0; i < _num_local_nodes; i++) {
manager->read_pointer(scan);
}
cerr << "read " << _num_net_nodes << " net transforms\n";
}
_initial_net_transform_inverse.read_datagram(scan);
}
@ -467,38 +499,26 @@ fillin(DatagramIterator& scan, BamReader* manager)
int CharacterJoint::
complete_pointers(TypedWritable **p_list, BamReader* manager)
{
int pi = MovingPartMatrix::complete_pointers(p_list, manager);
int i;
int start = MovingPartMatrix::complete_pointers(p_list, manager);
int mid = start+_num_net_arcs;
int end = start+_num_net_arcs+_num_local_arcs;
for(i = start; i < mid; i++)
{
if (p_list[i] == TypedWritable::Null)
{
char_cat->warning() << get_name()
<< " Ignoring null Net NodeRelation" << endl;
}
else
{
add_net_transform(DCAST(NodeRelation, p_list[i]));
}
for (i = 0; i < _num_net_arcs; i++) {
add_net_transform(DCAST(NodeRelation, p_list[pi++]));
}
for(i = mid; i < end; i++)
{
if (p_list[i] == TypedWritable::Null)
{
char_cat->warning() << get_name()
<< " Ignoring null Local NodeRelation" << endl;
}
else
{
add_local_transform(DCAST(NodeRelation, p_list[i]));
}
for (i = 0; i < _num_local_arcs; i++) {
add_local_transform(DCAST(NodeRelation, p_list[pi++]));
}
return end;
for (i = 0; i < _num_net_nodes; i++) {
add_net_transform(DCAST(PandaNode, p_list[pi++]));
}
for (i = 0; i < _num_local_nodes; i++) {
add_local_transform(DCAST(PandaNode, p_list[pi++]));
}
return pi;
}
////////////////////////////////////////////////////////////////////

2
panda/src/char/characterJoint.h
View File

@ -87,6 +87,7 @@ protected:
private:
int _num_net_arcs, _num_local_arcs;
int _num_net_nodes, _num_local_nodes;
public:
// The _geom_node member just holds a temporary pointer to a node
@ -118,6 +119,7 @@ private:
static TypeHandle _type_handle;
friend class Character;
friend class qpCharacter;
};
#endif

146
panda/src/char/qpcharacter.cxx
View File

@ -21,13 +21,12 @@
#include "computedVertices.h"
#include "config_char.h"
#include "geomNode.h"
#include "qpgeomNode.h"
#include "datagram.h"
#include "datagramIterator.h"
#include "bamReader.h"
#include "bamWriter.h"
#include "pStatTimer.h"
#include "geomNode.h"
#include "animControl.h"
#include "clockObject.h"
#include "pStatTimer.h"
@ -211,92 +210,76 @@ copy_joints(PartGroup *copy, PartGroup *orig) {
}
}
/*
////////////////////////////////////////////////////////////////////
// Function: qpCharacter::r_copy_subgraph
// Access: Private, Virtual
// Description: This is a virtual function inherited from Node. It's
// called when a copy_subgraph() operation reaches the
// qpCharacter node. In the case of a qpCharacter, it's
// overridden to do the all right things to copy the
// dynamic geometry to the new qpCharacter.
// Function: qpCharacter::r_copy_children
// Access: Protected, Virtual
// Description: This is called by r_copy_subgraph(); the copy has
// already been made of this particular node (and this
// is the copy); this function's job is to copy all of
// the children from the original.
//
// Note that it includes the parameter inst_map, which
// is a map type, and is not (and cannot be) exported
// from PANDA.DLL. Thus, any derivative of Node that is
// not also a member of PANDA.DLL *cannot* access this
// map.
// from PANDA.DLL. Thus, any derivative of PandaNode
// that is not also a member of PANDA.DLL *cannot*
// access this map, and probably should not even
// override this function.
////////////////////////////////////////////////////////////////////
Node *qpCharacter::
r_copy_subgraph(TypeHandle graph_type, Node::InstanceMap &) const {
Node *copy = make_copy();
nassertr(copy != (Node *)NULL, NULL);
if (copy->get_type() != get_type()) {
graph_cat.warning()
<< "Don't know how to copy nodes of type " << get_type() << "\n";
}
void qpCharacter::
r_copy_children(const PandaNode *from, PandaNode::InstanceMap &inst_map) {
// We assume there will be no instancing going on below the
// qpCharacter node. If there is, too bad; it will get flattened out.
// Now we preempt the node's r_copy_subgraph() operation with our
// own function that keeps track of the old vs. new arcs and also
// We preempt the node's r_copy_children() operation with our own
// function that keeps track of the old vs. new nodes and also
// updates any Geoms we find with our new dynamic vertices.
qpCharacter *char_copy;
DCAST_INTO_R(char_copy, copy, NULL);
ArcMap arc_map;
char_copy->r_copy_char(char_copy, this, graph_type, this, arc_map);
char_copy->copy_arc_pointers(this, arc_map);
return copy;
const qpCharacter *from_char;
DCAST_INTO_V(from_char, from);
NodeMap node_map;
r_copy_char(this, from_char, from_char, node_map);
copy_node_pointers(from_char, node_map);
}
*/
/*
////////////////////////////////////////////////////////////////////
// Function: qpCharacter::r_copy_char
// Access: Private
// Description: Recursively walks the scene graph hierarchy below the
// Description: Recursively walks the scene graph hiernodehy below the
// qpCharacter node, duplicating it while noting the
// orig:copy arc mappings, and also updates any
// orig:copy node mappings, and also updates any
// GeomNodes found.
////////////////////////////////////////////////////////////////////
void qpCharacter::
r_copy_char(Node *dest, const Node *source, TypeHandle graph_type,
const qpCharacter *from, qpCharacter::ArcMap &arc_map) {
if (source->is_of_type(GeomNode::get_class_type())) {
const GeomNode *source_gnode;
GeomNode *dest_gnode;
r_copy_char(PandaNode *dest, const PandaNode *source,
const qpCharacter *from, qpCharacter::NodeMap &node_map) {
if (source->is_geom_node()) {
const qpGeomNode *source_gnode;
qpGeomNode *dest_gnode;
DCAST_INTO_V(source_gnode, source);
DCAST_INTO_V(dest_gnode, dest);
dest_gnode->clear();
dest_gnode->remove_all_geoms();
int num_geoms = source_gnode->get_num_geoms();
for (int i = 0; i < num_geoms; i++) {
dDrawable *d = source_gnode->get_geom(i);
if (d->is_of_type(Geom::get_class_type())) {
dest_gnode->add_geom(copy_geom(DCAST(Geom, d), from));
} else {
dest_gnode->add_geom(d);
}
Geom *geom = source_gnode->get_geom(i);
const RenderState *state = source_gnode->get_geom_state(i);
dest_gnode->add_geom(copy_geom(geom, from), state);
}
}
int num_children = source->get_num_children(graph_type);
int num_children = source->get_num_children();
for (int i = 0; i < num_children; i++) {
NodeRelation *source_arc = source->get_child(graph_type, i);
const Node *source_child = source_arc->get_child();
nassertv(source_child != (Node *)NULL);
const PandaNode *source_child = source->get_child(i);
int source_sort = source->get_child_sort(i);
Node *dest_child;
PandaNode *dest_child;
if (source_child->is_of_type(qpCharacter::get_class_type())) {
// We make a special case for nodes of type qpCharacter. If we
// encounter one of these, we have a qpCharacter under a
// qpCharacter, and the nested qpCharacter's copy should be called
// instead of ours.
dest_child = source_child->copy_subgraph(graph_type);
dest_child = source_child->copy_subgraph();
} else {
// Otherwise, we assume that make_copy() will make a suitable
@ -304,21 +287,13 @@ r_copy_char(Node *dest, const Node *source, TypeHandle graph_type,
// have parented to a qpCharacter and expect copy_subgraph() to
// work correctly. Too bad.
dest_child = source_child->make_copy();
r_copy_char(dest_child, source_child, graph_type, from, arc_map);
r_copy_char(dest_child, source_child, from, node_map);
}
NodeRelation *dest_arc =
NodeRelation::create_typed_arc(graph_type, dest, dest_child);
nassertv(dest_arc != (NodeRelation *)NULL);
nassertv(dest_arc->is_exact_type(graph_type));
dest_arc->copy_transitions_from(source_arc);
arc_map[source_arc] = dest_arc;
dest->add_child(dest_child, source_sort);
node_map[source_child] = dest_child;
}
}
*/
/*
////////////////////////////////////////////////////////////////////
// Function: qpCharacter::copy_geom
// Access: Private
@ -373,18 +348,16 @@ copy_geom(Geom *source, const qpCharacter *from) {
return dest;
}
*/
/*
////////////////////////////////////////////////////////////////////
// Function: qpCharacter::copy_arc_pointers
// Function: qpCharacter::copy_node_pointers
// Access: Public
// Description: Creates _net_transform_arcs and _local_transform_arcs
// Description: Creates _net_transform_nodes and _local_transform_nodes
// as appropriate in each of the qpCharacter's joints, as
// copied from the other qpCharacter.
////////////////////////////////////////////////////////////////////
void qpCharacter::
copy_arc_pointers(const qpCharacter *from, const qpCharacter::ArcMap &arc_map) {
copy_node_pointers(const qpCharacter *from, const qpCharacter::NodeMap &node_map) {
nassertv(_parts.size() == from->_parts.size());
for (int i = 0; i < (int)_parts.size(); i++) {
if (_parts[i]->is_of_type(CharacterJoint::get_class_type())) {
@ -394,44 +367,43 @@ copy_arc_pointers(const qpCharacter *from, const qpCharacter::ArcMap &arc_map) {
DCAST_INTO_V(source_joint, from->_parts[i]);
DCAST_INTO_V(dest_joint, _parts[i]);
CharacterJoint::ArcList::const_iterator ai;
for (ai = source_joint->_net_transform_arcs.begin();
ai != source_joint->_net_transform_arcs.end();
CharacterJoint::NodeList::const_iterator ai;
for (ai = source_joint->_net_transform_nodes.begin();
ai != source_joint->_net_transform_nodes.end();
++ai) {
NodeRelation *source_arc = (*ai);
PandaNode *source_node = (*ai);
ArcMap::const_iterator mi;
mi = arc_map.find(source_arc);
if (mi != arc_map.end()) {
NodeRelation *dest_arc = (*mi).second;
NodeMap::const_iterator mi;
mi = node_map.find(source_node);
if (mi != node_map.end()) {
PandaNode *dest_node = (*mi).second;
// Here's an internal joint that the source qpCharacter was
// animating directly. We'll animate our corresponding
// joint the same way.
dest_joint->add_net_transform(dest_arc);
dest_joint->add_net_transform(dest_node);
}
}
for (ai = source_joint->_local_transform_arcs.begin();
ai != source_joint->_local_transform_arcs.end();
for (ai = source_joint->_local_transform_nodes.begin();
ai != source_joint->_local_transform_nodes.end();
++ai) {
NodeRelation *source_arc = (*ai);
PandaNode *source_node = (*ai);
ArcMap::const_iterator mi;
mi = arc_map.find(source_arc);
if (mi != arc_map.end()) {
NodeRelation *dest_arc = (*mi).second;
NodeMap::const_iterator mi;
mi = node_map.find(source_node);
if (mi != node_map.end()) {
PandaNode *dest_node = (*mi).second;
// Here's an internal joint that the source qpCharacter was
// animating directly. We'll animate our corresponding
// joint the same way.
dest_joint->add_local_transform(dest_arc);
dest_joint->add_local_transform(dest_node);
}
}
}
}
}
*/
////////////////////////////////////////////////////////////////////

14
panda/src/char/qpcharacter.h
View File

@ -66,15 +66,13 @@ PUBLISHED:
private:
void copy_joints(PartGroup *copy, PartGroup *orig);
/*
typedef pmap<NodeRelation *, NodeRelation *> ArcMap;
virtual Node *r_copy_subgraph(TypeHandle graph_type,
InstanceMap &inst_map) const;
void r_copy_char(Node *dest, const Node *source, TypeHandle graph_type,
const qpCharacter *from, ArcMap &arc_map);
typedef pmap<const PandaNode *, PandaNode *> NodeMap;
virtual void r_copy_children(const PandaNode *from, InstanceMap &inst_map);
void r_copy_char(PandaNode *dest, const PandaNode *source,
const qpCharacter *from, NodeMap &node_map);
PT(Geom) copy_geom(Geom *source, const qpCharacter *from);
void copy_arc_pointers(const qpCharacter *from, const ArcMap &arc_map);
*/
void copy_node_pointers(const qpCharacter *from, const NodeMap &node_map);
// These are the actual dynamic vertex pools for this qpCharacter's
// ComputedVertices--the vertices that it will recompute each frame

2
panda/src/egg2pg/qpcharacterMaker.cxx
View File

@ -217,7 +217,7 @@ parent_joint_nodes(PartGroup *part) {
PandaNode *joint_node = joint->_qpgeom_node;
if (joint_node != NULL) {
_character_node->add_child(joint_node);
// joint->add_net_transform(joint_node);
joint->add_net_transform(joint_node);
joint_node->set_transform(TransformState::make_mat(joint->_net_transform));
}
}

3
panda/src/putil/bam.h
View File

@ -32,7 +32,7 @@ static const unsigned short _bam_major_ver = 3;
// Bumped to major version 2 on 7/6/00 due to major changes in Character.
// Bumped to major version 3 on 12/8/00 to change float64's to float32's.
static const unsigned short _bam_minor_ver = 6;
static const unsigned short _bam_minor_ver = 7;
// Bumped to minor version 1 on 12/15/00 to add FFT-style channel
// compression.
// Bumped to minor version 2 on 2/15/01 to add ModelNode::_preserve_transform.
@ -40,6 +40,7 @@ static const unsigned short _bam_minor_ver = 6;
// Bumped to minor version 4 on 12/11/01 to transpose quaternions.
// Bumped to minor version 5 on 12/13/01 to remove obsolete fields from Texture.
// Bumped to minor version 6 on 5/16/02 to add ImageBuffer::_filename.
// Bumped to minor version 7 on 5/19/02 to add CharacterJoint::_net_transform_nodes, etc.
#endif