8987e4ffaf7b5c55f2cf349a6cbad496d3b7cd1e
[blender-staging.git] / 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.
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 "BLI_string.h"
41 #include "ED_armature.h"
42
43 #include "ArmatureImporter.h"
44
45 // use this for retrieving bone names, since these must be unique
46 template<class T>
47 static const char *bc_get_joint_name(T *node)
48 {
49         const std::string& id = node->getOriginalId();
50         return id.size() ? id.c_str() : node->getName().c_str();
51 }
52
53 ArmatureImporter::ArmatureImporter(UnitConverter *conv, MeshImporterBase *mesh, AnimationImporterBase *anim, Scene *sce) :
54         TransformReader(conv), scene(sce), empty(NULL), mesh_importer(mesh), anim_importer(anim) {}
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], bArmature *arm)
84 {
85         float joint_inv_bind_mat[4][4];
86
87         // JointData* jd = get_joint_data(node);
88
89         float mat[4][4];
90
91         if (skin.get_joint_inv_bind_matrix(joint_inv_bind_mat, node)) {
92                 // get original world-space matrix
93                 invert_m4_m4(mat, joint_inv_bind_mat);
94         }
95         // create a bone even if there's no joint data for it (i.e. it has no influence)
96         else {
97                 float obmat[4][4];
98
99                 // object-space
100                 get_node_mat(obmat, node, NULL, NULL);
101
102                 // get world-space
103                 if (parent)
104                         mul_m4_m4m4(mat, obmat, parent_mat);
105                 else
106                         copy_m4_m4(mat, obmat);
107         }
108
109         // TODO rename from Node "name" attrs later
110         EditBone *bone = ED_armature_edit_bone_add(arm, (char*)bc_get_joint_name(node));
111         totbone++;
112
113         if (parent) bone->parent = parent;
114
115         // set head
116         copy_v3_v3(bone->head, mat[3]);
117
118         // set tail, don't set it to head because 0-length bones are not allowed
119         float vec[3] = {0.0f, 0.5f, 0.0f};
120         add_v3_v3v3(bone->tail, bone->head, vec);
121
122         // set parent tail
123         if (parent && totchild == 1) {
124                 copy_v3_v3(parent->tail, bone->head);
125
126                 // not setting BONE_CONNECTED because this would lock child bone location with respect to parent
127                 // bone->flag |= BONE_CONNECTED;
128
129                 // XXX increase this to prevent "very" small bones?
130                 const float epsilon = 0.000001f;
131
132                 // derive leaf bone length
133                 float length = len_v3v3(parent->head, parent->tail);
134                 if ((length < leaf_bone_length || totbone == 0) && length > epsilon) {
135                         leaf_bone_length = length;
136                 }
137
138                 // treat zero-sized bone like a leaf bone
139                 if (length <= epsilon) {
140                         add_leaf_bone(parent_mat, parent);
141                 }
142
143                 /*
144 #if 0
145                 // and which row in mat is bone direction
146                 float vec[3];
147                 sub_v3_v3v3(vec, parent->tail, parent->head);
148 #ifdef COLLADA_DEBUG
149                 print_v3("tail - head", vec);
150                 print_m4("matrix", parent_mat);
151 #endif
152                 for (int i = 0; i < 3; i++) {
153 #ifdef COLLADA_DEBUG
154                         char *axis_names[] = {"X", "Y", "Z"};
155                         printf("%s-axis length is %f\n", axis_names[i], len_v3(parent_mat[i]));
156 #endif
157                         float angle = angle_v2v2(vec, parent_mat[i]);
158                         if (angle < min_angle) {
159 #ifdef COLLADA_DEBUG
160                                 print_v3("picking", parent_mat[i]);
161                                 printf("^ %s axis of %s's matrix\n", axis_names[i], get_dae_name(node));
162 #endif
163                                 bone_direction_row = i;
164                                 min_angle = angle;
165                         }
166                 }
167 #endif
168                 */
169         }
170
171         COLLADAFW::NodePointerArray& children = node->getChildNodes();
172         for (unsigned int i = 0; i < children.getCount(); i++) {
173                 create_bone(skin, children[i], bone, children.getCount(), mat, arm);
174         }
175
176         // in second case it's not a leaf bone, but we handle it the same way
177         if (!children.getCount() || children.getCount() > 1) {
178                 add_leaf_bone(mat, bone);
179         }
180 }
181
182 void ArmatureImporter::add_leaf_bone(float mat[][4], EditBone *bone)
183 {
184         LeafBone leaf;
185
186         leaf.bone = bone;
187         copy_m4_m4(leaf.mat, mat);
188         BLI_strncpy(leaf.name, bone->name, sizeof(leaf.name));
189
190         leaf_bones.push_back(leaf);
191 }
192
193 void ArmatureImporter::fix_leaf_bones()
194 {
195         // just setting tail for leaf bones here
196
197         std::vector<LeafBone>::iterator it;
198         for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
199                 LeafBone& leaf = *it;
200
201                 // pointing up
202                 float vec[3] = {0.0f, 0.0f, 1.0f};
203
204                 mul_v3_fl(vec, leaf_bone_length);
205
206                 copy_v3_v3(leaf.bone->tail, leaf.bone->head);
207                 add_v3_v3v3(leaf.bone->tail, leaf.bone->head, vec);
208         }
209 }
210
211 #if 0
212 void ArmatureImporter::set_leaf_bone_shapes(Object *ob_arm)
213 {
214         bPose *pose = ob_arm->pose;
215
216         std::vector<LeafBone>::iterator it;
217         for (it = leaf_bones.begin(); it != leaf_bones.end(); it++) {
218                 LeafBone& leaf = *it;
219
220                 bPoseChannel *pchan = get_pose_channel(pose, leaf.name);
221                 if (pchan) {
222                         pchan->custom = get_empty_for_leaves();
223                 }
224                 else {
225                         fprintf(stderr, "Cannot find a pose channel for leaf bone %s\n", leaf.name);
226                 }
227         }
228 }
229
230 void ArmatureImporter::set_euler_rotmode()
231 {
232         // just set rotmode = ROT_MODE_EUL on pose channel for each joint
233
234         std::map<COLLADAFW::UniqueId, COLLADAFW::Node*>::iterator it;
235
236         for (it = joint_by_uid.begin(); it != joint_by_uid.end(); it++) {
237
238                 COLLADAFW::Node *joint = it->second;
239
240                 std::map<COLLADAFW::UniqueId, SkinInfo>::iterator sit;
241                 
242                 for (sit = skin_by_data_uid.begin(); sit != skin_by_data_uid.end(); sit++) {
243                         SkinInfo& skin = sit->second;
244
245                         if (skin.uses_joint_or_descendant(joint)) {
246                                 bPoseChannel *pchan = skin.get_pose_channel_from_node(joint);
247
248                                 if (pchan) {
249                                         pchan->rotmode = ROT_MODE_EUL;
250                                 }
251                                 else {
252                                         fprintf(stderr, "Cannot find pose channel for %s.\n", get_joint_name(joint));
253                                 }
254
255                                 break;
256                         }
257                 }
258         }
259 }
260 #endif
261
262 Object *ArmatureImporter::get_empty_for_leaves()
263 {
264         if (empty) return empty;
265         
266         empty = add_object(scene, OB_EMPTY);
267         empty->empty_drawtype = OB_EMPTY_SPHERE;
268
269         return empty;
270 }
271
272 #if 0
273 Object *ArmatureImporter::find_armature(COLLADAFW::Node *node)
274 {
275         JointData* jd = get_joint_data(node);
276         if (jd) return jd->ob_arm;
277
278         COLLADAFW::NodePointerArray& children = node->getChildNodes();
279         for (int i = 0; i < children.getCount(); i++) {
280                 Object *ob_arm = find_armature(children[i]);
281                 if (ob_arm) return ob_arm;
282         }
283
284         return NULL;
285 }
286
287 ArmatureJoints& ArmatureImporter::get_armature_joints(Object *ob_arm)
288 {
289         // try finding it
290         std::vector<ArmatureJoints>::iterator it;
291         for (it = armature_joints.begin(); it != armature_joints.end(); it++) {
292                 if ((*it).ob_arm == ob_arm) return *it;
293         }
294
295         // not found, create one
296         ArmatureJoints aj;
297         aj.ob_arm = ob_arm;
298         armature_joints.push_back(aj);
299
300         return armature_joints.back();
301 }
302 #endif
303
304 void ArmatureImporter::create_armature_bones(SkinInfo& skin)
305 {
306         // just do like so:
307         // - get armature
308         // - enter editmode
309         // - add edit bones and head/tail properties using matrices and parent-child info
310         // - exit edit mode
311         // - set a sphere shape to leaf bones
312
313         Object *ob_arm = NULL;
314
315         /*
316          * find if there's another skin sharing at least one bone with this skin
317          * if so, use that skin's armature
318          */
319
320         /*
321           Pseudocode:
322
323           find_node_in_tree(node, root_joint)
324
325           skin::find_root_joints(root_joints):
326                 std::vector root_joints;
327                 for each root in root_joints:
328                         for each joint in joints:
329                                 if find_node_in_tree(joint, root):
330                                         if (std::find(root_joints.begin(), root_joints.end(), root) == root_joints.end())
331                                                 root_joints.push_back(root);
332
333           for (each skin B with armature) {
334                   find all root joints for skin B
335
336                   for each joint X in skin A:
337                         for each root joint R in skin B:
338                                 if (find_node_in_tree(X, R)) {
339                                         shared = 1;
340                                         goto endloop;
341                                 }
342           }
343
344           endloop:
345         */
346
347         SkinInfo *a = &skin;
348         Object *shared = NULL;
349         std::vector<COLLADAFW::Node*> skin_root_joints;
350
351         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
352         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
353                 SkinInfo *b = &it->second;
354                 if (b == a || b->get_armature() == NULL)
355                         continue;
356
357                 skin_root_joints.clear();
358
359                 b->find_root_joints(root_joints, joint_by_uid, skin_root_joints);
360
361                 std::vector<COLLADAFW::Node*>::iterator ri;
362                 for (ri = skin_root_joints.begin(); ri != skin_root_joints.end(); ri++) {
363                         if (a->uses_joint_or_descendant(*ri)) {
364                                 shared = b->get_armature();
365                                 break;
366                         }
367                 }
368
369                 if (shared != NULL)
370                         break;
371         }
372
373         if (shared)
374                 ob_arm = skin.set_armature(shared);
375         else
376                 ob_arm = skin.create_armature(scene);
377
378         // enter armature edit mode
379         ED_armature_to_edit(ob_arm);
380
381         leaf_bones.clear();
382         totbone = 0;
383         // bone_direction_row = 1; // TODO: don't default to Y but use asset and based on it decide on default row
384         leaf_bone_length = FLT_MAX;
385         // min_angle = 360.0f;          // minimum angle between bone head-tail and a row of bone matrix
386
387         // create bones
388         /*
389            TODO:
390            check if bones have already been created for a given joint
391         */
392
393         std::vector<COLLADAFW::Node*>::iterator ri;
394         for (ri = root_joints.begin(); ri != root_joints.end(); ri++) {
395                 // for shared armature check if bone tree is already created
396                 if (shared && std::find(skin_root_joints.begin(), skin_root_joints.end(), *ri) != skin_root_joints.end())
397                         continue;
398
399                 // since root_joints may contain joints for multiple controllers, we need to filter
400                 if (skin.uses_joint_or_descendant(*ri)) {
401                         create_bone(skin, *ri, NULL, (*ri)->getChildNodes().getCount(), NULL, (bArmature*)ob_arm->data);
402
403                         if (joint_parent_map.find((*ri)->getUniqueId()) != joint_parent_map.end() && !skin.get_parent())
404                                 skin.set_parent(joint_parent_map[(*ri)->getUniqueId()]);
405                 }
406         }
407
408         fix_leaf_bones();
409
410         // exit armature edit mode
411         ED_armature_from_edit(ob_arm);
412         ED_armature_edit_free(ob_arm);
413         DAG_id_tag_update(&ob_arm->id, OB_RECALC_OB|OB_RECALC_DATA);
414
415         // set_leaf_bone_shapes(ob_arm);
416         // set_euler_rotmode();
417 }
418
419
420 // root - if this joint is the top joint in hierarchy, if a joint
421 // is a child of a node (not joint), root should be true since
422 // this is where we build armature bones from
423 void ArmatureImporter::add_joint(COLLADAFW::Node *node, bool root, Object *parent)
424 {
425         joint_by_uid[node->getUniqueId()] = node;
426         if (root) {
427                 root_joints.push_back(node);
428
429                 if (parent)
430                         joint_parent_map[node->getUniqueId()] = parent;
431         }
432 }
433
434 #if 0
435 void ArmatureImporter::add_root_joint(COLLADAFW::Node *node)
436 {
437         // root_joints.push_back(node);
438         Object *ob_arm = find_armature(node);
439         if (ob_arm)     {
440                 get_armature_joints(ob_arm).root_joints.push_back(node);
441         }
442 #ifdef COLLADA_DEBUG
443         else {
444                 fprintf(stderr, "%s cannot be added to armature.\n", get_joint_name(node));
445         }
446 #endif
447 }
448 #endif
449
450 // here we add bones to armatures, having armatures previously created in write_controller
451 void ArmatureImporter::make_armatures(bContext *C)
452 {
453         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
454         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
455
456                 SkinInfo& skin = it->second;
457
458                 create_armature_bones(skin);
459
460                 // link armature with a mesh object
461                 Object *ob = mesh_importer->get_object_by_geom_uid(*get_geometry_uid(skin.get_controller_uid()));
462                 if (ob)
463                         skin.link_armature(C, ob, joint_by_uid, this);
464                 else
465                         fprintf(stderr, "Cannot find object to link armature with.\n");
466
467                 // set armature parent if any
468                 Object *par = skin.get_parent();
469                 if (par)
470                         bc_set_parent(skin.get_armature(), par, C, false);
471
472                 // free memory stolen from SkinControllerData
473                 skin.free();
474         }
475 }
476
477 #if 0
478 // link with meshes, create vertex groups, assign weights
479 void ArmatureImporter::link_armature(Object *ob_arm, const COLLADAFW::UniqueId& geom_id, const COLLADAFW::UniqueId& controller_data_id)
480 {
481         Object *ob = mesh_importer->get_object_by_geom_uid(geom_id);
482
483         if (!ob) {
484                 fprintf(stderr, "Cannot find object by geometry UID.\n");
485                 return;
486         }
487
488         if (skin_by_data_uid.find(controller_data_id) == skin_by_data_uid.end()) {
489                 fprintf(stderr, "Cannot find skin info by controller data UID.\n");
490                 return;
491         }
492
493         SkinInfo& skin = skin_by_data_uid[conroller_data_id];
494
495         // create vertex groups
496 }
497 #endif
498
499 bool ArmatureImporter::write_skin_controller_data(const COLLADAFW::SkinControllerData* data)
500 {
501         // at this stage we get vertex influence info that should go into me->verts and ob->defbase
502         // there's no info to which object this should be long so we associate it with skin controller data UID
503
504         // don't forget to call defgroup_unique_name before we copy
505
506         // controller data uid -> [armature] -> joint data, 
507         // [mesh object]
508         // 
509
510         SkinInfo skin(unit_converter);
511         skin.borrow_skin_controller_data(data);
512
513         // store join inv bind matrix to use it later in armature construction
514         const COLLADAFW::Matrix4Array& inv_bind_mats = data->getInverseBindMatrices();
515         for (unsigned int i = 0; i < data->getJointsCount(); i++) {
516                 skin.add_joint(inv_bind_mats[i]);
517         }
518
519         skin_by_data_uid[data->getUniqueId()] = skin;
520
521         return true;
522 }
523
524 bool ArmatureImporter::write_controller(const COLLADAFW::Controller* controller)
525 {
526         // - create and store armature object
527
528         const COLLADAFW::UniqueId& skin_id = controller->getUniqueId();
529
530         if (controller->getControllerType() == COLLADAFW::Controller::CONTROLLER_TYPE_SKIN) {
531                 COLLADAFW::SkinController *co = (COLLADAFW::SkinController*)controller;
532                 // to be able to find geom id by controller id
533                 geom_uid_by_controller_uid[skin_id] = co->getSource();
534
535                 const COLLADAFW::UniqueId& data_uid = co->getSkinControllerData();
536                 if (skin_by_data_uid.find(data_uid) == skin_by_data_uid.end()) {
537                         fprintf(stderr, "Cannot find skin by controller data UID.\n");
538                         return true;
539                 }
540
541                 skin_by_data_uid[data_uid].set_controller(co);
542         }
543         // morph controller
544         else {
545                 // shape keys? :)
546                 fprintf(stderr, "Morph controller is not supported yet.\n");
547         }
548
549         return true;
550 }
551
552 COLLADAFW::UniqueId *ArmatureImporter::get_geometry_uid(const COLLADAFW::UniqueId& controller_uid)
553 {
554         if (geom_uid_by_controller_uid.find(controller_uid) == geom_uid_by_controller_uid.end())
555                 return NULL;
556
557         return &geom_uid_by_controller_uid[controller_uid];
558 }
559
560 Object *ArmatureImporter::get_armature_for_joint(COLLADAFW::Node *node)
561 {
562         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
563         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
564                 SkinInfo& skin = it->second;
565
566                 if (skin.uses_joint_or_descendant(node))
567                         return skin.get_armature();
568         }
569
570         return NULL;
571 }
572
573 void ArmatureImporter::get_rna_path_for_joint(COLLADAFW::Node *node, char *joint_path, size_t count)
574 {
575         BLI_snprintf(joint_path, count, "pose.bones[\"%s\"]", bc_get_joint_name(node));
576 }
577
578 // gives a world-space mat
579 bool ArmatureImporter::get_joint_bind_mat(float m[][4], COLLADAFW::Node *joint)
580 {
581         std::map<COLLADAFW::UniqueId, SkinInfo>::iterator it;
582         bool found = false;
583         for (it = skin_by_data_uid.begin(); it != skin_by_data_uid.end(); it++) {
584                 SkinInfo& skin = it->second;
585                 if ((found = skin.get_joint_inv_bind_matrix(m, joint))) {
586                         invert_m4(m);
587                         break;
588                 }
589         }
590
591         return found;
592 }