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