Merge with trunk r37677
[blender.git] / source / blender / collada / ArmatureImporter.cpp
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Chingiz Dyussenov, Arystanbek Dyussenov, Nathan Letwory.
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/collada/ArmatureImporter.cpp
26  *  \ingroup collada
27  */
28
29
30 /* COLLADABU_ASSERT, may be able to remove later */
31 #include "COLLADABUPlatform.h"
32
33 #include <algorithm>
34
35 #include "COLLADAFWUniqueId.h"
36
37 #include "BKE_action.h"
38 #include "BKE_depsgraph.h"
39 #include "BKE_object.h"
40 #include "BLI_string.h"
41 #include "ED_armature.h"
42
43 #include "ArmatureImporter.h"
44
45 // use node name, or fall back to original id if not present (name is optional)
46 template<class T>
47 static const char *bc_get_joint_name(T *node)
48 {
49         const std::string& id = node->getName();
50         return id.size() ? id.c_str() : node->getOriginalId().c_str();
51 }
52
53 ArmatureImporter::ArmatureImporter(UnitConverter *conv, MeshImporterBase *mesh, AnimationImporterBase *anim, Scene *sce) :
54         TransformReader(conv), scene(sce), empty(NULL), mesh_importer(mesh), anim_importer(anim) {}
55
56 ArmatureImporter::~ArmatureImporter()
57 {
58         // free skin controller data if we forget to do this earlier
59         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
60         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
61                 it->second.free();
62         }
63 }
64
65 #if 0
66 JointData *ArmatureImporter::get_joint_data(COLLADAFW::Node *node);
67 {
68         const COLLADAFW::UniqueId& joint_id = node->getUniqueId();
69
70         if (joint_id_to_joint_index_map.find(joint_id) == joint_id_to_joint_index_map.end()) {
71                 fprintf(stderr, "Cannot find a joint index by joint id for %s.\n",
72                                 node->getOriginalId().c_str());
73                 return NULL;
74         }
75
76         int joint_index = joint_id_to_joint_index_map[joint_id];
77
78         return &joint_index_to_joint_info_map[joint_index];
79 }
80 #endif
81 void ArmatureImporter::create_unskinned_bone( COLLADAFW::Node *node, EditBone *parent, int totchild,
82                                  float parent_mat[][4], bArmature *arm)
83 {
84         float mat[4][4];
85    float obmat[4][4];
86
87         // object-space
88         get_node_mat(obmat, node, NULL, NULL);
89
90         // get world-space
91         if (parent)
92                 mul_m4_m4m4(mat, obmat, parent_mat);
93         else
94                 copy_m4_m4(mat, obmat);
95
96         EditBone *bone = ED_armature_edit_bone_add(arm, (char*)bc_get_joint_name(node));
97         totbone++;
98
99         if (parent) bone->parent = parent;
100
101         // set head
102         copy_v3_v3(bone->head, mat[3]);
103
104         // set tail, don't set it to head because 0-length bones are not allowed
105         float vec[3] = {0.0f, 0.5f, 0.0f};
106         add_v3_v3v3(bone->tail, bone->head, vec);
107
108         // set parent tail
109         if (parent && totchild == 1) {
110                 copy_v3_v3(parent->tail, bone->head);
111
112                 // not setting BONE_CONNECTED because this would lock child bone location with respect to parent
113                 // bone->flag |= BONE_CONNECTED;
114
115                 // XXX increase this to prevent "very" small bones?
116                 const float epsilon = 0.000001f;
117
118                 // derive leaf bone length
119                 float length = len_v3v3(parent->head, parent->tail);
120                 if ((length < leaf_bone_length || totbone == 0) && length > epsilon) {
121                         leaf_bone_length = length;
122                 }
123
124                 // treat zero-sized bone like a leaf bone
125                 if (length <= epsilon) {
126                         add_leaf_bone(parent_mat, parent);
127                 }
128
129         }
130
131         COLLADAFW::NodePointerArray& children = node->getChildNodes();
132         for (unsigned int i = 0; i < children.getCount(); i++) {
133                 create_unskinned_bone( children[i], bone, children.getCount(), mat, arm);
134         }
135
136         // in second case it's not a leaf bone, but we handle it the same way
137         if (!children.getCount() || children.getCount() > 1) {
138                 add_leaf_bone(mat, bone);
139         }
140
141 }
142
143 void ArmatureImporter::create_bone(SkinInfo& skin, COLLADAFW::Node *node, EditBone *parent, int totchild,
144                                  float parent_mat[][4], bArmature *arm)
145 {
146         float joint_inv_bind_mat[4][4];
147
148         // JointData* jd = get_joint_data(node);
149
150         float mat[4][4];
151
152         if (skin.get_joint_inv_bind_matrix(joint_inv_bind_mat, node)) {
153                 // get original world-space matrix
154                 invert_m4_m4(mat, joint_inv_bind_mat);
155         }
156         // create a bone even if there's no joint data for it (i.e. it has no influence)
157         else {
158                 float obmat[4][4];
159
160                 // object-space
161                 get_node_mat(obmat, node, NULL, NULL);
162
163                 // get world-space
164                 if (parent)
165                         mul_m4_m4m4(mat, obmat, parent_mat);
166                 else
167                         copy_m4_m4(mat, obmat);
168         }
169
170         // TODO rename from Node "name" attrs later
171         EditBone *bone = ED_armature_edit_bone_add(arm, (char*)bc_get_joint_name(node));
172         totbone++;
173
174         if (parent) bone->parent = parent;
175
176         // set head
177         copy_v3_v3(bone->head, mat[3]);
178
179         // set tail, don't set it to head because 0-length bones are not allowed
180         float vec[3] = {0.0f, 0.5f, 0.0f};
181         add_v3_v3v3(bone->tail, bone->head, vec);
182
183         // set parent tail
184         if (parent && totchild == 1) {
185                 copy_v3_v3(parent->tail, bone->head);
186
187                 // not setting BONE_CONNECTED because this would lock child bone location with respect to parent
188                 // bone->flag |= BONE_CONNECTED;
189
190                 // XXX increase this to prevent "very" small bones?
191                 const float epsilon = 0.000001f;
192
193                 // derive leaf bone length
194                 float length = len_v3v3(parent->head, parent->tail);
195                 if ((length < leaf_bone_length || totbone == 0) && length > epsilon) {
196                         leaf_bone_length = length;
197                 }
198
199                 // treat zero-sized bone like a leaf bone
200                 if (length <= epsilon) {
201                         add_leaf_bone(parent_mat, parent);
202                 }
203
204                 /*
205 #if 0
206                 // and which row in mat is bone direction
207                 float vec[3];
208                 sub_v3_v3v3(vec, parent->tail, parent->head);
209 #ifdef COLLADA_DEBUG
210                 print_v3("tail - head", vec);
211                 print_m4("matrix", parent_mat);
212 #endif
213                 for (int i = 0; i < 3; i++) {
214 #ifdef COLLADA_DEBUG
215                         char *axis_names[] = {"X", "Y", "Z"};
216                         printf("%s-axis length is %f\n", axis_names[i], len_v3(parent_mat[i]));
217 #endif
218                         float angle = angle_v2v2(vec, parent_mat[i]);
219                         if (angle < min_angle) {
220 #ifdef COLLADA_DEBUG
221                                 print_v3("picking", parent_mat[i]);
222                                 printf("^ %s axis of %s's matrix\n", axis_names[i], get_dae_name(node));
223 #endif
224                                 bone_direction_row = i;
225                                 min_angle = angle;
226                         }
227                 }
228 #endif
229                 */
230         }
231
232         COLLADAFW::NodePointerArray& children = node->getChildNodes();
233         for (unsigned int i = 0; i < children.getCount(); i++) {
234                 create_bone(skin, children[i], bone, children.getCount(), mat, arm);
235         }
236
237         // in second case it's not a leaf bone, but we handle it the same way
238         if (!children.getCount() || children.getCount() > 1) {
239                 add_leaf_bone(mat, bone);
240         }
241 }
242
243 void ArmatureImporter::add_leaf_bone(float mat[][4], EditBone *bone)
244 {
245         LeafBone leaf;
246
247         leaf.bone = bone;
248         copy_m4_m4(leaf.mat, mat);
249         BLI_strncpy(leaf.name, bone->name, sizeof(leaf.name));
250
251         leaf_bones.push_back(leaf);
252 }
253
254 void ArmatureImporter::fix_leaf_bones()
255 {
256         // just setting tail for leaf bones here
257
258         std::vector<LeafBone>::iterator it;
259         for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
260                 LeafBone& leaf = *it;
261
262                 // pointing up
263                 float vec[3] = {0.0f, 0.0f, 1.0f};
264
265                 mul_v3_fl(vec, leaf_bone_length);
266
267                 copy_v3_v3(leaf.bone->tail, leaf.bone->head);
268                 add_v3_v3v3(leaf.bone->tail, leaf.bone->head, vec);
269         }
270 }
271
272 #if 0
273 void ArmatureImporter::set_leaf_bone_shapes(Object *ob_arm)
274 {
275         bPose *pose = ob_arm->pose;
276
277         std::vector<LeafBone>::iterator it;
278         for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
279                 LeafBone& leaf = *it;
280
281                 bPoseChannel *pchan = get_pose_channel(pose, leaf.name);
282                 if (pchan) {
283                         pchan->custom = get_empty_for_leaves();
284                 }
285                 else {
286                         fprintf(stderr, "Cannot find a pose channel for leaf bone %s\n", leaf.name);
287                 }
288         }
289 }
290
291 void ArmatureImporter::set_euler_rotmode()
292 {
293         // just set rotmode = ROT_MODE_EUL on pose channel for each joint
294
295         std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>::iterator it;
296
297         for (it = joint_by_uid.begin(); it != joint_by_uid.end(); it++) {
298
299                 COLLADAFW::Node *joint = it->second;
300
301                 std::map<COLLADAFW::UniqueId, SkinInfo>::iterator sit;
302                 
303                 for (sit = skin_by_data_uid.begin(); sit != skin_by_data_uid.end(); sit++) {
304                         SkinInfo& skin = sit->second;
305
306                         if (skin.uses_joint_or_descendant(joint)) {
307                                 bPoseChannel *pchan = skin.get_pose_channel_from_node(joint);
308
309                                 if (pchan) {
310                                         pchan->rotmode = ROT_MODE_EUL;
311                                 }
312                                 else {
313                                         fprintf(stderr, "Cannot find pose channel for %s.\n", get_joint_name(joint));
314                                 }
315
316                                 break;
317                         }
318                 }
319         }
320 }
321 #endif
322
323 Object *ArmatureImporter::get_empty_for_leaves()
324 {
325         if (empty) return empty;
326         
327         empty = add_object(scene, OB_EMPTY);
328         empty->empty_drawtype = OB_EMPTY_SPHERE;
329
330         return empty;
331 }
332
333 #if 0
334 Object *ArmatureImporter::find_armature(COLLADAFW::Node *node)
335 {
336         JointData* jd = get_joint_data(node);
337         if (jd) return jd->ob_arm;
338
339         COLLADAFW::NodePointerArray& children = node->getChildNodes();
340         for (int i = 0; i < children.getCount(); i++) {
341                 Object *ob_arm = find_armature(children[i]);
342                 if (ob_arm) return ob_arm;
343         }
344
345         return NULL;
346 }
347
348 ArmatureJoints& ArmatureImporter::get_armature_joints(Object *ob_arm)
349 {
350         // try finding it
351         std::vector<ArmatureJoints>::iterator it;
352         for (it = armature_joints.begin(); it != armature_joints.end(); it++) {
353                 if ((*it).ob_arm == ob_arm) return *it;
354         }
355
356         // not found, create one
357         ArmatureJoints aj;
358         aj.ob_arm = ob_arm;
359         armature_joints.push_back(aj);
360
361         return armature_joints.back();
362 }
363 #endif
364 void ArmatureImporter::create_armature_bones( )
365 {
366         std::vector<COLLADAFW::Node*>::iterator ri;
367         //if there is an armature created for root_joint next root_joint
368         for (ri = root_joints.begin(); ri != root_joints.end(); ri++) {
369                         if ( get_armature_for_joint(*ri) != NULL ) continue;
370             
371         //add armature object for current joint
372                 //Object *ob_arm = add_object(scene, OB_ARMATURE);
373
374                 Object *ob_arm = joint_parent_map[(*ri)->getUniqueId()];
375                 //ob_arm->type = OB_ARMATURE;
376                 ED_armature_to_edit(ob_arm);
377
378                 // min_angle = 360.0f;          // minimum angle between bone head-tail and a row of bone matrix
379
380                 // create unskinned bones
381                 /*
382                    TODO:
383                    check if bones have already been created for a given joint
384                 */
385      leaf_bone_length = FLT_MAX;
386                 create_unskinned_bone(*ri, NULL, (*ri)->getChildNodes().getCount(), NULL, (bArmature*)ob_arm->data);
387
388                 fix_leaf_bones();
389
390         // exit armature edit mode
391         
392
393         //if (joint_parent_map.find((*ri)->getUniqueId()) != joint_parent_map.end() && ob_arm->parent!=NULL)
394         //      ob_arm->parent = joint_parent_map[(*ri)->getUniqueId()];
395         
396         unskinned_armature_map[(*ri)->getUniqueId()] = ob_arm;
397
398         ED_armature_from_edit(ob_arm);
399         ED_armature_edit_free(ob_arm);
400         DAG_id_tag_update(&ob_arm->id, OB_RECALC_OB|OB_RECALC_DATA);
401         }
402
403         
404 }
405
406 void ArmatureImporter::create_armature_bones(SkinInfo& skin)
407 {
408         // just do like so:
409         // - get armature
410         // - enter editmode
411         // - add edit bones and head/tail properties using matrices and parent-child info
412         // - exit edit mode
413         // - set a sphere shape to leaf bones
414
415         Object *ob_arm = NULL;
416
417         /*
418          * find if there's another skin sharing at least one bone with this skin
419          * if so, use that skin's armature
420          */
421
422         /*
423           Pseudocode:
424
425           find_node_in_tree(node, root_joint)
426
427           skin::find_root_joints(root_joints):
428                 std::vector root_joints;
429                 for each root in root_joints:
430                         for each joint in joints:
431                                 if find_node_in_tree(joint, root):
432                                         if (std::find(root_joints.begin(), root_joints.end(), root) == root_joints.end())
433                                                 root_joints.push_back(root);
434
435           for (each skin B with armature) {
436                   find all root joints for skin B
437
438                   for each joint X in skin A:
439                         for each root joint R in skin B:
440                                 if (find_node_in_tree(X, R)) {
441                                         shared = 1;
442                                         goto endloop;
443                                 }
444           }
445
446           endloop:
447         */
448
449         SkinInfo *a = &skin;
450         Object *shared = NULL;
451         std::vector<COLLADAFW::Node*> skin_root_joints;
452
453         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
454         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
455                 SkinInfo *b = &it->second;
456                 if (b == a || b->get_armature() == NULL)
457                         continue;
458
459                 skin_root_joints.clear();
460
461                 b->find_root_joints(root_joints, joint_by_uid, skin_root_joints);
462
463                 std::vector<COLLADAFW::Node*>::iterator ri;
464                 for (ri = skin_root_joints.begin(); ri != skin_root_joints.end(); ri++) {
465                         if (a->uses_joint_or_descendant(*ri)) {
466                                 shared = b->get_armature();
467                                 break;
468                         }
469                 }
470
471                 if (shared != NULL)
472                         break;
473         }
474
475         if (shared)
476                 ob_arm = skin.set_armature(shared);
477         else
478                 ob_arm = skin.create_armature(scene); //once for every armature
479
480         // enter armature edit mode
481         ED_armature_to_edit(ob_arm);
482
483         leaf_bones.clear();
484         totbone = 0;
485         // bone_direction_row = 1; // TODO: don't default to Y but use asset and based on it decide on default row
486         leaf_bone_length = FLT_MAX;
487         // min_angle = 360.0f;          // minimum angle between bone head-tail and a row of bone matrix
488
489         // create bones
490         /*
491            TODO:
492            check if bones have already been created for a given joint
493         */
494
495         std::vector<COLLADAFW::Node*>::iterator ri;
496         for (ri = root_joints.begin(); ri != root_joints.end(); ri++) {
497                 // for shared armature check if bone tree is already created
498                 if (shared && std::find(skin_root_joints.begin(), skin_root_joints.end(), *ri) != skin_root_joints.end())
499                         continue;
500
501                 // since root_joints may contain joints for multiple controllers, we need to filter
502                 if (skin.uses_joint_or_descendant(*ri)) {
503                         create_bone(skin, *ri, NULL, (*ri)->getChildNodes().getCount(), NULL, (bArmature*)ob_arm->data);
504
505                         if (joint_parent_map.find((*ri)->getUniqueId()) != joint_parent_map.end() && !skin.get_parent())
506                                 skin.set_parent(joint_parent_map[(*ri)->getUniqueId()]);
507                 }
508         }
509
510         fix_leaf_bones();
511
512         // exit armature edit mode
513         ED_armature_from_edit(ob_arm);
514         ED_armature_edit_free(ob_arm);
515         DAG_id_tag_update(&ob_arm->id, OB_RECALC_OB|OB_RECALC_DATA);
516
517         // set_leaf_bone_shapes(ob_arm);
518     // set_euler_rotmode();
519 }
520
521
522 // root - if this joint is the top joint in hierarchy, if a joint
523 // is a child of a node (not joint), root should be true since
524 // this is where we build armature bones from
525
526 void ArmatureImporter::add_joint(COLLADAFW::Node *node, bool root, Object *parent, Scene *sce)
527 {
528         joint_by_uid[node->getUniqueId()] = node;
529         if (root) {
530                 root_joints.push_back(node);
531
532                 if (parent) {
533                                         
534                         joint_parent_map[node->getUniqueId()] = parent;
535                 }
536         }
537 }
538
539 #if 0
540 void ArmatureImporter::add_root_joint(COLLADAFW::Node *node)
541 {
542         // root_joints.push_back(node);
543         Object *ob_arm = find_armature(node);
544         if (ob_arm)     {
545                 get_armature_joints(ob_arm).root_joints.push_back(node);
546         }
547 #ifdef COLLADA_DEBUG
548         else {
549                 fprintf(stderr, "%s cannot be added to armature.\n", get_joint_name(node));
550         }
551 #endif
552 }
553 #endif
554
555 // here we add bones to armatures, having armatures previously created in write_controller
556 void ArmatureImporter::make_armatures(bContext *C)
557 {
558         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
559         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
560
561                 SkinInfo& skin = it->second;
562
563                 create_armature_bones(skin);
564
565                 // link armature with a mesh object
566                 Object *ob = mesh_importer->get_object_by_geom_uid(*get_geometry_uid(skin.get_controller_uid()));
567                 if (ob)
568                         skin.link_armature(C, ob, joint_by_uid, this);
569                 else
570                         fprintf(stderr, "Cannot find object to link armature with.\n");
571
572                 // set armature parent if any
573                 Object *par = skin.get_parent();
574                 if (par)
575                         bc_set_parent(skin.get_armature(), par, C, false);
576
577                 // free memory stolen from SkinControllerData
578                 skin.free();
579         }
580
581         create_armature_bones();
582
583 }
584
585 #if 0
586 // link with meshes, create vertex groups, assign weights
587 void ArmatureImporter::link_armature(Object *ob_arm, const COLLADAFW::UniqueId& geom_id, const COLLADAFW::UniqueId& controller_data_id)
588 {
589         Object *ob = mesh_importer->get_object_by_geom_uid(geom_id);
590
591         if (!ob) {
592                 fprintf(stderr, "Cannot find object by geometry UID.\n");
593                 return;
594         }
595
596         if (skin_by_data_uid.find(controller_data_id) == skin_by_data_uid.end()) {
597                 fprintf(stderr, "Cannot find skin info by controller data UID.\n");
598                 return;
599         }
600
601         SkinInfo& skin = skin_by_data_uid[conroller_data_id];
602
603         // create vertex groups
604 }
605 #endif
606
607 bool ArmatureImporter::write_skin_controller_data(const COLLADAFW::SkinControllerData* data)
608 {
609         // at this stage we get vertex influence info that should go into me->verts and ob->defbase
610         // there's no info to which object this should be long so we associate it with skin controller data UID
611
612         // don't forget to call defgroup_unique_name before we copy
613
614         // controller data uid -> [armature] -> joint data, 
615         // [mesh object]
616         // 
617
618         SkinInfo skin(unit_converter);
619         skin.borrow_skin_controller_data(data);
620
621         // store join inv bind matrix to use it later in armature construction
622         const COLLADAFW::Matrix4Array& inv_bind_mats = data->getInverseBindMatrices();
623         for (unsigned int i = 0; i < data->getJointsCount(); i++) {
624                 skin.add_joint(inv_bind_mats[i]);
625         }
626
627         skin_by_data_uid[data->getUniqueId()] = skin;
628
629         return true;
630 }
631
632 bool ArmatureImporter::write_controller(const COLLADAFW::Controller* controller)
633 {
634         // - create and store armature object
635
636         const COLLADAFW::UniqueId& skin_id = controller->getUniqueId();
637
638         if (controller->getControllerType() == COLLADAFW::Controller::CONTROLLER_TYPE_SKIN) {
639                 COLLADAFW::SkinController *co = (COLLADAFW::SkinController*)controller;
640                 // to be able to find geom id by controller id
641                 geom_uid_by_controller_uid[skin_id] = co->getSource();
642
643                 const COLLADAFW::UniqueId& data_uid = co->getSkinControllerData();
644                 if (skin_by_data_uid.find(data_uid) == skin_by_data_uid.end()) {
645                         fprintf(stderr, "Cannot find skin by controller data UID.\n");
646                         return true;
647                 }
648
649                 skin_by_data_uid[data_uid].set_controller(co);
650         }
651         // morph controller
652         else {
653                 // shape keys? :)
654                 fprintf(stderr, "Morph controller is not supported yet.\n");
655         }
656
657         return true;
658 }
659
660 COLLADAFW::UniqueId *ArmatureImporter::get_geometry_uid(const COLLADAFW::UniqueId& controller_uid)
661 {
662         if (geom_uid_by_controller_uid.find(controller_uid) == geom_uid_by_controller_uid.end())
663                 return NULL;
664
665         return &geom_uid_by_controller_uid[controller_uid];
666 }
667
668 Object *ArmatureImporter::get_armature_for_joint(COLLADAFW::Node *node)
669 {
670         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
671         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
672                 SkinInfo& skin = it->second;
673
674                 if (skin.uses_joint_or_descendant(node))
675                         return skin.get_armature();
676         }
677    
678          std::map<COLLADAFW::UniqueId, Object*>::iterator arm;
679         for (arm = unskinned_armature_map.begin(); arm != unskinned_armature_map.end(); arm++) {
680                 if(arm->first == node->getUniqueId() )
681                         return arm->second;
682         }
683         return NULL;
684 }
685
686 void ArmatureImporter::get_rna_path_for_joint(COLLADAFW::Node *node, char *joint_path, size_t count)
687 {
688         BLI_snprintf(joint_path, count, "pose.bones[\"%s\"]", bc_get_joint_name(node));
689 }
690
691 // gives a world-space mat
692 bool ArmatureImporter::get_joint_bind_mat(float m[][4], COLLADAFW::Node *joint)
693 {
694         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
695         bool found = false;
696         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
697                 SkinInfo& skin = it->second;
698                 if ((found = skin.get_joint_inv_bind_matrix(m, joint))) {
699                         invert_m4(m);
700                         break;
701                 }
702         }
703
704         return found;
705 }