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