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