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

747 lines
28 KiB
C++
Raw Blame History

// Filename: eggCharacterCollection.cxx
// Created by: drose (26Feb01)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
//
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
// along with this source code; you will also find a current copy of
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
//
// To contact the maintainers of this program write to
// panda3d-general@lists.sourceforge.net .
//
////////////////////////////////////////////////////////////////////
#include "eggCharacterCollection.h"
#include "eggCharacterData.h"
#include "eggJointData.h"
#include "eggSliderData.h"
#include "dcast.h"
#include "eggGroup.h"
#include "eggTable.h"
#include "eggPrimitive.h"
#include "eggVertex.h"
#include "eggVertexUV.h"
#include "eggMorphList.h"
#include "eggSAnimData.h"
#include "indirectCompareNames.h"
#include "indent.h"
#include <algorithm>
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::Constructor
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
EggCharacterCollection::
EggCharacterCollection() {
_next_model_index = 0;
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::Destructor
// Access: Public, Virtual
// Description:
////////////////////////////////////////////////////////////////////
EggCharacterCollection::
~EggCharacterCollection() {
Characters::iterator ci;
for (ci = _characters.begin(); ci != _characters.end(); ++ci) {
delete (*ci);
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::add_egg
// Access: Public
// Description: Adds a new egg file to the list of models and
// animation files for this particular character.
//
// Returns the new egg_index if the file is successfully
// added, or -1 if there is some problem (for instance,
// it does not contain a character model or animation
// table).
//
// If the joint hierarchy does not match the existing
// joint hierarchy, a best match is attempted.
////////////////////////////////////////////////////////////////////
int EggCharacterCollection::
add_egg(EggData *egg) {
_top_egg_nodes.clear();
if (!scan_hierarchy(egg)) {
return -1;
}
int egg_index = _eggs.size();
_eggs.push_back(EggInfo());
EggInfo &egg_info = _eggs.back();
egg_info._egg = egg;
egg_info._first_model_index = 0;
// Now, for each model, add an entry in the egg_info and match the
// joint hierarchy to the known joints.
TopEggNodesByName::iterator tni;
for (tni = _top_egg_nodes.begin(); tni != _top_egg_nodes.end(); ++tni) {
string character_name = (*tni).first;
TopEggNodes &top_nodes = (*tni).second;
EggCharacterData *char_data = make_character(character_name);
EggJointData *root_joint = char_data->get_root_joint();
TopEggNodes::iterator ti;
for (ti = top_nodes.begin(); ti != top_nodes.end(); ++ti) {
EggNode *model_root = (*ti).first;
ModelDescription &desc = (*ti).second;
int model_index = _next_model_index++;
if (egg_info._models.empty()) {
egg_info._first_model_index = model_index;
}
egg_info._models.push_back(model_root);
char_data->add_model(model_index, model_root, egg);
nassertr(model_index == (int)_characters_by_model_index.size(), -1);
_characters_by_model_index.push_back(char_data);
root_joint->add_back_pointer(model_index, desc._root_node);
match_egg_nodes(char_data, root_joint, desc._top_nodes,
egg_index, model_index);
scan_for_morphs(model_root, model_index, char_data);
scan_for_sliders(model_root, model_index, char_data);
}
}
return egg_index;
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::get_character_by_name
// Access: Public
// Description: Returns the Character with the indicated name, if it
// exists in the collection, or NULL if it does not.
////////////////////////////////////////////////////////////////////
EggCharacterData *EggCharacterCollection::
get_character_by_name(const string &character_name) const {
Characters::const_iterator ci;
for (ci = _characters.begin(); ci != _characters.end(); ++ci) {
EggCharacterData *char_data = (*ci);
if (char_data->get_name() == character_name) {
return char_data;
}
}
return (EggCharacterData *)NULL;
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::make_character_data
// Access: Public, Virtual
// Description: Allocates and returns a new EggCharacterData
// structure. This is primarily intended as a hook so
// derived classes can customize the type of
// EggCharacterData nodes used to represent the
// characters in this collection.
////////////////////////////////////////////////////////////////////
EggCharacterData *EggCharacterCollection::
make_character_data() {
return new EggCharacterData(this);
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::make_joint_data
// Access: Public, Virtual
// Description: Allocates and returns a new EggJointData structure
// for the given character. This is primarily intended
// as a hook so derived classes can customize the type
// of EggJointData nodes used to represent the joint
// hierarchy.
////////////////////////////////////////////////////////////////////
EggJointData *EggCharacterCollection::
make_joint_data(EggCharacterData *char_data) {
return new EggJointData(this, char_data);
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::make_slider_data
// Access: Public, Virtual
// Description: Allocates and returns a new EggSliderData structure
// for the given character. This is primarily intended
// as a hook so derived classes can customize the type
// of EggSliderData nodes used to represent the slider
// list.
////////////////////////////////////////////////////////////////////
EggSliderData *EggCharacterCollection::
make_slider_data(EggCharacterData *char_data) {
return new EggSliderData(this, char_data);
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::make_character
// Access: Protected
// Description: Allocates and returns a new EggCharacterData object
// representing the named character, if there is not
// already a character by that name.
////////////////////////////////////////////////////////////////////
EggCharacterData *EggCharacterCollection::
make_character(const string &character_name) {
// Does the named character exist yet?
Characters::iterator ci;
for (ci = _characters.begin(); ci != _characters.end(); ++ci) {
EggCharacterData *char_data = (*ci);
if (char_data->get_name() == character_name) {
return char_data;
}
}
// Define a new character.
EggCharacterData *char_data = make_character_data();
char_data->set_name(character_name);
_characters.push_back(char_data);
return char_data;
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::scan_hierarchy
// Access: Private
// Description: Walks the given egg data's hierarchy, looking for
// either the start of an animation channel or the start
// of a character model. Returns true if either (or
// both) is found, false if the model appears to have
// nothing to do with characters.
//
// Fills up the _top_egg_nodes according to the nodes
// found.
////////////////////////////////////////////////////////////////////
bool EggCharacterCollection::
scan_hierarchy(EggNode *egg_node) {
if (egg_node->is_of_type(EggGroup::get_class_type())) {
EggGroup *group = DCAST(EggGroup, egg_node);
if (group->get_dart_type() != EggGroup::DT_none) {
// A group with a <Dart> flag begins a character model.
scan_for_top_joints(group, group, group->get_name());
return true;
}
} else if (egg_node->is_of_type(EggTable::get_class_type())) {
EggTable *table = DCAST(EggTable, egg_node);
if (table->get_table_type() == EggTable::TT_bundle) {
// A <Bundle> begins an animation table.
scan_for_top_tables(table, table, table->get_name());
return true;
}
}
bool character_found = false;
if (egg_node->is_of_type(EggGroupNode::get_class_type())) {
EggGroupNode *group = DCAST(EggGroupNode, egg_node);
EggGroupNode::iterator gi;
for (gi = group->begin(); gi != group->end(); ++gi) {
if (scan_hierarchy(*gi)) {
character_found = true;
}
}
}
return character_found;
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::scan_for_top_joints
// Access: Private
// Description: Once a character model has been found, continue
// scanning the egg hierarchy to look for the topmost
// <Joint> nodes encountered.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
scan_for_top_joints(EggNode *egg_node, EggNode *model_root,
const string &character_name) {
if (egg_node->is_of_type(EggGroup::get_class_type())) {
EggGroup *group = DCAST(EggGroup, egg_node);
if (group->has_lod()) {
// This group has an LOD specification; that indicates multiple
// skeleton hierarchies for this character, one for each LOD.
// We call each of these a separate model.
model_root = group;
}
if (group->get_group_type() == EggGroup::GT_joint) {
// A <Joint> node begins a model hierarchy.
ModelDescription &desc = _top_egg_nodes[character_name][model_root];
desc._root_node = model_root;
desc._top_nodes.push_back(group);
return;
}
}
if (egg_node->is_of_type(EggGroupNode::get_class_type())) {
EggGroupNode *group = DCAST(EggGroupNode, egg_node);
EggGroupNode::iterator gi;
for (gi = group->begin(); gi != group->end(); ++gi) {
scan_for_top_joints(*gi, model_root, character_name);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::scan_for_top_tables
// Access: Private
// Description: Once an animation has been found, continue scanning
// the egg hierarchy to look for the topmost <Table>
// nodes encountered.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
scan_for_top_tables(EggTable *bundle, EggNode *model_root,
const string &character_name) {
// We really only need to check the immediate children of the bundle
// for a table node called "<skeleton>".
EggGroupNode::iterator gi;
for (gi = bundle->begin(); gi != bundle->end(); ++gi) {
EggNode *child = (*gi);
if (child->is_of_type(EggTable::get_class_type())) {
EggTable *table = DCAST(EggTable, child);
if (table->get_name() == "<skeleton>") {
// Here it is! Now the immediate children of this node are
// the top tables.
ModelDescription &desc = _top_egg_nodes[character_name][model_root];
desc._root_node = table;
EggGroupNode::iterator cgi;
for (cgi = table->begin(); cgi != table->end(); ++cgi) {
EggNode *grandchild = (*cgi);
if (grandchild->is_of_type(EggTable::get_class_type())) {
desc._top_nodes.push_back(grandchild);
}
}
}
}
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::scan_for_morphs
// Access: Private
// Description: Go back through a model's hierarchy and look for
// morph targets on the vertices and primitives.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
scan_for_morphs(EggNode *egg_node, int model_index,
EggCharacterData *char_data) {
if (egg_node->is_of_type(EggPrimitive::get_class_type())) {
EggPrimitive *prim = DCAST(EggPrimitive, egg_node);
// Check for morphs on the primitive.
add_morph_back_pointers(prim, prim, model_index, char_data);
// Also check for morphs on each of the prim's vertices.
EggPrimitive::const_iterator vi;
for (vi = prim->begin(); vi != prim->end(); ++vi) {
EggVertex *vertex = (*vi);
add_morph_back_pointers(vertex, vertex, model_index, char_data);
add_morph_back_pointers_vertex(vertex, vertex, model_index, char_data);
EggMorphVertexList::const_iterator mvi;
for (mvi = vertex->_dxyzs.begin();
mvi != vertex->_dxyzs.end();
++mvi) {
const EggMorphVertex &morph = (*mvi);
char_data->make_slider(morph.get_name())->add_back_pointer(model_index, vertex);
}
}
}
if (egg_node->is_of_type(EggGroupNode::get_class_type())) {
EggGroupNode *group = DCAST(EggGroupNode, egg_node);
EggGroupNode::iterator gi;
for (gi = group->begin(); gi != group->end(); ++gi) {
scan_for_morphs(*gi, model_index, char_data);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::scan_for_sliders
// Access: Private
// Description: Go back to the animation tables and look for morph
// slider animation channels.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
scan_for_sliders(EggNode *egg_node, int model_index,
EggCharacterData *char_data) {
if (egg_node->is_of_type(EggTable::get_class_type())) {
EggTable *bundle = DCAST(EggTable, egg_node);
// We really only need to check the immediate children of the
// bundle for a table node called "morph". This is a sibling of
// "<skeleton>", which we found a minute ago, but we weren't ready
// to scan for the morph sliders at the time, so we have to look
// again now.
EggGroupNode::iterator gi;
for (gi = bundle->begin(); gi != bundle->end(); ++gi) {
EggNode *child = (*gi);
if (child->is_of_type(EggTable::get_class_type())) {
EggTable *table = DCAST(EggTable, child);
if (table->get_name() == "morph") {
// Here it is! Now the immediate children of this node are
// all the slider channels.
EggGroupNode::iterator cgi;
for (cgi = table->begin(); cgi != table->end(); ++cgi) {
EggNode *grandchild = (*cgi);
if (grandchild->is_of_type(EggSAnimData::get_class_type())) {
char_data->make_slider(grandchild->get_name())->add_back_pointer(model_index, grandchild);
}
}
}
}
}
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::add_morph_back_pointers
// Access: Private
// Description: Adds the back pointers for the kinds of morphs we
// might find in an EggAttributes object.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
add_morph_back_pointers(EggAttributes *attrib, EggObject *egg_object,
int model_index, EggCharacterData *char_data) {
EggMorphNormalList::const_iterator mni;
for (mni = attrib->_dnormals.begin();
mni != attrib->_dnormals.end();
++mni) {
const EggMorphNormal &morph = (*mni);
char_data->make_slider(morph.get_name())->add_back_pointer(model_index, egg_object);
}
EggMorphColorList::const_iterator mci;
for (mci = attrib->_drgbas.begin();
mci != attrib->_drgbas.end();
++mci) {
const EggMorphColor &morph = (*mci);
char_data->make_slider(morph.get_name())->add_back_pointer(model_index, egg_object);
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::add_morph_back_pointers_vertex
// Access: Private
// Description: Adds the back pointers for the kinds of morphs we
// might find in an EggVertex object.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
add_morph_back_pointers_vertex(EggVertex *vertex, EggObject *egg_object,
int model_index, EggCharacterData *char_data) {
EggVertex::const_uv_iterator ui;
for (ui = vertex->uv_begin(); ui != vertex->uv_end(); ++ui) {
EggVertexUV *vert_uv = (*ui);
EggMorphTexCoordList::const_iterator mti;
for (mti = vert_uv->_duvs.begin();
mti != vert_uv->_duvs.end();
++mti) {
const EggMorphTexCoord &morph = (*mti);
char_data->make_slider(morph.get_name())->add_back_pointer(model_index, egg_object);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::match_egg_nodes
// Access: Private
// Description: Attempts to match up the indicated list of egg_nodes
// with the children of the given joint_data, by name if
// possible.
//
// Also recurses on each matched joint to build up the
// entire joint hierarchy.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
match_egg_nodes(EggCharacterData *char_data, EggJointData *joint_data,
EggNodeList &egg_nodes, int egg_index, int model_index) {
// Sort the list of egg_nodes in order by name. This will make the
// matching up by names easier and more reliable.
sort(egg_nodes.begin(), egg_nodes.end(), IndirectCompareNames<Namable>());
if (joint_data->_children.empty()) {
// If the EggJointData has no children yet, we must be the first.
// Gleefully define all the joints.
EggNodeList::iterator ei;
for (ei = egg_nodes.begin(); ei != egg_nodes.end(); ++ei) {
EggNode *egg_node = (*ei);
EggJointData *data = make_joint_data(char_data);
joint_data->_children.push_back(data);
char_data->_joints.push_back(data);
char_data->_components.push_back(data);
data->_parent = joint_data;
data->_new_parent = joint_data;
found_egg_match(char_data, data, egg_node, egg_index, model_index);
}
} else {
// The EggJointData already has children; therefore, we have to
// match our joints up with the already-existing ones.
EggNodeList extra_egg_nodes;
EggJointData::Children extra_data;
EggNodeList::iterator ei;
EggJointData::Children::iterator di;
ei = egg_nodes.begin();
di = joint_data->_children.begin();
while (ei != egg_nodes.end() && di != joint_data->_children.end()) {
EggNode *egg_node = (*ei);
EggJointData *data = (*di);
if (egg_node->get_name() < data->get_name()) {
// Here's a joint in the egg file, unmatched in the data.
extra_egg_nodes.push_back(egg_node);
++ei;
} else if (data->get_name() < egg_node->get_name()) {
// Here's a joint in the data, umatched by the egg file.
extra_data.push_back(data);
++di;
} else {
// Hey, these two match! Hooray!
found_egg_match(char_data, data, egg_node, egg_index, model_index);
++ei;
++di;
}
}
while (ei != egg_nodes.end()) {
EggNode *egg_node = (*ei);
// Here's a joint in the egg file, unmatched in the data.
extra_egg_nodes.push_back(egg_node);
++ei;
}
while (di != joint_data->_children.end()) {
EggJointData *data = (*di);
// Here's a joint in the data, umatched by the egg file.
extra_data.push_back(data);
++di;
}
if (!extra_egg_nodes.empty()) {
// If we have some extra egg_nodes, we have to find a place to
// match them. (If we only had extra data, we don't care.)
// First, check to see if any of the names match any past-used
// name.
EggNodeList more_egg_nodes;
for (ei = extra_egg_nodes.begin(); ei != extra_egg_nodes.end(); ++ei) {
EggNode *egg_node = (*ei);
bool matched = false;
for (di = extra_data.begin();
di != extra_data.end() && !matched;
++di) {
EggJointData *data = (*di);
if (data->matches_name(egg_node->get_name())) {
matched = true;
found_egg_match(char_data, data, egg_node, egg_index, model_index);
extra_data.erase(di);
}
}
if (!matched) {
// This joint name was never seen before.
more_egg_nodes.push_back(egg_node);
}
}
extra_egg_nodes.swap(more_egg_nodes);
}
if (!extra_egg_nodes.empty()) {
// Ok, we've still got to find a home for these remaining
// egg_nodes.
if (extra_egg_nodes.size() == extra_data.size()) {
// Match 'em up one-for-one.
size_t i;
for (i = 0; i < extra_egg_nodes.size(); i++) {
EggNode *egg_node = extra_egg_nodes[i];
EggJointData *data = extra_data[i];
found_egg_match(char_data, data, egg_node, egg_index, model_index);
}
} else {
// Just tack 'em on the end.
EggNodeList::iterator ei;
for (ei = extra_egg_nodes.begin(); ei != extra_egg_nodes.end(); ++ei) {
EggNode *egg_node = (*ei);
EggJointData *data = make_joint_data(char_data);
joint_data->_children.push_back(data);
char_data->_joints.push_back(data);
char_data->_components.push_back(data);
data->_parent = joint_data;
data->_new_parent = joint_data;
found_egg_match(char_data, data, egg_node, egg_index, model_index);
}
}
}
}
// Now sort the generated joint data hierarchy by name, just to be
// sure.
sort(joint_data->_children.begin(), joint_data->_children.end(),
IndirectCompareNames<Namable>());
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::found_egg_match
// Access: Private
// Description: Marks a one-to-one association between the indicated
// EggJointData and the indicated EggNode, and then
// recurses below.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
found_egg_match(EggCharacterData *char_data, EggJointData *joint_data,
EggNode *egg_node, int egg_index, int model_index) {
if (egg_node->has_name()) {
joint_data->add_name(egg_node->get_name(), char_data->_component_names);
}
egg_node->set_name(joint_data->get_name());
joint_data->add_back_pointer(model_index, egg_node);
if (egg_node->is_of_type(EggGroupNode::get_class_type())) {
EggGroupNode *group_node = DCAST(EggGroupNode, egg_node);
// Now consider all the children of egg_node that are themselves
// joints or tables.
EggNodeList egg_nodes;
// Two approaches: either we are scanning a model with joints, or
// an animation bundle with tables.
if (egg_node->is_of_type(EggGroup::get_class_type())) {
// A model with joints.
EggGroupNode::iterator gi;
for (gi = group_node->begin(); gi != group_node->end(); ++gi) {
EggNode *child = (*gi);
if (child->is_of_type(EggGroup::get_class_type())) {
EggGroup *group = DCAST(EggGroup, child);
if (group->get_group_type() == EggGroup::GT_joint) {
egg_nodes.push_back(group);
}
}
}
} else {
// An animation bundle with tables.
EggGroupNode::iterator gi;
for (gi = group_node->begin(); gi != group_node->end(); ++gi) {
EggNode *child = (*gi);
if (child->is_of_type(EggTable::get_class_type())) {
EggTable *table = DCAST(EggTable, child);
if (!(table->get_name() == "xform")) {
egg_nodes.push_back(table);
}
}
}
}
if (!egg_nodes.empty()) {
match_egg_nodes(char_data, joint_data, egg_nodes,
egg_index, model_index);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::rename_char
// Access: Public
// Description: Renames the ith character to the indicated name.
// This name must not already be used by another
// character in the collection.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
rename_char(int i, const string &name) {
nassertv(i >= 0 && i < (int)_characters.size());
EggCharacterData *char_data = _characters[i];
if (char_data->get_name() != name) {
nassertv(get_character_by_name(name) == (EggCharacterData *)NULL);
char_data->rename_char(name);
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::write
// Access: Public, Virtual
// Description:
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
write(ostream &out, int indent_level) const {
Characters::const_iterator ci;
for (ci = _characters.begin(); ci != _characters.end(); ++ci) {
EggCharacterData *char_data = (*ci);
char_data->write(out, indent_level);
}
}
////////////////////////////////////////////////////////////////////
// Function: EggCharacterCollection::check_errors
// Access: Public
// Description: Can be called after the collection has been
// completely filled up with egg files to output any
// messages from warning conditions that have been
// detected, such as inconsistent animation tables.
//
// In addition to reporting this errors, calling this
// function will also ensure that they are all repaired.
// Pass force_initial_rest_frame as true to also force
// rest frames from different models to be the same if
// they are initially different.
////////////////////////////////////////////////////////////////////
void EggCharacterCollection::
check_errors(ostream &out, bool force_initial_rest_frame) {
Characters::const_iterator ci;
for (ci = _characters.begin(); ci != _characters.end(); ++ci) {
EggCharacterData *char_data = (*ci);
int num_joints = char_data->get_num_joints();
for (int j = 0; j < num_joints; j++) {
EggJointData *joint_data = char_data->get_joint(j);
if (joint_data->rest_frames_differ()) {
if (force_initial_rest_frame) {
joint_data->force_initial_rest_frame();
out << "Forced rest frames the same for " << joint_data->get_name()
<< ".\n";
} else {
out << "Warning: rest frames for " << joint_data->get_name()
<< " differ.\n";
}
}
}
int num_models = char_data->get_num_models();
for (int mi = 0; mi < num_models; mi++) {
int model_index = char_data->get_model_index(mi);
if (!char_data->check_num_frames(model_index)) {
out << "Warning: animation from "
<< char_data->get_egg_data(model_index)->get_egg_filename().get_basename()
<< " had an inconsistent number of frames.\n";
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink