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