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