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