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