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