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