source/blender/collada/ArmatureImporter.cpp

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