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