00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "character.h"
00016 #include "characterJoint.h"
00017 #include "config_char.h"
00018 #include "nodePath.h"
00019 #include "geomNode.h"
00020 #include "datagram.h"
00021 #include "datagramIterator.h"
00022 #include "bamReader.h"
00023 #include "bamWriter.h"
00024 #include "pStatTimer.h"
00025 #include "animControl.h"
00026 #include "clockObject.h"
00027 #include "pStatTimer.h"
00028 #include "camera.h"
00029 #include "cullTraverser.h"
00030 #include "cullTraverserData.h"
00031
00032 TypeHandle Character::_type_handle;
00033
00034 PStatCollector Character::_animation_pcollector("*:Animation");
00035
00036
00037
00038
00039
00040
00041 Character::
00042 Character(const Character ©, bool copy_bundles) :
00043 PartBundleNode(copy),
00044 _lod_center(copy._lod_center),
00045 _lod_far_distance(copy._lod_far_distance),
00046 _lod_near_distance(copy._lod_near_distance),
00047 _lod_delay_factor(copy._lod_delay_factor),
00048 _do_lod_animation(copy._do_lod_animation),
00049 _joints_pcollector(copy._joints_pcollector),
00050 _skinning_pcollector(copy._skinning_pcollector)
00051 {
00052 set_cull_callback();
00053
00054 if (copy_bundles) {
00055
00056 int num_bundles = copy.get_num_bundles();
00057 for (int i = 0; i < num_bundles; ++i) {
00058 PartBundle *orig_bundle = copy.get_bundle(i);
00059 PT(PartBundle) new_bundle = DCAST(PartBundle, orig_bundle->copy_subgraph());
00060 add_bundle(new_bundle);
00061 }
00062 } else {
00063
00064 int num_bundles = copy.get_num_bundles();
00065 for (int i = 0; i < num_bundles; ++i) {
00066 PartBundle *orig_bundle = copy.get_bundle(i);
00067 add_bundle(orig_bundle);
00068 }
00069 }
00070 _last_auto_update = -1.0;
00071 _view_frame = -1;
00072 _view_distance2 = 0.0f;
00073 }
00074
00075
00076
00077
00078
00079
00080 Character::
00081 Character(const string &name) :
00082 PartBundleNode(name, new CharacterJointBundle(name)),
00083 _joints_pcollector(PStatCollector(_animation_pcollector, name), "Joints"),
00084 _skinning_pcollector(PStatCollector(_animation_pcollector, name), "Vertices")
00085 {
00086 set_cull_callback();
00087 clear_lod_animation();
00088 _last_auto_update = -1.0;
00089 _view_frame = -1;
00090 _view_distance2 = 0.0f;
00091 }
00092
00093
00094
00095
00096
00097
00098 Character::
00099 ~Character() {
00100 int num_bundles = get_num_bundles();
00101 for (int i = 0; i < num_bundles; ++i) {
00102 r_clear_joint_characters(get_bundle(i));
00103 }
00104 }
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117 PandaNode *Character::
00118 make_copy() const {
00119 return new Character(*this, true);
00120 }
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132 PandaNode *Character::
00133 dupe_for_flatten() const {
00134 return new Character(*this, false);
00135 }
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152 PandaNode *Character::
00153 combine_with(PandaNode *other) {
00154 if (is_exact_type(get_class_type()) &&
00155 other->is_exact_type(get_class_type())) {
00156
00157 Character *c_other = DCAST(Character, other);
00158 steal_bundles(c_other);
00159 return this;
00160 }
00161
00162 return PandaNode::combine_with(other);
00163 }
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190 bool Character::
00191 cull_callback(CullTraverser *trav, CullTraverserData &data) {
00192
00193
00194
00195
00196
00197
00198 if (_do_lod_animation) {
00199 int this_frame = ClockObject::get_global_clock()->get_frame_count();
00200
00201 CPT(TransformState) rel_transform = get_rel_transform(trav, data);
00202 LPoint3 center = _lod_center * rel_transform->get_mat();
00203 PN_stdfloat dist2 = center.dot(center);
00204
00205 if (this_frame != _view_frame || dist2 < _view_distance2) {
00206 _view_frame = this_frame;
00207 _view_distance2 = dist2;
00208
00209
00210 PN_stdfloat dist = sqrt(dist2);
00211 double delay = 0.0;
00212 if (dist > _lod_near_distance) {
00213 delay = _lod_delay_factor * (dist - _lod_near_distance) / (_lod_far_distance - _lod_near_distance);
00214 nassertr(delay > 0.0, false);
00215 }
00216 set_lod_current_delay(delay);
00217
00218 if (char_cat.is_spam()) {
00219 char_cat.spam()
00220 << "Distance to " << NodePath::any_path(this) << " in frame "
00221 << this_frame << " is " << dist << ", computed delay is " << delay
00222 << "\n";
00223 }
00224 }
00225 }
00226
00227 update();
00228 return true;
00229 }
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251 CPT(TransformState) Character::
00252 calc_tight_bounds(LPoint3 &min_point, LPoint3 &max_point, bool &found_any,
00253 const TransformState *transform, Thread *current_thread) const {
00254
00255
00256
00257 ((Character *)this)->update_to_now();
00258
00259
00260
00261
00262
00263
00264 Parents parents = get_parents();
00265 for (int i = 0; i < parents.get_num_parents(); ++i) {
00266 PandaNode *parent = parents.get_parent(i);
00267 parent->get_bounds();
00268 }
00269
00270 return PandaNode::calc_tight_bounds(min_point, max_point,
00271 found_any, transform, current_thread);
00272 }
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287 void Character::
00288 merge_bundles(PartBundle *old_bundle, PartBundle *new_bundle) {
00289 if (old_bundle == new_bundle) {
00290
00291 return;
00292 }
00293
00294
00295 PT(PartBundleHandle) old_bundle_handle;
00296 Bundles::const_iterator bi;
00297 for (bi = _bundles.begin(); bi != _bundles.end(); ++bi) {
00298 if ((*bi)->get_bundle() == old_bundle) {
00299 old_bundle_handle = (*bi);
00300 break;
00301 }
00302 }
00303 nassertv(!old_bundle_handle.is_null());
00304
00305 PT(PartBundleHandle) new_bundle_handle = new PartBundleHandle(new_bundle);
00306 merge_bundles(old_bundle_handle, new_bundle_handle);
00307 }
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336 void Character::
00337 merge_bundles(PartBundleHandle *old_bundle_handle,
00338 PartBundleHandle *new_bundle_handle) {
00339 PartBundle *old_bundle = old_bundle_handle->get_bundle();
00340 PartBundle *new_bundle = new_bundle_handle->get_bundle();
00341 new_bundle->merge_anim_preloads(old_bundle);
00342
00343 update_bundle(old_bundle_handle, new_bundle);
00344 }
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377 void Character::
00378 set_lod_animation(const LPoint3 ¢er,
00379 PN_stdfloat far_distance, PN_stdfloat near_distance,
00380 PN_stdfloat delay_factor) {
00381 nassertv(far_distance >= near_distance);
00382 nassertv(delay_factor >= 0.0f);
00383 _lod_center = center;
00384 _lod_far_distance = far_distance;
00385 _lod_near_distance = near_distance;
00386 _lod_delay_factor = delay_factor;
00387 _do_lod_animation = (_lod_far_distance > _lod_near_distance && _lod_delay_factor > 0.0);
00388 if (!_do_lod_animation) {
00389 set_lod_current_delay(0.0);
00390 }
00391 }
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401 void Character::
00402 clear_lod_animation() {
00403 _lod_center = LPoint3::zero();
00404 _lod_far_distance = 0.0f;
00405 _lod_near_distance = 0.0f;
00406 _lod_delay_factor = 0.0f;
00407 _do_lod_animation = false;
00408 set_lod_current_delay(0.0);
00409 }
00410
00411
00412
00413
00414
00415
00416
00417
00418 CharacterJoint *Character::
00419 find_joint(const string &name) const {
00420 int num_bundles = get_num_bundles();
00421 for (int i = 0; i < num_bundles; ++i) {
00422 PartGroup *part = get_bundle(i)->find_child(name);
00423 if (part != (PartGroup *)NULL &&
00424 part->is_of_type(CharacterJoint::get_class_type())) {
00425 return DCAST(CharacterJoint, part);
00426 }
00427 }
00428
00429 return NULL;
00430 }
00431
00432
00433
00434
00435
00436
00437
00438
00439 CharacterSlider *Character::
00440 find_slider(const string &name) const {
00441 int num_bundles = get_num_bundles();
00442 for (int i = 0; i < num_bundles; ++i) {
00443 PartGroup *part = get_bundle(i)->find_child(name);
00444 if (part != (PartGroup *)NULL &&
00445 part->is_of_type(CharacterSlider::get_class_type())) {
00446 return DCAST(CharacterSlider, part);
00447 }
00448 }
00449
00450 return NULL;
00451 }
00452
00453
00454
00455
00456
00457
00458
00459
00460 void Character::
00461 write_parts(ostream &out) const {
00462 int num_bundles = get_num_bundles();
00463 for (int i = 0; i < num_bundles; ++i) {
00464 get_bundle(i)->write(out, 0);
00465 }
00466 }
00467
00468
00469
00470
00471
00472
00473
00474
00475 void Character::
00476 write_part_values(ostream &out) const {
00477 int num_bundles = get_num_bundles();
00478 for (int i = 0; i < num_bundles; ++i) {
00479 get_bundle(i)->write_with_value(out, 0);
00480 }
00481 }
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494 void Character::
00495 update_to_now() {
00496 update();
00497 }
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507 void Character::
00508 update() {
00509 double now = ClockObject::get_global_clock()->get_frame_time();
00510 if (now != _last_auto_update) {
00511 _last_auto_update = now;
00512
00513 if (char_cat.is_spam()) {
00514 char_cat.spam()
00515 << "Animating " << NodePath::any_path(this)
00516 << " at time " << now << "\n";
00517 }
00518
00519 PStatTimer timer(_joints_pcollector);
00520 do_update();
00521 }
00522 }
00523
00524
00525
00526
00527
00528
00529
00530 void Character::
00531 force_update() {
00532
00533 PStatTimer timer(_joints_pcollector);
00534
00535
00536 int num_bundles = get_num_bundles();
00537 for (int i = 0; i < num_bundles; ++i) {
00538 get_bundle(i)->force_update();
00539 }
00540 }
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557 void Character::
00558 r_copy_children(const PandaNode *from, PandaNode::InstanceMap &inst_map,
00559 Thread *current_thread) {
00560
00561
00562
00563
00564
00565
00566
00567 const Character *from_char;
00568 DCAST_INTO_V(from_char, from);
00569 NodeMap node_map;
00570 JointMap joint_map;
00571
00572 int num_bundles = get_num_bundles();
00573 nassertv(from_char->get_num_bundles() == num_bundles);
00574 int i;
00575 for (i = 0; i < num_bundles; ++i) {
00576 fill_joint_map(joint_map, get_bundle(i), from_char->get_bundle(i));
00577 }
00578
00579 GeomVertexMap gvmap;
00580 GeomJointMap gjmap;
00581 GeomSliderMap gsmap;
00582 r_copy_char(this, from_char, from_char, node_map, joint_map,
00583 gvmap, gjmap, gsmap);
00584
00585 for (i = 0; i < num_bundles; ++i) {
00586 copy_node_pointers(node_map, get_bundle(i), from_char->get_bundle(i));
00587 }
00588 }
00589
00590
00591
00592
00593
00594
00595
00596
00597 void Character::
00598 update_bundle(PartBundleHandle *old_bundle_handle, PartBundle *new_bundle) {
00599 if (old_bundle_handle->get_bundle() == new_bundle) {
00600
00601 return;
00602 }
00603
00604
00605
00606 JointMap joint_map;
00607 r_merge_bundles(joint_map, old_bundle_handle->get_bundle(), new_bundle);
00608
00609 PartBundleNode::update_bundle(old_bundle_handle, new_bundle);
00610
00611
00612 GeomVertexMap gvmap;
00613 GeomJointMap gjmap;
00614 GeomSliderMap gsmap;
00615 r_update_geom(this, joint_map, gvmap, gjmap, gsmap);
00616 }
00617
00618
00619
00620
00621
00622
00623
00624 CPT(TransformState) Character::
00625 get_rel_transform(CullTraverser *trav, CullTraverserData &data) {
00626
00627 Camera *camera = trav->get_scene()->get_camera_node();
00628
00629
00630 CPT(TransformState) rel_transform;
00631
00632 NodePath lod_center = camera->get_lod_center();
00633 if (!lod_center.is_empty()) {
00634 rel_transform =
00635 lod_center.get_net_transform()->invert_compose(data.get_net_transform(trav));
00636 } else {
00637 NodePath cull_center = camera->get_cull_center();
00638 if (!cull_center.is_empty()) {
00639 rel_transform =
00640 cull_center.get_net_transform()->invert_compose(data.get_net_transform(trav));
00641 } else {
00642 rel_transform = data.get_modelview_transform(trav);
00643 }
00644 }
00645
00646 return rel_transform;
00647 }
00648
00649
00650
00651
00652
00653
00654
00655 void Character::
00656 do_update() {
00657
00658 if (even_animation) {
00659 int num_bundles = get_num_bundles();
00660 for (int i = 0; i < num_bundles; ++i) {
00661 get_bundle(i)->force_update();
00662 }
00663 } else {
00664 int num_bundles = get_num_bundles();
00665 for (int i = 0; i < num_bundles; ++i) {
00666 get_bundle(i)->update();
00667 }
00668 }
00669 }
00670
00671
00672
00673
00674
00675
00676
00677 void Character::
00678 set_lod_current_delay(double delay) {
00679 int num_bundles = get_num_bundles();
00680 for (int i = 0; i < num_bundles; ++i) {
00681 get_bundle(i)->set_update_delay(delay);
00682 }
00683 }
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693 void Character::
00694 fill_joint_map(Character::JointMap &joint_map,
00695 PartGroup *copy, PartGroup *orig) {
00696 joint_map[orig] = copy;
00697
00698 int i = 0, j = 0;
00699 int copy_num_children = copy->get_num_children();
00700 int orig_num_children = orig->get_num_children();
00701
00702 while (i < copy_num_children && j < orig_num_children) {
00703 PartGroup *pc = copy->get_child(i);
00704 PartGroup *ac = orig->get_child(j);
00705
00706 if (pc->get_name() < ac->get_name()) {
00707 i++;
00708 } else if (ac->get_name() < pc->get_name()) {
00709 j++;
00710 } else {
00711 fill_joint_map(joint_map, pc, ac);
00712 i++;
00713 j++;
00714 }
00715 }
00716 }
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726 void Character::
00727 r_merge_bundles(Character::JointMap &joint_map,
00728 PartGroup *old_group, PartGroup *new_group) {
00729 joint_map[old_group] = new_group;
00730
00731 if (new_group->is_of_type(CharacterJoint::get_class_type())) {
00732 CharacterJoint *new_joint;
00733 DCAST_INTO_V(new_joint, new_group);
00734
00735
00736 new_joint->_character = this;
00737
00738 if (old_group != new_group &&
00739 old_group->is_of_type(CharacterJoint::get_class_type())) {
00740 CharacterJoint *old_joint;
00741 DCAST_INTO_V(old_joint, old_group);
00742
00743
00744
00745 old_joint->_character = NULL;
00746
00747
00748
00749 CharacterJoint::NodeList::iterator ni;
00750 for (ni = old_joint->_net_transform_nodes.begin();
00751 ni != old_joint->_net_transform_nodes.end();
00752 ++ni) {
00753 new_joint->_net_transform_nodes.insert(*ni);
00754 }
00755 for (ni = old_joint->_local_transform_nodes.begin();
00756 ni != old_joint->_local_transform_nodes.end();
00757 ++ni) {
00758 new_joint->_local_transform_nodes.insert(*ni);
00759 }
00760 }
00761 }
00762
00763 if (old_group == new_group) {
00764 return;
00765 }
00766
00767 int i = 0, j = 0;
00768 int old_num_children = old_group->get_num_children();
00769 int new_num_children = new_group->get_num_children();
00770
00771 PartGroup::Children new_children(PartGroup::get_class_type());
00772 new_children.reserve(max(old_num_children, new_num_children));
00773
00774 while (i < old_num_children && j < new_num_children) {
00775 PartGroup *pc = old_group->get_child(i);
00776 PartGroup *ac = new_group->get_child(j);
00777
00778 if (pc->get_name() < ac->get_name()) {
00779
00780
00781 PartGroup *new_pc = pc->make_copy();
00782 new_children.push_back(new_pc);
00783
00784 r_merge_bundles(joint_map, pc, new_pc);
00785 i++;
00786
00787 } else if (ac->get_name() < pc->get_name()) {
00788
00789
00790 new_children.push_back(ac);
00791
00792 r_merge_bundles(joint_map, ac, ac);
00793 j++;
00794
00795 } else {
00796
00797 new_children.push_back(ac);
00798
00799 r_merge_bundles(joint_map, pc, ac);
00800 i++;
00801 j++;
00802 }
00803 }
00804
00805 while (i < old_num_children) {
00806 PartGroup *pc = old_group->get_child(i);
00807
00808
00809
00810 PartGroup *new_pc = pc->make_copy();
00811 new_children.push_back(new_pc);
00812
00813 r_merge_bundles(joint_map, pc, new_pc);
00814 i++;
00815 }
00816
00817 while (j < new_num_children) {
00818 PartGroup *ac = new_group->get_child(j);
00819
00820
00821
00822 new_children.push_back(ac);
00823
00824 r_merge_bundles(joint_map, ac, ac);
00825 j++;
00826 }
00827
00828 new_group->_children.swap(new_children);
00829 }
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840 void Character::
00841 r_copy_char(PandaNode *dest, const PandaNode *source,
00842 const Character *from, Character::NodeMap &node_map,
00843 const Character::JointMap &joint_map,
00844 Character::GeomVertexMap &gvmap,
00845 Character::GeomJointMap &gjmap, Character::GeomSliderMap &gsmap) {
00846
00847 if (source->is_geom_node()) {
00848 const GeomNode *source_gnode;
00849 GeomNode *dest_gnode;
00850 DCAST_INTO_V(source_gnode, source);
00851 DCAST_INTO_V(dest_gnode, dest);
00852
00853 dest_gnode->remove_all_geoms();
00854 int num_geoms = source_gnode->get_num_geoms();
00855 for (int i = 0; i < num_geoms; i++) {
00856 const Geom *geom = source_gnode->get_geom(i);
00857 const RenderState *state = source_gnode->get_geom_state(i);
00858 dest_gnode->add_geom(copy_geom(geom, joint_map, gvmap, gjmap, gsmap), state);
00859 }
00860 }
00861
00862 int num_children = source->get_num_children();
00863 for (int i = 0; i < num_children; i++) {
00864 const PandaNode *source_child = source->get_child(i);
00865 int source_sort = source->get_child_sort(i);
00866
00867 PT(PandaNode) dest_child;
00868 if (source_child->is_of_type(Character::get_class_type())) {
00869
00870
00871
00872
00873 dest_child = source_child->copy_subgraph();
00874
00875 } else {
00876
00877
00878
00879
00880 dest_child = source_child->make_copy();
00881 r_copy_char(dest_child, source_child, from, node_map, joint_map,
00882 gvmap, gjmap, gsmap);
00883 }
00884 dest->add_child(dest_child, source_sort);
00885 node_map[source_child] = dest_child;
00886 }
00887 }
00888
00889
00890
00891
00892
00893
00894
00895
00896 void Character::
00897 r_update_geom(PandaNode *node, const Character::JointMap &joint_map,
00898 Character::GeomVertexMap &gvmap,
00899 Character::GeomJointMap &gjmap,
00900 Character::GeomSliderMap &gsmap) {
00901 if (node->is_geom_node()) {
00902 GeomNode *gnode;
00903 DCAST_INTO_V(gnode, node);
00904
00905 int num_geoms = gnode->get_num_geoms();
00906 for (int i = 0; i < num_geoms; i++) {
00907 CPT(Geom) geom = gnode->get_geom(i);
00908 PT(Geom) new_geom = copy_geom(geom, joint_map, gvmap, gjmap, gsmap);
00909 gnode->set_geom(i, new_geom);
00910 }
00911 }
00912
00913 int num_children = node->get_num_children();
00914 for (int i = 0; i < num_children; i++) {
00915 PandaNode *child = node->get_child(i);
00916
00917 r_update_geom(child, joint_map, gvmap, gjmap, gsmap);
00918 }
00919 }
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929 PT(Geom) Character::
00930 copy_geom(const Geom *source, const Character::JointMap &joint_map,
00931 Character::GeomVertexMap &gvmap, Character::GeomJointMap &gjmap,
00932 Character::GeomSliderMap &gsmap) {
00933 CPT(GeomVertexFormat) format = source->get_vertex_data()->get_format();
00934 if (format->get_animation().get_animation_type() == Geom::AT_none) {
00935
00936 return (Geom *)source;
00937 }
00938
00939 PT(Geom) dest = source->make_copy();
00940
00941 CPT(GeomVertexData) orig_vdata = source->get_vertex_data();
00942 PT(GeomVertexData) new_vdata;
00943 GeomVertexMap::iterator gvmi = gvmap.find(orig_vdata);
00944 if (gvmi != gvmap.end()) {
00945 new_vdata = (*gvmi).second;
00946 } else {
00947 new_vdata = new GeomVertexData(*orig_vdata);
00948
00949 new_vdata->set_transform_table(redirect_transform_table(orig_vdata->get_transform_table(), joint_map, gjmap));
00950 new_vdata->set_transform_blend_table(redirect_transform_blend_table(orig_vdata->get_transform_blend_table(), joint_map, gjmap));
00951 new_vdata->set_slider_table(redirect_slider_table(orig_vdata->get_slider_table(), gsmap));
00952
00953 gvmap.insert(GeomVertexMap::value_type(orig_vdata, new_vdata));
00954 }
00955
00956 dest->set_vertex_data(new_vdata);
00957
00958 return dest;
00959 }
00960
00961
00962
00963
00964
00965
00966
00967
00968 void Character::
00969 copy_node_pointers(const Character::NodeMap &node_map,
00970 PartGroup *dest, const PartGroup *source) {
00971 if (dest->is_of_type(CharacterJoint::get_class_type())) {
00972 nassertv(dest != source);
00973 const CharacterJoint *source_joint;
00974 CharacterJoint *dest_joint;
00975 DCAST_INTO_V(source_joint, source);
00976 DCAST_INTO_V(dest_joint, dest);
00977
00978 CharacterJoint::NodeList::const_iterator ai;
00979 for (ai = source_joint->_net_transform_nodes.begin();
00980 ai != source_joint->_net_transform_nodes.end();
00981 ++ai) {
00982 PandaNode *source_node = (*ai);
00983
00984 NodeMap::const_iterator mi;
00985 mi = node_map.find(source_node);
00986 if (mi != node_map.end()) {
00987 PandaNode *dest_node = (*mi).second;
00988
00989
00990
00991
00992 dest_joint->set_character(this);
00993 dest_joint->add_net_transform(dest_node);
00994 }
00995 }
00996
00997 for (ai = source_joint->_local_transform_nodes.begin();
00998 ai != source_joint->_local_transform_nodes.end();
00999 ++ai) {
01000 PandaNode *source_node = (*ai);
01001
01002 NodeMap::const_iterator mi;
01003 mi = node_map.find(source_node);
01004 if (mi != node_map.end()) {
01005 PandaNode *dest_node = (*mi).second;
01006
01007
01008
01009
01010 dest_joint->set_character(this);
01011 dest_joint->add_local_transform(dest_node);
01012 }
01013 }
01014 }
01015
01016
01017 int i = 0, j = 0;
01018 int dest_num_children = dest->get_num_children();
01019 int source_num_children = source->get_num_children();
01020
01021 while (i < dest_num_children && j < source_num_children) {
01022 PartGroup *pc = dest->get_child(i);
01023 PartGroup *ac = source->get_child(j);
01024
01025 if (pc->get_name() < ac->get_name()) {
01026 i++;
01027 } else if (ac->get_name() < pc->get_name()) {
01028 j++;
01029 } else {
01030 copy_node_pointers(node_map, pc, ac);
01031 i++;
01032 j++;
01033 }
01034 }
01035 }
01036
01037
01038
01039
01040
01041
01042
01043
01044 CPT(TransformTable) Character::
01045 redirect_transform_table(const TransformTable *source,
01046 const Character::JointMap &joint_map,
01047 Character::GeomJointMap &gjmap) {
01048 if (source == (TransformTable *)NULL) {
01049 return NULL;
01050 }
01051
01052 PT(TransformTable) dest = new TransformTable(*source);
01053
01054 int num_transforms = dest->get_num_transforms();
01055 for (int i = 0; i < num_transforms; ++i) {
01056 const VertexTransform *vt = dest->get_transform(i);
01057 PT(JointVertexTransform) new_jvt = redirect_joint(vt, joint_map, gjmap);
01058 if (new_jvt != (JointVertexTransform *)NULL) {
01059 dest->set_transform(i, new_jvt);
01060 }
01061 }
01062
01063 return TransformTable::register_table(dest);
01064 }
01065
01066
01067
01068
01069
01070
01071
01072
01073 CPT(TransformBlendTable) Character::
01074 redirect_transform_blend_table(const TransformBlendTable *source,
01075 const Character::JointMap &joint_map,
01076 Character::GeomJointMap &gjmap) {
01077 if (source == (TransformBlendTable *)NULL) {
01078 return NULL;
01079 }
01080
01081 PT(TransformBlendTable) dest = new TransformBlendTable(*source);
01082
01083 int num_blends = dest->get_num_blends();
01084 for (int i = 0; i < num_blends; ++i) {
01085 TransformBlend blend = dest->get_blend(i);
01086 int num_transforms = blend.get_num_transforms();
01087 for (int j = 0; j < num_transforms; ++j) {
01088 const VertexTransform *vt = blend.get_transform(j);
01089 PT(JointVertexTransform) new_jvt = redirect_joint(vt, joint_map, gjmap);
01090 if (new_jvt != (JointVertexTransform *)NULL) {
01091 blend.set_transform(j, new_jvt);
01092 }
01093 }
01094 dest->set_blend(i, blend);
01095 }
01096
01097 return dest;
01098 }
01099
01100
01101
01102
01103
01104
01105
01106
01107 CPT(SliderTable) Character::
01108 redirect_slider_table(const SliderTable *source,
01109 Character::GeomSliderMap &gsmap) {
01110 if (source == (SliderTable *)NULL) {
01111 return NULL;
01112 }
01113
01114 PT(SliderTable) dest = new SliderTable(*source);
01115
01116 int num_sliders = dest->get_num_sliders();
01117 for (int i = 0; i < num_sliders; ++i) {
01118 const VertexSlider *vs = dest->get_slider(i);
01119 PT(CharacterVertexSlider) new_cvs = redirect_slider(vs, gsmap);
01120 if (new_cvs != (CharacterVertexSlider *)NULL) {
01121 dest->set_slider(i, new_cvs);
01122 }
01123 }
01124
01125 return SliderTable::register_table(dest);
01126 }
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136 PT(JointVertexTransform) Character::
01137 redirect_joint(const VertexTransform *vt,
01138 const Character::JointMap &joint_map,
01139 Character::GeomJointMap &gjmap) {
01140 GeomJointMap::iterator ji;
01141 ji = gjmap.find(vt);
01142 if (ji != gjmap.end()) {
01143 return (*ji).second;
01144 }
01145
01146 PT(JointVertexTransform) new_jvt;
01147
01148 if (vt->is_of_type(JointVertexTransform::get_class_type())) {
01149 const JointVertexTransform *jvt = DCAST(JointVertexTransform, vt);
01150 const CharacterJoint *orig_joint = jvt->get_joint();
01151 JointMap::const_iterator jmi = joint_map.find(orig_joint);
01152 if (jmi == joint_map.end()) {
01153 char_cat.error()
01154 << "Could not find joint " << *orig_joint
01155 << " within the character hierarchy.\n";
01156
01157 } else {
01158 CharacterJoint *joint = DCAST(CharacterJoint, (*jmi).second);
01159 new_jvt = new JointVertexTransform(joint);
01160 }
01161 }
01162
01163 gjmap[vt] = new_jvt;
01164 return new_jvt;
01165 }
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175 PT(CharacterVertexSlider) Character::
01176 redirect_slider(const VertexSlider *vs, Character::GeomSliderMap &gsmap) {
01177 GeomSliderMap::iterator ji;
01178 ji = gsmap.find(vs);
01179 if (ji != gsmap.end()) {
01180 return (*ji).second;
01181 }
01182
01183 PT(CharacterVertexSlider) new_cvs;
01184
01185 if (vs->is_of_type(CharacterVertexSlider::get_class_type())) {
01186 const CharacterVertexSlider *cvs = DCAST(CharacterVertexSlider, vs);
01187 CharacterSlider *slider = find_slider(cvs->get_char_slider()->get_name());
01188 if (slider != (CharacterSlider *)NULL) {
01189 new_cvs = new CharacterVertexSlider(slider);
01190 }
01191 }
01192
01193 gsmap[vs] = new_cvs;
01194 return new_cvs;
01195 }
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205 void Character::
01206 r_clear_joint_characters(PartGroup *part) {
01207 if (part->is_of_type(CharacterJoint::get_class_type())) {
01208 CharacterJoint *joint = DCAST(CharacterJoint, part);
01209
01210
01211
01212
01213
01214 if (joint->get_character() == this) {
01215 joint->set_character(NULL);
01216 }
01217 }
01218
01219 int num_children = part->get_num_children();
01220 for (int i = 0; i < num_children; ++i) {
01221 PartGroup *child = part->get_child(i);
01222 r_clear_joint_characters(child);
01223 }
01224 }
01225
01226
01227
01228
01229
01230
01231
01232 void Character::
01233 register_with_read_factory() {
01234 BamReader::get_factory()->register_factory(get_class_type(), make_from_bam);
01235 }
01236
01237
01238
01239
01240
01241
01242
01243 void Character::
01244 write_datagram(BamWriter *manager, Datagram &dg) {
01245 PartBundleNode::write_datagram(manager, dg);
01246
01247
01248 dg.add_uint16(0);
01249 }
01250
01251
01252
01253
01254
01255
01256
01257
01258 int Character::
01259 complete_pointers(TypedWritable **p_list, BamReader *manager) {
01260
01261
01262 return PartBundleNode::complete_pointers(p_list, manager) + _temp_num_parts;
01263 }
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273 TypedWritable *Character::
01274 make_from_bam(const FactoryParams ¶ms) {
01275 Character *node = new Character("");
01276 DatagramIterator scan;
01277 BamReader *manager;
01278
01279 parse_params(params, scan, manager);
01280 node->fillin(scan, manager);
01281
01282 return node;
01283 }
01284
01285
01286
01287
01288
01289
01290
01291
01292 void Character::
01293 fillin(DatagramIterator &scan, BamReader *manager) {
01294 PartBundleNode::fillin(scan, manager);
01295
01296
01297
01298
01299 _temp_num_parts = scan.get_uint16();
01300 for (unsigned int i = 0; i < _temp_num_parts; i++) {
01301 manager->read_pointer(scan);
01302 }
01303
01304 #ifdef DO_PSTATS
01305
01306 if (has_name()) {
01307 _joints_pcollector =
01308 PStatCollector(PStatCollector(_animation_pcollector, get_name()), "Joints");
01309 _skinning_pcollector =
01310 PStatCollector(PStatCollector(_animation_pcollector, get_name()), "Vertices");
01311 }
01312 #endif
01313 }