Cleanup: correct naming IMAGE_Z_DEPTH
[blender.git] / source / blender / blenkernel / intern / armature.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <ctype.h>
25 #include <float.h>
26 #include <math.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_alloca.h"
34 #include "BLI_ghash.h"
35 #include "BLI_listbase.h"
36 #include "BLI_math.h"
37 #include "BLI_string.h"
38 #include "BLI_utildefines.h"
39 #include "BLT_translation.h"
40
41 #include "DNA_armature_types.h"
42 #include "DNA_constraint_types.h"
43 #include "DNA_listBase.h"
44 #include "DNA_object_types.h"
45 #include "DNA_scene_types.h"
46
47 #include "BKE_action.h"
48 #include "BKE_anim_data.h"
49 #include "BKE_anim_visualization.h"
50 #include "BKE_armature.h"
51 #include "BKE_constraint.h"
52 #include "BKE_curve.h"
53 #include "BKE_idprop.h"
54 #include "BKE_idtype.h"
55 #include "BKE_lib_id.h"
56 #include "BKE_lib_query.h"
57 #include "BKE_main.h"
58 #include "BKE_object.h"
59 #include "BKE_scene.h"
60
61 #include "DEG_depsgraph_build.h"
62 #include "DEG_depsgraph_query.h"
63
64 #include "BIK_api.h"
65
66 #include "BLO_read_write.h"
67
68 #include "CLG_log.h"
69
70 static CLG_LogRef LOG = {"bke.armature"};
71
72 /* -------------------------------------------------------------------- */
73 /** \name Prototypes
74  * \{ */
75
76 static void copy_bonechildren(Bone *bone_dst,
77                               const Bone *bone_src,
78                               const Bone *bone_src_act,
79                               Bone **r_bone_dst_act,
80                               const int flag);
81
82 static void copy_bonechildren_custom_handles(Bone *bone_dst, bArmature *arm_dst);
83
84 /** \} */
85
86 /* -------------------------------------------------------------------- */
87 /** \name Armature Data-block
88  * \{ */
89
90 /**
91  * Only copy internal data of Armature ID from source
92  * to already allocated/initialized destination.
93  * You probably never want to use that directly,
94  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
95  *
96  * WARNING! This function will not handle ID user count!
97  *
98  * \param flag: Copying options (see BKE_lib_id.h's LIB_ID_COPY_... flags for more).
99  */
100 static void armature_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
101 {
102   bArmature *armature_dst = (bArmature *)id_dst;
103   const bArmature *armature_src = (const bArmature *)id_src;
104
105   Bone *bone_src, *bone_dst;
106   Bone *bone_dst_act = NULL;
107
108   /* We never handle usercount here for own data. */
109   const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
110
111   armature_dst->bonehash = NULL;
112
113   BLI_duplicatelist(&armature_dst->bonebase, &armature_src->bonebase);
114
115   /* Duplicate the childrens' lists */
116   bone_dst = armature_dst->bonebase.first;
117   for (bone_src = armature_src->bonebase.first; bone_src; bone_src = bone_src->next) {
118     bone_dst->parent = NULL;
119     copy_bonechildren(bone_dst, bone_src, armature_src->act_bone, &bone_dst_act, flag_subdata);
120     bone_dst = bone_dst->next;
121   }
122
123   armature_dst->act_bone = bone_dst_act;
124
125   BKE_armature_bone_hash_make(armature_dst);
126
127   /* Fix custom handle references. */
128   for (bone_dst = armature_dst->bonebase.first; bone_dst; bone_dst = bone_dst->next) {
129     copy_bonechildren_custom_handles(bone_dst, armature_dst);
130   }
131
132   armature_dst->edbo = NULL;
133   armature_dst->act_edbone = NULL;
134 }
135
136 /** Free (or release) any data used by this armature (does not free the armature itself). */
137 static void armature_free_data(struct ID *id)
138 {
139   bArmature *armature = (bArmature *)id;
140
141   BKE_armature_bone_hash_free(armature);
142   BKE_armature_bonelist_free(&armature->bonebase);
143
144   /* free editmode data */
145   if (armature->edbo) {
146     BLI_freelistN(armature->edbo);
147
148     MEM_freeN(armature->edbo);
149     armature->edbo = NULL;
150   }
151 }
152
153 static void armature_foreach_id_bone(Bone *bone, LibraryForeachIDData *data)
154 {
155   IDP_foreach_property(
156       bone->prop, IDP_TYPE_FILTER_ID, BKE_lib_query_idpropertiesForeachIDLink_callback, data);
157
158   LISTBASE_FOREACH (Bone *, curbone, &bone->childbase) {
159     armature_foreach_id_bone(curbone, data);
160   }
161 }
162
163 static void armature_foreach_id(ID *id, LibraryForeachIDData *data)
164 {
165   bArmature *arm = (bArmature *)id;
166   LISTBASE_FOREACH (Bone *, bone, &arm->bonebase) {
167     armature_foreach_id_bone(bone, data);
168   }
169 }
170
171 static void write_bone(BlendWriter *writer, Bone *bone)
172 {
173   /* PATCH for upward compatibility after 2.37+ armature recode */
174   bone->size[0] = bone->size[1] = bone->size[2] = 1.0f;
175
176   /* Write this bone */
177   BLO_write_struct(writer, Bone, bone);
178
179   /* Write ID Properties -- and copy this comment EXACTLY for easy finding
180    * of library blocks that implement this.*/
181   if (bone->prop) {
182     IDP_BlendWrite(writer, bone->prop);
183   }
184
185   /* Write Children */
186   LISTBASE_FOREACH (Bone *, cbone, &bone->childbase) {
187     write_bone(writer, cbone);
188   }
189 }
190
191 static void armature_blend_write(BlendWriter *writer, ID *id, const void *id_address)
192 {
193   bArmature *arm = (bArmature *)id;
194   if (arm->id.us > 0 || BLO_write_is_undo(writer)) {
195     /* Clean up, important in undo case to reduce false detection of changed datablocks. */
196     arm->bonehash = NULL;
197     arm->edbo = NULL;
198     /* Must always be cleared (armatures don't have their own edit-data). */
199     arm->needs_flush_to_id = 0;
200     arm->act_edbone = NULL;
201
202     BLO_write_id_struct(writer, bArmature, id_address, &arm->id);
203     BKE_id_blend_write(writer, &arm->id);
204
205     if (arm->adt) {
206       BKE_animdata_blend_write(writer, arm->adt);
207     }
208
209     /* Direct data */
210     LISTBASE_FOREACH (Bone *, bone, &arm->bonebase) {
211       write_bone(writer, bone);
212     }
213   }
214 }
215
216 static void direct_link_bones(BlendDataReader *reader, Bone *bone)
217 {
218   BLO_read_data_address(reader, &bone->parent);
219   BLO_read_data_address(reader, &bone->prop);
220   IDP_BlendDataRead(reader, &bone->prop);
221
222   BLO_read_data_address(reader, &bone->bbone_next);
223   BLO_read_data_address(reader, &bone->bbone_prev);
224
225   bone->flag &= ~(BONE_DRAW_ACTIVE | BONE_DRAW_LOCKED_WEIGHT);
226
227   BLO_read_list(reader, &bone->childbase);
228
229   LISTBASE_FOREACH (Bone *, child, &bone->childbase) {
230     direct_link_bones(reader, child);
231   }
232 }
233
234 static void armature_blend_read_data(BlendDataReader *reader, ID *id)
235 {
236   bArmature *arm = (bArmature *)id;
237   BLO_read_list(reader, &arm->bonebase);
238   arm->bonehash = NULL;
239   arm->edbo = NULL;
240   /* Must always be cleared (armatures don't have their own edit-data). */
241   arm->needs_flush_to_id = 0;
242
243   BLO_read_data_address(reader, &arm->adt);
244   BKE_animdata_blend_read_data(reader, arm->adt);
245
246   LISTBASE_FOREACH (Bone *, bone, &arm->bonebase) {
247     direct_link_bones(reader, bone);
248   }
249
250   BLO_read_data_address(reader, &arm->act_bone);
251   arm->act_edbone = NULL;
252
253   BKE_armature_bone_hash_make(arm);
254 }
255
256 static void lib_link_bones(BlendLibReader *reader, Bone *bone)
257 {
258   IDP_BlendReadLib(reader, bone->prop);
259
260   LISTBASE_FOREACH (Bone *, curbone, &bone->childbase) {
261     lib_link_bones(reader, curbone);
262   }
263 }
264
265 static void armature_blend_read_lib(BlendLibReader *reader, ID *id)
266 {
267   bArmature *arm = (bArmature *)id;
268   LISTBASE_FOREACH (Bone *, curbone, &arm->bonebase) {
269     lib_link_bones(reader, curbone);
270   }
271 }
272
273 static void expand_bones(BlendExpander *expander, Bone *bone)
274 {
275   IDP_BlendReadExpand(expander, bone->prop);
276
277   LISTBASE_FOREACH (Bone *, curBone, &bone->childbase) {
278     expand_bones(expander, curBone);
279   }
280 }
281
282 static void armature_blend_read_expand(BlendExpander *expander, ID *id)
283 {
284   bArmature *arm = (bArmature *)id;
285   LISTBASE_FOREACH (Bone *, curBone, &arm->bonebase) {
286     expand_bones(expander, curBone);
287   }
288 }
289
290 IDTypeInfo IDType_ID_AR = {
291     .id_code = ID_AR,
292     .id_filter = FILTER_ID_AR,
293     .main_listbase_index = INDEX_ID_AR,
294     .struct_size = sizeof(bArmature),
295     .name = "Armature",
296     .name_plural = "armatures",
297     .translation_context = BLT_I18NCONTEXT_ID_ARMATURE,
298     .flags = 0,
299
300     .init_data = NULL,
301     .copy_data = armature_copy_data,
302     .free_data = armature_free_data,
303     .make_local = NULL,
304     .foreach_id = armature_foreach_id,
305     .foreach_cache = NULL,
306
307     .blend_write = armature_blend_write,
308     .blend_read_data = armature_blend_read_data,
309     .blend_read_lib = armature_blend_read_lib,
310     .blend_read_expand = armature_blend_read_expand,
311 };
312
313 /** \} */
314
315 /* -------------------------------------------------------------------- */
316 /** \name Generic Data-Level Functions
317  * \{ */
318
319 bArmature *BKE_armature_add(Main *bmain, const char *name)
320 {
321   bArmature *arm;
322
323   arm = BKE_libblock_alloc(bmain, ID_AR, name, 0);
324   arm->deformflag = ARM_DEF_VGROUP | ARM_DEF_ENVELOPE;
325   arm->flag = ARM_COL_CUSTOM; /* custom bone-group colors */
326   arm->layer = 1;
327   return arm;
328 }
329
330 bArmature *BKE_armature_from_object(Object *ob)
331 {
332   if (ob->type == OB_ARMATURE) {
333     return (bArmature *)ob->data;
334   }
335   return NULL;
336 }
337
338 int BKE_armature_bonelist_count(ListBase *lb)
339 {
340   int i = 0;
341   LISTBASE_FOREACH (Bone *, bone, lb) {
342     i += 1 + BKE_armature_bonelist_count(&bone->childbase);
343   }
344
345   return i;
346 }
347
348 void BKE_armature_bonelist_free(ListBase *lb)
349 {
350   Bone *bone;
351
352   for (bone = lb->first; bone; bone = bone->next) {
353     if (bone->prop) {
354       IDP_FreeProperty(bone->prop);
355     }
356     BKE_armature_bonelist_free(&bone->childbase);
357   }
358
359   BLI_freelistN(lb);
360 }
361
362 static void copy_bonechildren(Bone *bone_dst,
363                               const Bone *bone_src,
364                               const Bone *bone_src_act,
365                               Bone **r_bone_dst_act,
366                               const int flag)
367 {
368   Bone *bone_src_child, *bone_dst_child;
369
370   if (bone_src == bone_src_act) {
371     *r_bone_dst_act = bone_dst;
372   }
373
374   if (bone_src->prop) {
375     bone_dst->prop = IDP_CopyProperty_ex(bone_src->prop, flag);
376   }
377
378   /* Copy this bone's list */
379   BLI_duplicatelist(&bone_dst->childbase, &bone_src->childbase);
380
381   /* For each child in the list, update it's children */
382   for (bone_src_child = bone_src->childbase.first, bone_dst_child = bone_dst->childbase.first;
383        bone_src_child;
384        bone_src_child = bone_src_child->next, bone_dst_child = bone_dst_child->next) {
385     bone_dst_child->parent = bone_dst;
386     copy_bonechildren(bone_dst_child, bone_src_child, bone_src_act, r_bone_dst_act, flag);
387   }
388 }
389
390 static void copy_bonechildren_custom_handles(Bone *bone_dst, bArmature *arm_dst)
391 {
392   Bone *bone_dst_child;
393
394   if (bone_dst->bbone_prev) {
395     bone_dst->bbone_prev = BKE_armature_find_bone_name(arm_dst, bone_dst->bbone_prev->name);
396   }
397   if (bone_dst->bbone_next) {
398     bone_dst->bbone_next = BKE_armature_find_bone_name(arm_dst, bone_dst->bbone_next->name);
399   }
400
401   for (bone_dst_child = bone_dst->childbase.first; bone_dst_child;
402        bone_dst_child = bone_dst_child->next) {
403     copy_bonechildren_custom_handles(bone_dst_child, arm_dst);
404   }
405 }
406
407 bArmature *BKE_armature_copy(Main *bmain, const bArmature *arm)
408 {
409   bArmature *arm_copy;
410   BKE_id_copy(bmain, &arm->id, (ID **)&arm_copy);
411   return arm_copy;
412 }
413
414 /** \} */
415
416 /* -------------------------------------------------------------------- */
417 /** \name Armature Transform Copy
418  * \{ */
419
420 static void copy_bone_transform(Bone *bone_dst, const Bone *bone_src)
421 {
422   bone_dst->roll = bone_src->roll;
423
424   copy_v3_v3(bone_dst->head, bone_src->head);
425   copy_v3_v3(bone_dst->tail, bone_src->tail);
426
427   copy_m3_m3(bone_dst->bone_mat, bone_src->bone_mat);
428
429   copy_v3_v3(bone_dst->arm_head, bone_src->arm_head);
430   copy_v3_v3(bone_dst->arm_tail, bone_src->arm_tail);
431
432   copy_m4_m4(bone_dst->arm_mat, bone_src->arm_mat);
433
434   bone_dst->arm_roll = bone_src->arm_roll;
435 }
436
437 void BKE_armature_copy_bone_transforms(bArmature *armature_dst, const bArmature *armature_src)
438 {
439   Bone *bone_dst = armature_dst->bonebase.first;
440   const Bone *bone_src = armature_src->bonebase.first;
441   while (bone_dst != NULL) {
442     BLI_assert(bone_src != NULL);
443     copy_bone_transform(bone_dst, bone_src);
444     bone_dst = bone_dst->next;
445     bone_src = bone_src->next;
446   }
447 }
448
449 /** \} */
450
451 /* -------------------------------------------------------------------- */
452 /** \name Armature Transform by 4x4 Matrix
453  *
454  * \see #ED_armature_edit_transform for the edit-mode version of this function.
455  * \{ */
456
457 /** Helper for #ED_armature_transform */
458 static void armature_transform_recurse(ListBase *bonebase,
459                                        const float mat[4][4],
460                                        const bool do_props,
461                                        /* Cached from 'mat'. */
462                                        const float mat3[3][3],
463                                        const float scale,
464                                        /* Child bones. */
465                                        const Bone *bone_parent,
466                                        const float arm_mat_parent_inv[4][4])
467 {
468   LISTBASE_FOREACH (Bone *, bone, bonebase) {
469
470     /* Store the initial bone roll in a matrix, this is needed even for child bones
471      * so any change in head/tail doesn't cause the roll to change.
472      *
473      * Logic here is different to edit-mode because
474      * this is calculated in relative to the parent. */
475     float roll_mat3_pre[3][3];
476     {
477       float delta[3];
478       sub_v3_v3v3(delta, bone->tail, bone->head);
479       vec_roll_to_mat3(delta, bone->roll, roll_mat3_pre);
480       if (bone->parent == NULL) {
481         mul_m3_m3m3(roll_mat3_pre, mat3, roll_mat3_pre);
482       }
483     }
484     /* Optional, use this for predictable results since the roll is re-calculated below anyway. */
485     bone->roll = 0.0f;
486
487     mul_m4_v3(mat, bone->arm_head);
488     mul_m4_v3(mat, bone->arm_tail);
489
490     /* Get the new head and tail */
491     if (bone_parent) {
492       sub_v3_v3v3(bone->head, bone->arm_head, bone_parent->arm_tail);
493       sub_v3_v3v3(bone->tail, bone->arm_tail, bone_parent->arm_tail);
494
495       mul_mat3_m4_v3(arm_mat_parent_inv, bone->head);
496       mul_mat3_m4_v3(arm_mat_parent_inv, bone->tail);
497     }
498     else {
499       copy_v3_v3(bone->head, bone->arm_head);
500       copy_v3_v3(bone->tail, bone->arm_tail);
501     }
502
503     /* Now the head/tail have been updated, set the roll back, matching 'roll_mat3_pre'. */
504     {
505       float roll_mat3_post[3][3], delta_mat3[3][3];
506       float delta[3];
507       sub_v3_v3v3(delta, bone->tail, bone->head);
508       vec_roll_to_mat3(delta, 0.0f, roll_mat3_post);
509       invert_m3(roll_mat3_post);
510       mul_m3_m3m3(delta_mat3, roll_mat3_post, roll_mat3_pre);
511       bone->roll = atan2f(delta_mat3[2][0], delta_mat3[2][2]);
512     }
513
514     BKE_armature_where_is_bone(bone, bone_parent, false);
515
516     {
517       float arm_mat3[3][3];
518       copy_m3_m4(arm_mat3, bone->arm_mat);
519       mat3_to_vec_roll(arm_mat3, NULL, &bone->arm_roll);
520     }
521
522     if (do_props) {
523       bone->rad_head *= scale;
524       bone->rad_tail *= scale;
525       bone->dist *= scale;
526
527       /* we could be smarter and scale by the matrix along the x & z axis */
528       bone->xwidth *= scale;
529       bone->zwidth *= scale;
530     }
531
532     if (!BLI_listbase_is_empty(&bone->childbase)) {
533       float arm_mat_inv[4][4];
534       invert_m4_m4(arm_mat_inv, bone->arm_mat);
535       armature_transform_recurse(&bone->childbase, mat, do_props, mat3, scale, bone, arm_mat_inv);
536     }
537   }
538 }
539
540 void BKE_armature_transform(bArmature *arm, const float mat[4][4], const bool do_props)
541 {
542   /* Store the scale of the matrix here to use on envelopes. */
543   float scale = mat4_to_scale(mat);
544   float mat3[3][3];
545
546   copy_m3_m4(mat3, mat);
547   normalize_m3(mat3);
548
549   armature_transform_recurse(&arm->bonebase, mat, do_props, mat3, scale, NULL, NULL);
550 }
551
552 /** \} */
553
554 /* -------------------------------------------------------------------- */
555 /** \name Armature Bone Find by Name
556  *
557  * Using fast #GHash look-ups when available.
558  * \{ */
559
560 static Bone *get_named_bone_bonechildren(ListBase *lb, const char *name)
561 {
562   Bone *curBone, *rbone;
563
564   for (curBone = lb->first; curBone; curBone = curBone->next) {
565     if (STREQ(curBone->name, name)) {
566       return curBone;
567     }
568
569     rbone = get_named_bone_bonechildren(&curBone->childbase, name);
570     if (rbone) {
571       return rbone;
572     }
573   }
574
575   return NULL;
576 }
577
578 /**
579  * Walk the list until the bone is found (slow!),
580  * use #BKE_armature_bone_from_name_map for multiple lookups.
581  */
582 Bone *BKE_armature_find_bone_name(bArmature *arm, const char *name)
583 {
584   if (!arm) {
585     return NULL;
586   }
587
588   if (arm->bonehash) {
589     return BLI_ghash_lookup(arm->bonehash, name);
590   }
591
592   return get_named_bone_bonechildren(&arm->bonebase, name);
593 }
594
595 static void armature_bone_from_name_insert_recursive(GHash *bone_hash, ListBase *lb)
596 {
597   LISTBASE_FOREACH (Bone *, bone, lb) {
598     BLI_ghash_insert(bone_hash, bone->name, bone);
599     armature_bone_from_name_insert_recursive(bone_hash, &bone->childbase);
600   }
601 }
602
603 /**
604  * Create a (name -> bone) map.
605  *
606  * \note typically #bPose.chanhash us used via #BKE_pose_channel_find_name
607  * this is for the cases we can't use pose channels.
608  */
609 static GHash *armature_bone_from_name_map(bArmature *arm)
610 {
611   const int bones_count = BKE_armature_bonelist_count(&arm->bonebase);
612   GHash *bone_hash = BLI_ghash_str_new_ex(__func__, bones_count);
613   armature_bone_from_name_insert_recursive(bone_hash, &arm->bonebase);
614   return bone_hash;
615 }
616
617 void BKE_armature_bone_hash_make(bArmature *arm)
618 {
619   if (!arm->bonehash) {
620     arm->bonehash = armature_bone_from_name_map(arm);
621   }
622 }
623
624 void BKE_armature_bone_hash_free(bArmature *arm)
625 {
626   if (arm->bonehash) {
627     BLI_ghash_free(arm->bonehash, NULL, NULL);
628     arm->bonehash = NULL;
629   }
630 }
631
632 /** \} */
633
634 /* -------------------------------------------------------------------- */
635 /** \name Armature Bone Flags
636  * \{ */
637
638 bool BKE_armature_bone_flag_test_recursive(const Bone *bone, int flag)
639 {
640   if (bone->flag & flag) {
641     return true;
642   }
643   if (bone->parent) {
644     return BKE_armature_bone_flag_test_recursive(bone->parent, flag);
645   }
646   return false;
647 }
648
649 /** \} */
650
651 /* -------------------------------------------------------------------- */
652 /** \name Armature Layer Refresh Used
653  * \{ */
654
655 static void armature_refresh_layer_used_recursive(bArmature *arm, ListBase *bones)
656 {
657   LISTBASE_FOREACH (Bone *, bone, bones) {
658     arm->layer_used |= bone->layer;
659     armature_refresh_layer_used_recursive(arm, &bone->childbase);
660   }
661 }
662
663 void BKE_armature_refresh_layer_used(struct Depsgraph *depsgraph, struct bArmature *arm)
664 {
665   if (arm->edbo != NULL) {
666     /* Don't perform this update when the armature is in edit mode. In that case it should be
667      * handled by ED_armature_edit_refresh_layer_used(). */
668     return;
669   }
670
671   arm->layer_used = 0;
672   armature_refresh_layer_used_recursive(arm, &arm->bonebase);
673
674   if (depsgraph == NULL || DEG_is_active(depsgraph)) {
675     bArmature *arm_orig = (bArmature *)DEG_get_original_id(&arm->id);
676     arm_orig->layer_used = arm->layer_used;
677   }
678 }
679
680 /** \} */
681
682 /* -------------------------------------------------------------------- */
683 /** \name Armature Layer Refresh Used
684  * \{ */
685
686 /* Finds the best possible extension to the name on a particular axis. (For renaming, check for
687  * unique names afterwards) strip_number: removes number extensions  (TODO: not used)
688  * axis: the axis to name on
689  * head/tail: the head/tail co-ordinate of the bone on the specified axis */
690 bool bone_autoside_name(
691     char name[MAXBONENAME], int UNUSED(strip_number), short axis, float head, float tail)
692 {
693   unsigned int len;
694   char basename[MAXBONENAME] = "";
695   char extension[5] = "";
696
697   len = strlen(name);
698   if (len == 0) {
699     return false;
700   }
701   BLI_strncpy(basename, name, sizeof(basename));
702
703   /* Figure out extension to append:
704    * - The extension to append is based upon the axis that we are working on.
705    * - If head happens to be on 0, then we must consider the tail position as well to decide
706    *   which side the bone is on
707    *   -> If tail is 0, then it's bone is considered to be on axis, so no extension should be added
708    *   -> Otherwise, extension is added from perspective of object based on which side tail goes to
709    * - If head is non-zero, extension is added from perspective of object based on side head is on
710    */
711   if (axis == 2) {
712     /* z-axis - vertical (top/bottom) */
713     if (IS_EQF(head, 0.0f)) {
714       if (tail < 0) {
715         strcpy(extension, "Bot");
716       }
717       else if (tail > 0) {
718         strcpy(extension, "Top");
719       }
720     }
721     else {
722       if (head < 0) {
723         strcpy(extension, "Bot");
724       }
725       else {
726         strcpy(extension, "Top");
727       }
728     }
729   }
730   else if (axis == 1) {
731     /* y-axis - depth (front/back) */
732     if (IS_EQF(head, 0.0f)) {
733       if (tail < 0) {
734         strcpy(extension, "Fr");
735       }
736       else if (tail > 0) {
737         strcpy(extension, "Bk");
738       }
739     }
740     else {
741       if (head < 0) {
742         strcpy(extension, "Fr");
743       }
744       else {
745         strcpy(extension, "Bk");
746       }
747     }
748   }
749   else {
750     /* x-axis - horizontal (left/right) */
751     if (IS_EQF(head, 0.0f)) {
752       if (tail < 0) {
753         strcpy(extension, "R");
754       }
755       else if (tail > 0) {
756         strcpy(extension, "L");
757       }
758     }
759     else {
760       if (head < 0) {
761         strcpy(extension, "R");
762         /* XXX Shouldn't this be simple else, as for z and y axes? */
763       }
764       else if (head > 0) {
765         strcpy(extension, "L");
766       }
767     }
768   }
769
770   /* Simple name truncation
771    * - truncate if there is an extension and it wouldn't be able to fit
772    * - otherwise, just append to end
773    */
774   if (extension[0]) {
775     bool changed = true;
776
777     while (changed) { /* remove extensions */
778       changed = false;
779       if (len > 2 && basename[len - 2] == '.') {
780         if (basename[len - 1] == 'L' || basename[len - 1] == 'R') { /* L R */
781           basename[len - 2] = '\0';
782           len -= 2;
783           changed = true;
784         }
785       }
786       else if (len > 3 && basename[len - 3] == '.') {
787         if ((basename[len - 2] == 'F' && basename[len - 1] == 'r') || /* Fr */
788             (basename[len - 2] == 'B' && basename[len - 1] == 'k'))   /* Bk */
789         {
790           basename[len - 3] = '\0';
791           len -= 3;
792           changed = true;
793         }
794       }
795       else if (len > 4 && basename[len - 4] == '.') {
796         if ((basename[len - 3] == 'T' && basename[len - 2] == 'o' &&
797              basename[len - 1] == 'p') || /* Top */
798             (basename[len - 3] == 'B' && basename[len - 2] == 'o' &&
799              basename[len - 1] == 't')) /* Bot */
800         {
801           basename[len - 4] = '\0';
802           len -= 4;
803           changed = true;
804         }
805       }
806     }
807
808     if ((MAXBONENAME - len) < strlen(extension) + 1) { /* add 1 for the '.' */
809       strncpy(name, basename, len - strlen(extension));
810     }
811
812     BLI_snprintf(name, MAXBONENAME, "%s.%s", basename, extension);
813
814     return true;
815   }
816   return false;
817 }
818
819 /** \} */
820
821 /* -------------------------------------------------------------------- */
822 /** \name Armature B-Bone Support
823  * \{ */
824
825 /* Compute a set of bezier parameter values that produce approximately equally spaced points. */
826 static void equalize_cubic_bezier(const float control[4][3],
827                                   int temp_segments,
828                                   int final_segments,
829                                   float *r_t_points)
830 {
831   float(*coords)[3] = BLI_array_alloca(coords, temp_segments + 1);
832   float *pdist = BLI_array_alloca(pdist, temp_segments + 1);
833
834   /* Compute the first pass of bezier point coordinates. */
835   for (int i = 0; i < 3; i++) {
836     BKE_curve_forward_diff_bezier(control[0][i],
837                                   control[1][i],
838                                   control[2][i],
839                                   control[3][i],
840                                   &coords[0][i],
841                                   temp_segments,
842                                   sizeof(*coords));
843   }
844
845   /* Calculate the length of the polyline at each point. */
846   pdist[0] = 0.0f;
847
848   for (int i = 0; i < temp_segments; i++) {
849     pdist[i + 1] = pdist[i] + len_v3v3(coords[i], coords[i + 1]);
850   }
851
852   /* Go over distances and calculate new parameter values. */
853   float dist_step = pdist[temp_segments] / final_segments;
854
855   r_t_points[0] = 0.0f;
856
857   for (int i = 1, nr = 1; i <= final_segments; i++) {
858     float dist = i * dist_step;
859
860     /* We're looking for location (distance) 'dist' in the array. */
861     while ((nr < temp_segments) && (dist >= pdist[nr])) {
862       nr++;
863     }
864
865     float fac = (pdist[nr] - dist) / (pdist[nr] - pdist[nr - 1]);
866
867     r_t_points[i] = (nr - fac) / temp_segments;
868   }
869
870   r_t_points[final_segments] = 1.0f;
871 }
872
873 /* Evaluate bezier position and tangent at a specific parameter value
874  * using the De Casteljau algorithm. */
875 static void evaluate_cubic_bezier(const float control[4][3],
876                                   float t,
877                                   float r_pos[3],
878                                   float r_tangent[3])
879 {
880   float layer1[3][3];
881   interp_v3_v3v3(layer1[0], control[0], control[1], t);
882   interp_v3_v3v3(layer1[1], control[1], control[2], t);
883   interp_v3_v3v3(layer1[2], control[2], control[3], t);
884
885   float layer2[2][3];
886   interp_v3_v3v3(layer2[0], layer1[0], layer1[1], t);
887   interp_v3_v3v3(layer2[1], layer1[1], layer1[2], t);
888
889   sub_v3_v3v3(r_tangent, layer2[1], layer2[0]);
890   madd_v3_v3v3fl(r_pos, layer2[0], r_tangent, t);
891 }
892
893 /* Get "next" and "prev" bones - these are used for handle calculations. */
894 void BKE_pchan_bbone_handles_get(bPoseChannel *pchan, bPoseChannel **r_prev, bPoseChannel **r_next)
895 {
896   if (pchan->bone->bbone_prev_type == BBONE_HANDLE_AUTO) {
897     /* Use connected parent. */
898     if (pchan->bone->flag & BONE_CONNECTED) {
899       *r_prev = pchan->parent;
900     }
901     else {
902       *r_prev = NULL;
903     }
904   }
905   else {
906     /* Use the provided bone as prev - leave blank to eliminate this effect altogether. */
907     *r_prev = pchan->bbone_prev;
908   }
909
910   if (pchan->bone->bbone_next_type == BBONE_HANDLE_AUTO) {
911     /* Use connected child. */
912     *r_next = pchan->child;
913   }
914   else {
915     /* Use the provided bone as next - leave blank to eliminate this effect altogether. */
916     *r_next = pchan->bbone_next;
917   }
918 }
919
920 /* Compute B-Bone spline parameters for the given channel. */
921 void BKE_pchan_bbone_spline_params_get(struct bPoseChannel *pchan,
922                                        const bool rest,
923                                        struct BBoneSplineParameters *param)
924 {
925   bPoseChannel *next, *prev;
926   Bone *bone = pchan->bone;
927   float imat[4][4], posemat[4][4];
928   float delta[3];
929
930   memset(param, 0, sizeof(*param));
931
932   param->segments = bone->segments;
933   param->length = bone->length;
934
935   if (!rest) {
936     float scale[3];
937
938     /* Check if we need to take non-uniform bone scaling into account. */
939     mat4_to_size(scale, pchan->pose_mat);
940
941     if (fabsf(scale[0] - scale[1]) > 1e-6f || fabsf(scale[1] - scale[2]) > 1e-6f) {
942       param->do_scale = true;
943       copy_v3_v3(param->scale, scale);
944     }
945   }
946
947   BKE_pchan_bbone_handles_get(pchan, &prev, &next);
948
949   /* Find the handle points, since this is inside bone space, the
950    * first point = (0, 0, 0)
951    * last point =  (0, length, 0) */
952   if (rest) {
953     invert_m4_m4(imat, pchan->bone->arm_mat);
954   }
955   else if (param->do_scale) {
956     copy_m4_m4(posemat, pchan->pose_mat);
957     normalize_m4(posemat);
958     invert_m4_m4(imat, posemat);
959   }
960   else {
961     invert_m4_m4(imat, pchan->pose_mat);
962   }
963
964   if (prev) {
965     float h1[3];
966     bool done = false;
967
968     param->use_prev = true;
969
970     /* Transform previous point inside this bone space. */
971     if (bone->bbone_prev_type == BBONE_HANDLE_RELATIVE) {
972       /* Use delta movement (from restpose), and apply this relative to the current bone's head. */
973       if (rest) {
974         /* In restpose, arm_head == pose_head */
975         zero_v3(param->prev_h);
976         done = true;
977       }
978       else {
979         sub_v3_v3v3(delta, prev->pose_head, prev->bone->arm_head);
980         sub_v3_v3v3(h1, pchan->pose_head, delta);
981       }
982     }
983     else if (bone->bbone_prev_type == BBONE_HANDLE_TANGENT) {
984       /* Use bone direction by offsetting so that its tail meets current bone's head */
985       if (rest) {
986         sub_v3_v3v3(delta, prev->bone->arm_tail, prev->bone->arm_head);
987         sub_v3_v3v3(h1, bone->arm_head, delta);
988       }
989       else {
990         sub_v3_v3v3(delta, prev->pose_tail, prev->pose_head);
991         sub_v3_v3v3(h1, pchan->pose_head, delta);
992       }
993     }
994     else {
995       /* Apply special handling for smoothly joining B-Bone chains */
996       param->prev_bbone = (prev->bone->segments > 1);
997
998       /* Use bone head as absolute position. */
999       copy_v3_v3(h1, rest ? prev->bone->arm_head : prev->pose_head);
1000     }
1001
1002     if (!done) {
1003       mul_v3_m4v3(param->prev_h, imat, h1);
1004     }
1005
1006     if (!param->prev_bbone) {
1007       /* Find the previous roll to interpolate. */
1008       mul_m4_m4m4(param->prev_mat, imat, rest ? prev->bone->arm_mat : prev->pose_mat);
1009     }
1010   }
1011
1012   if (next) {
1013     float h2[3];
1014     bool done = false;
1015
1016     param->use_next = true;
1017
1018     /* Transform next point inside this bone space. */
1019     if (bone->bbone_next_type == BBONE_HANDLE_RELATIVE) {
1020       /* Use delta movement (from restpose), and apply this relative to the current bone's tail. */
1021       if (rest) {
1022         /* In restpose, arm_head == pose_head */
1023         copy_v3_fl3(param->next_h, 0.0f, param->length, 0.0);
1024         done = true;
1025       }
1026       else {
1027         sub_v3_v3v3(delta, next->pose_head, next->bone->arm_head);
1028         add_v3_v3v3(h2, pchan->pose_tail, delta);
1029       }
1030     }
1031     else if (bone->bbone_next_type == BBONE_HANDLE_TANGENT) {
1032       /* Use bone direction by offsetting so that its head meets current bone's tail */
1033       if (rest) {
1034         sub_v3_v3v3(delta, next->bone->arm_tail, next->bone->arm_head);
1035         add_v3_v3v3(h2, bone->arm_tail, delta);
1036       }
1037       else {
1038         sub_v3_v3v3(delta, next->pose_tail, next->pose_head);
1039         add_v3_v3v3(h2, pchan->pose_tail, delta);
1040       }
1041     }
1042     else {
1043       /* Apply special handling for smoothly joining B-Bone chains */
1044       param->next_bbone = (next->bone->segments > 1);
1045
1046       /* Use bone tail as absolute position. */
1047       copy_v3_v3(h2, rest ? next->bone->arm_tail : next->pose_tail);
1048     }
1049
1050     if (!done) {
1051       mul_v3_m4v3(param->next_h, imat, h2);
1052     }
1053
1054     /* Find the next roll to interpolate as well. */
1055     mul_m4_m4m4(param->next_mat, imat, rest ? next->bone->arm_mat : next->pose_mat);
1056   }
1057
1058   /* Add effects from bbone properties over the top
1059    * - These properties allow users to hand-animate the
1060    *   bone curve/shape, without having to resort to using
1061    *   extra bones
1062    * - The "bone" level offsets are for defining the restpose
1063    *   shape of the bone (e.g. for curved eyebrows for example).
1064    *   -> In the viewport, it's needed to define what the rest pose
1065    *      looks like
1066    *   -> For "rest == 0", we also still need to have it present
1067    *      so that we can "cancel out" this restpose when it comes
1068    *      time to deform some geometry, it won't cause double transforms.
1069    * - The "pchan" level offsets are the ones that animators actually
1070    *   end up animating
1071    */
1072   {
1073     param->ease1 = bone->ease1 + (!rest ? pchan->ease1 : 0.0f);
1074     param->ease2 = bone->ease2 + (!rest ? pchan->ease2 : 0.0f);
1075
1076     param->roll1 = bone->roll1 + (!rest ? pchan->roll1 : 0.0f);
1077     param->roll2 = bone->roll2 + (!rest ? pchan->roll2 : 0.0f);
1078
1079     if (bone->flag & BONE_ADD_PARENT_END_ROLL) {
1080       if (prev) {
1081         if (prev->bone) {
1082           param->roll1 += prev->bone->roll2;
1083         }
1084
1085         if (!rest) {
1086           param->roll1 += prev->roll2;
1087         }
1088       }
1089     }
1090
1091     param->scale_in_x = bone->scale_in_x * (!rest ? pchan->scale_in_x : 1.0f);
1092     param->scale_in_y = bone->scale_in_y * (!rest ? pchan->scale_in_y : 1.0f);
1093     param->scale_out_x = bone->scale_out_x * (!rest ? pchan->scale_out_x : 1.0f);
1094     param->scale_out_y = bone->scale_out_y * (!rest ? pchan->scale_out_y : 1.0f);
1095
1096     /* Extra curve x / y */
1097     param->curve_in_x = bone->curve_in_x + (!rest ? pchan->curve_in_x : 0.0f);
1098     param->curve_in_y = bone->curve_in_y + (!rest ? pchan->curve_in_y : 0.0f);
1099
1100     param->curve_out_x = bone->curve_out_x + (!rest ? pchan->curve_out_x : 0.0f);
1101     param->curve_out_y = bone->curve_out_y + (!rest ? pchan->curve_out_y : 0.0f);
1102   }
1103 }
1104
1105 /* Fills the array with the desired amount of bone->segments elements.
1106  * This calculation is done within unit bone space. */
1107 void BKE_pchan_bbone_spline_setup(bPoseChannel *pchan,
1108                                   const bool rest,
1109                                   const bool for_deform,
1110                                   Mat4 *result_array)
1111 {
1112   BBoneSplineParameters param;
1113
1114   BKE_pchan_bbone_spline_params_get(pchan, rest, &param);
1115
1116   pchan->bone->segments = BKE_pchan_bbone_spline_compute(&param, for_deform, result_array);
1117 }
1118
1119 /* Computes the bezier handle vectors and rolls coming from custom handles. */
1120 void BKE_pchan_bbone_handles_compute(const BBoneSplineParameters *param,
1121                                      float h1[3],
1122                                      float *r_roll1,
1123                                      float h2[3],
1124                                      float *r_roll2,
1125                                      bool ease,
1126                                      bool offsets)
1127 {
1128   float mat3[3][3];
1129   float length = param->length;
1130   float epsilon = 1e-5 * length;
1131
1132   if (param->do_scale) {
1133     length *= param->scale[1];
1134   }
1135
1136   *r_roll1 = *r_roll2 = 0.0f;
1137
1138   if (param->use_prev) {
1139     copy_v3_v3(h1, param->prev_h);
1140
1141     if (param->prev_bbone) {
1142       /* If previous bone is B-bone too, use average handle direction. */
1143       h1[1] -= length;
1144     }
1145
1146     if (normalize_v3(h1) < epsilon) {
1147       copy_v3_fl3(h1, 0.0f, -1.0f, 0.0f);
1148     }
1149
1150     negate_v3(h1);
1151
1152     if (!param->prev_bbone) {
1153       /* Find the previous roll to interpolate. */
1154       copy_m3_m4(mat3, param->prev_mat);
1155       mat3_vec_to_roll(mat3, h1, r_roll1);
1156     }
1157   }
1158   else {
1159     h1[0] = 0.0f;
1160     h1[1] = 1.0;
1161     h1[2] = 0.0f;
1162   }
1163
1164   if (param->use_next) {
1165     copy_v3_v3(h2, param->next_h);
1166
1167     /* If next bone is B-bone too, use average handle direction. */
1168     if (param->next_bbone) {
1169       /* pass */
1170     }
1171     else {
1172       h2[1] -= length;
1173     }
1174
1175     if (normalize_v3(h2) < epsilon) {
1176       copy_v3_fl3(h2, 0.0f, 1.0f, 0.0f);
1177     }
1178
1179     /* Find the next roll to interpolate as well. */
1180     copy_m3_m4(mat3, param->next_mat);
1181     mat3_vec_to_roll(mat3, h2, r_roll2);
1182   }
1183   else {
1184     h2[0] = 0.0f;
1185     h2[1] = 1.0f;
1186     h2[2] = 0.0f;
1187   }
1188
1189   if (ease) {
1190     const float circle_factor = length * (cubic_tangent_factor_circle_v3(h1, h2) / 0.75f);
1191
1192     const float hlength1 = param->ease1 * circle_factor;
1193     const float hlength2 = param->ease2 * circle_factor;
1194
1195     /* and only now negate h2 */
1196     mul_v3_fl(h1, hlength1);
1197     mul_v3_fl(h2, -hlength2);
1198   }
1199
1200   /* Add effects from bbone properties over the top
1201    * - These properties allow users to hand-animate the
1202    *   bone curve/shape, without having to resort to using
1203    *   extra bones
1204    * - The "bone" level offsets are for defining the rest-pose
1205    *   shape of the bone (e.g. for curved eyebrows for example).
1206    *   -> In the viewport, it's needed to define what the rest pose
1207    *      looks like
1208    *   -> For "rest == 0", we also still need to have it present
1209    *      so that we can "cancel out" this rest-pose when it comes
1210    *      time to deform some geometry, it won't cause double transforms.
1211    * - The "pchan" level offsets are the ones that animators actually
1212    *   end up animating
1213    */
1214   if (offsets) {
1215     /* Add extra rolls. */
1216     *r_roll1 += param->roll1;
1217     *r_roll2 += param->roll2;
1218
1219     /* Extra curve x / y */
1220     /* NOTE:
1221      * Scale correction factors here are to compensate for some random floating-point glitches
1222      * when scaling up the bone or it's parent by a factor of approximately 8.15/6, which results
1223      * in the bone length getting scaled up too (from 1 to 8), causing the curve to flatten out.
1224      */
1225     const float xscale_correction = (param->do_scale) ? param->scale[0] : 1.0f;
1226     const float yscale_correction = (param->do_scale) ? param->scale[2] : 1.0f;
1227
1228     h1[0] += param->curve_in_x * xscale_correction;
1229     h1[2] += param->curve_in_y * yscale_correction;
1230
1231     h2[0] += param->curve_out_x * xscale_correction;
1232     h2[2] += param->curve_out_y * yscale_correction;
1233   }
1234 }
1235
1236 static void make_bbone_spline_matrix(BBoneSplineParameters *param,
1237                                      const float scalemats[2][4][4],
1238                                      const float pos[3],
1239                                      const float axis[3],
1240                                      float roll,
1241                                      float scalex,
1242                                      float scaley,
1243                                      float result[4][4])
1244 {
1245   float mat3[3][3];
1246
1247   vec_roll_to_mat3(axis, roll, mat3);
1248
1249   copy_m4_m3(result, mat3);
1250   copy_v3_v3(result[3], pos);
1251
1252   if (param->do_scale) {
1253     /* Correct for scaling when this matrix is used in scaled space. */
1254     mul_m4_series(result, scalemats[0], result, scalemats[1]);
1255   }
1256
1257   /* BBone scale... */
1258   mul_v3_fl(result[0], scalex);
1259   mul_v3_fl(result[2], scaley);
1260 }
1261
1262 /* Fade from first to second derivative when the handle is very short. */
1263 static void ease_handle_axis(const float deriv1[3], const float deriv2[3], float r_axis[3])
1264 {
1265   const float gap = 0.1f;
1266
1267   copy_v3_v3(r_axis, deriv1);
1268
1269   float len1 = len_squared_v3(deriv1), len2 = len_squared_v3(deriv2);
1270   float ratio = len1 / len2;
1271
1272   if (ratio < gap * gap) {
1273     madd_v3_v3fl(r_axis, deriv2, gap - sqrtf(ratio));
1274   }
1275 }
1276
1277 /* Fills the array with the desired amount of bone->segments elements.
1278  * This calculation is done within unit bone space. */
1279 int BKE_pchan_bbone_spline_compute(BBoneSplineParameters *param,
1280                                    const bool for_deform,
1281                                    Mat4 *result_array)
1282 {
1283   float scalemats[2][4][4];
1284   float bezt_controls[4][3];
1285   float h1[3], roll1, h2[3], roll2, prev[3], cur[3], axis[3];
1286   float length = param->length;
1287
1288   if (param->do_scale) {
1289     size_to_mat4(scalemats[1], param->scale);
1290     invert_m4_m4(scalemats[0], scalemats[1]);
1291
1292     length *= param->scale[1];
1293   }
1294
1295   BKE_pchan_bbone_handles_compute(param, h1, &roll1, h2, &roll2, true, true);
1296
1297   /* Make curve. */
1298   CLAMP_MAX(param->segments, MAX_BBONE_SUBDIV);
1299
1300   copy_v3_fl3(bezt_controls[3], 0.0f, length, 0.0f);
1301   add_v3_v3v3(bezt_controls[2], bezt_controls[3], h2);
1302   copy_v3_v3(bezt_controls[1], h1);
1303   zero_v3(bezt_controls[0]);
1304
1305   float bezt_points[MAX_BBONE_SUBDIV + 1];
1306
1307   equalize_cubic_bezier(bezt_controls, MAX_BBONE_SUBDIV, param->segments, bezt_points);
1308
1309   /* Deformation uses N+1 matrices computed at points between the segments. */
1310   if (for_deform) {
1311     /* Bezier derivatives. */
1312     float bezt_deriv1[3][3], bezt_deriv2[2][3];
1313
1314     for (int i = 0; i < 3; i++) {
1315       sub_v3_v3v3(bezt_deriv1[i], bezt_controls[i + 1], bezt_controls[i]);
1316     }
1317     for (int i = 0; i < 2; i++) {
1318       sub_v3_v3v3(bezt_deriv2[i], bezt_deriv1[i + 1], bezt_deriv1[i]);
1319     }
1320
1321     /* End points require special handling to fix zero length handles. */
1322     ease_handle_axis(bezt_deriv1[0], bezt_deriv2[0], axis);
1323     make_bbone_spline_matrix(param,
1324                              scalemats,
1325                              bezt_controls[0],
1326                              axis,
1327                              roll1,
1328                              param->scale_in_x,
1329                              param->scale_in_y,
1330                              result_array[0].mat);
1331
1332     for (int a = 1; a < param->segments; a++) {
1333       evaluate_cubic_bezier(bezt_controls, bezt_points[a], cur, axis);
1334
1335       float fac = ((float)a) / param->segments;
1336       float roll = interpf(roll2, roll1, fac);
1337       float scalex = interpf(param->scale_out_x, param->scale_in_x, fac);
1338       float scaley = interpf(param->scale_out_y, param->scale_in_y, fac);
1339
1340       make_bbone_spline_matrix(
1341           param, scalemats, cur, axis, roll, scalex, scaley, result_array[a].mat);
1342     }
1343
1344     negate_v3(bezt_deriv2[1]);
1345     ease_handle_axis(bezt_deriv1[2], bezt_deriv2[1], axis);
1346     make_bbone_spline_matrix(param,
1347                              scalemats,
1348                              bezt_controls[3],
1349                              axis,
1350                              roll2,
1351                              param->scale_out_x,
1352                              param->scale_out_y,
1353                              result_array[param->segments].mat);
1354   }
1355   /* Other code (e.g. display) uses matrices for the segments themselves. */
1356   else {
1357     zero_v3(prev);
1358
1359     for (int a = 0; a < param->segments; a++) {
1360       evaluate_cubic_bezier(bezt_controls, bezt_points[a + 1], cur, axis);
1361
1362       sub_v3_v3v3(axis, cur, prev);
1363
1364       float fac = (a + 0.5f) / param->segments;
1365       float roll = interpf(roll2, roll1, fac);
1366       float scalex = interpf(param->scale_out_x, param->scale_in_x, fac);
1367       float scaley = interpf(param->scale_out_y, param->scale_in_y, fac);
1368
1369       make_bbone_spline_matrix(
1370           param, scalemats, prev, axis, roll, scalex, scaley, result_array[a].mat);
1371       copy_v3_v3(prev, cur);
1372     }
1373   }
1374
1375   return param->segments;
1376 }
1377
1378 static void allocate_bbone_cache(bPoseChannel *pchan, int segments)
1379 {
1380   bPoseChannel_Runtime *runtime = &pchan->runtime;
1381
1382   if (runtime->bbone_segments != segments) {
1383     BKE_pose_channel_free_bbone_cache(runtime);
1384
1385     runtime->bbone_segments = segments;
1386     runtime->bbone_rest_mats = MEM_malloc_arrayN(
1387         sizeof(Mat4), 1 + (uint)segments, "bPoseChannel_Runtime::bbone_rest_mats");
1388     runtime->bbone_pose_mats = MEM_malloc_arrayN(
1389         sizeof(Mat4), 1 + (uint)segments, "bPoseChannel_Runtime::bbone_pose_mats");
1390     runtime->bbone_deform_mats = MEM_malloc_arrayN(
1391         sizeof(Mat4), 2 + (uint)segments, "bPoseChannel_Runtime::bbone_deform_mats");
1392     runtime->bbone_dual_quats = MEM_malloc_arrayN(
1393         sizeof(DualQuat), 1 + (uint)segments, "bPoseChannel_Runtime::bbone_dual_quats");
1394   }
1395 }
1396
1397 /** Compute and cache the B-Bone shape in the channel runtime struct. */
1398 void BKE_pchan_bbone_segments_cache_compute(bPoseChannel *pchan)
1399 {
1400   bPoseChannel_Runtime *runtime = &pchan->runtime;
1401   Bone *bone = pchan->bone;
1402   int segments = bone->segments;
1403
1404   BLI_assert(segments > 1);
1405
1406   /* Allocate the cache if needed. */
1407   allocate_bbone_cache(pchan, segments);
1408
1409   /* Compute the shape. */
1410   Mat4 *b_bone = runtime->bbone_pose_mats;
1411   Mat4 *b_bone_rest = runtime->bbone_rest_mats;
1412   Mat4 *b_bone_mats = runtime->bbone_deform_mats;
1413   DualQuat *b_bone_dual_quats = runtime->bbone_dual_quats;
1414   int a;
1415
1416   BKE_pchan_bbone_spline_setup(pchan, false, true, b_bone);
1417   BKE_pchan_bbone_spline_setup(pchan, true, true, b_bone_rest);
1418
1419   /* Compute deform matrices. */
1420   /* first matrix is the inverse arm_mat, to bring points in local bone space
1421    * for finding out which segment it belongs to */
1422   invert_m4_m4(b_bone_mats[0].mat, bone->arm_mat);
1423
1424   /* then we make the b_bone_mats:
1425    * - first transform to local bone space
1426    * - translate over the curve to the bbone mat space
1427    * - transform with b_bone matrix
1428    * - transform back into global space */
1429
1430   for (a = 0; a <= bone->segments; a++) {
1431     float tmat[4][4];
1432
1433     invert_m4_m4(tmat, b_bone_rest[a].mat);
1434     mul_m4_series(b_bone_mats[a + 1].mat,
1435                   pchan->chan_mat,
1436                   bone->arm_mat,
1437                   b_bone[a].mat,
1438                   tmat,
1439                   b_bone_mats[0].mat);
1440
1441     mat4_to_dquat(&b_bone_dual_quats[a], bone->arm_mat, b_bone_mats[a + 1].mat);
1442   }
1443 }
1444
1445 /** Copy cached B-Bone segments from one channel to another */
1446 void BKE_pchan_bbone_segments_cache_copy(bPoseChannel *pchan, bPoseChannel *pchan_from)
1447 {
1448   bPoseChannel_Runtime *runtime = &pchan->runtime;
1449   bPoseChannel_Runtime *runtime_from = &pchan_from->runtime;
1450   int segments = runtime_from->bbone_segments;
1451
1452   if (segments <= 1) {
1453     BKE_pose_channel_free_bbone_cache(&pchan->runtime);
1454   }
1455   else {
1456     allocate_bbone_cache(pchan, segments);
1457
1458     memcpy(runtime->bbone_rest_mats, runtime_from->bbone_rest_mats, sizeof(Mat4) * (1 + segments));
1459     memcpy(runtime->bbone_pose_mats, runtime_from->bbone_pose_mats, sizeof(Mat4) * (1 + segments));
1460     memcpy(runtime->bbone_deform_mats,
1461            runtime_from->bbone_deform_mats,
1462            sizeof(Mat4) * (2 + segments));
1463     memcpy(runtime->bbone_dual_quats,
1464            runtime_from->bbone_dual_quats,
1465            sizeof(DualQuat) * (1 + segments));
1466   }
1467 }
1468
1469 /**
1470  * Calculate index and blend factor for the two B-Bone segment nodes
1471  * affecting the point at 0 <= pos <= 1.
1472  */
1473 void BKE_pchan_bbone_deform_segment_index(const bPoseChannel *pchan,
1474                                           float pos,
1475                                           int *r_index,
1476                                           float *r_blend_next)
1477 {
1478   int segments = pchan->bone->segments;
1479
1480   CLAMP(pos, 0.0f, 1.0f);
1481
1482   /* Calculate the indices of the 2 affecting b_bone segments.
1483    * Integer part is the first segment's index.
1484    * Integer part plus 1 is the second segment's index.
1485    * Fractional part is the blend factor. */
1486   float pre_blend = pos * (float)segments;
1487
1488   int index = (int)floorf(pre_blend);
1489   CLAMP(index, 0, segments - 1);
1490
1491   float blend = pre_blend - index;
1492   CLAMP(blend, 0.0f, 1.0f);
1493
1494   *r_index = index;
1495   *r_blend_next = blend;
1496 }
1497
1498 /** \} */
1499
1500 /* -------------------------------------------------------------------- */
1501 /** \name Bone Space to Space Conversion API
1502  * \{ */
1503
1504 void get_objectspace_bone_matrix(struct Bone *bone,
1505                                  float M_accumulatedMatrix[4][4],
1506                                  int UNUSED(root),
1507                                  int UNUSED(posed))
1508 {
1509   copy_m4_m4(M_accumulatedMatrix, bone->arm_mat);
1510 }
1511
1512 /* Convert World-Space Matrix to Pose-Space Matrix */
1513 void BKE_armature_mat_world_to_pose(Object *ob, const float inmat[4][4], float outmat[4][4])
1514 {
1515   float obmat[4][4];
1516
1517   /* prevent crashes */
1518   if (ob == NULL) {
1519     return;
1520   }
1521
1522   /* get inverse of (armature) object's matrix  */
1523   invert_m4_m4(obmat, ob->obmat);
1524
1525   /* multiply given matrix by object's-inverse to find pose-space matrix */
1526   mul_m4_m4m4(outmat, inmat, obmat);
1527 }
1528
1529 /* Convert World-Space Location to Pose-Space Location
1530  * NOTE: this cannot be used to convert to pose-space location of the supplied
1531  *       pose-channel into its local space (i.e. 'visual'-keyframing) */
1532 void BKE_armature_loc_world_to_pose(Object *ob, const float inloc[3], float outloc[3])
1533 {
1534   float xLocMat[4][4];
1535   float nLocMat[4][4];
1536
1537   /* build matrix for location */
1538   unit_m4(xLocMat);
1539   copy_v3_v3(xLocMat[3], inloc);
1540
1541   /* get bone-space cursor matrix and extract location */
1542   BKE_armature_mat_world_to_pose(ob, xLocMat, nLocMat);
1543   copy_v3_v3(outloc, nLocMat[3]);
1544 }
1545
1546 /** \} */
1547
1548 /* -------------------------------------------------------------------- */
1549 /** \name Bone Matrix Calculation API
1550  * \{ */
1551
1552 /* Simple helper, computes the offset bone matrix.
1553  *     offs_bone = yoffs(b-1) + root(b) + bonemat(b). */
1554 void BKE_bone_offset_matrix_get(const Bone *bone, float offs_bone[4][4])
1555 {
1556   BLI_assert(bone->parent != NULL);
1557
1558   /* Bone transform itself. */
1559   copy_m4_m3(offs_bone, bone->bone_mat);
1560
1561   /* The bone's root offset (is in the parent's coordinate system). */
1562   copy_v3_v3(offs_bone[3], bone->head);
1563
1564   /* Get the length translation of parent (length along y axis). */
1565   offs_bone[3][1] += bone->parent->length;
1566 }
1567
1568 /* Construct the matrices (rot/scale and loc)
1569  * to apply the PoseChannels into the armature (object) space.
1570  * I.e. (roughly) the "pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b)" in the
1571  *     pose_mat(b)= pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b) * chan_mat(b)
1572  * ...function.
1573  *
1574  * This allows to get the transformations of a bone in its object space,
1575  * *before* constraints (and IK) get applied (used by pose evaluation code).
1576  * And reverse: to find pchan transformations needed to place a bone at a given loc/rot/scale
1577  * in object space (used by interactive transform, and snapping code).
1578  *
1579  * Note that, with the HINGE/NO_SCALE/NO_LOCAL_LOCATION options, the location matrix
1580  * will differ from the rotation/scale matrix...
1581  *
1582  * NOTE: This cannot be used to convert to pose-space transforms of the supplied
1583  *       pose-channel into its local space (i.e. 'visual'-keyframing).
1584  *       (note: I don't understand that, so I keep it :p --mont29).
1585  */
1586 void BKE_bone_parent_transform_calc_from_pchan(const bPoseChannel *pchan,
1587                                                BoneParentTransform *r_bpt)
1588 {
1589   const Bone *bone, *parbone;
1590   const bPoseChannel *parchan;
1591
1592   /* set up variables for quicker access below */
1593   bone = pchan->bone;
1594   parbone = bone->parent;
1595   parchan = pchan->parent;
1596
1597   if (parchan) {
1598     float offs_bone[4][4];
1599     /* yoffs(b-1) + root(b) + bonemat(b). */
1600     BKE_bone_offset_matrix_get(bone, offs_bone);
1601
1602     BKE_bone_parent_transform_calc_from_matrices(bone->flag,
1603                                                  bone->inherit_scale_mode,
1604                                                  offs_bone,
1605                                                  parbone->arm_mat,
1606                                                  parchan->pose_mat,
1607                                                  r_bpt);
1608   }
1609   else {
1610     BKE_bone_parent_transform_calc_from_matrices(
1611         bone->flag, bone->inherit_scale_mode, bone->arm_mat, NULL, NULL, r_bpt);
1612   }
1613 }
1614
1615 /* Compute the parent transform using data decoupled from specific data structures.
1616  *
1617  * bone_flag: Bone->flag containing settings
1618  * offs_bone: delta from parent to current arm_mat (or just arm_mat if no parent)
1619  * parent_arm_mat, parent_pose_mat: arm_mat and pose_mat of parent, or NULL
1620  * r_bpt: OUTPUT parent transform */
1621 void BKE_bone_parent_transform_calc_from_matrices(int bone_flag,
1622                                                   int inherit_scale_mode,
1623                                                   const float offs_bone[4][4],
1624                                                   const float parent_arm_mat[4][4],
1625                                                   const float parent_pose_mat[4][4],
1626                                                   BoneParentTransform *r_bpt)
1627 {
1628   copy_v3_fl(r_bpt->post_scale, 1.0f);
1629
1630   if (parent_pose_mat) {
1631     const bool use_rotation = (bone_flag & BONE_HINGE) == 0;
1632     const bool full_transform = use_rotation && inherit_scale_mode == BONE_INHERIT_SCALE_FULL;
1633
1634     /* Compose the rotscale matrix for this bone. */
1635     if (full_transform) {
1636       /* Parent pose rotation and scale. */
1637       mul_m4_m4m4(r_bpt->rotscale_mat, parent_pose_mat, offs_bone);
1638     }
1639     else {
1640       float tmat[4][4], tscale[3];
1641
1642       /* If using parent pose rotation: */
1643       if (use_rotation) {
1644         copy_m4_m4(tmat, parent_pose_mat);
1645
1646         /* Normalize the matrix when needed. */
1647         switch (inherit_scale_mode) {
1648           case BONE_INHERIT_SCALE_FULL:
1649           case BONE_INHERIT_SCALE_FIX_SHEAR:
1650             /* Keep scale and shear. */
1651             break;
1652
1653           case BONE_INHERIT_SCALE_NONE:
1654           case BONE_INHERIT_SCALE_AVERAGE:
1655             /* Remove scale and shear from parent. */
1656             orthogonalize_m4_stable(tmat, 1, true);
1657             break;
1658
1659           case BONE_INHERIT_SCALE_ALIGNED:
1660             /* Remove shear and extract scale. */
1661             orthogonalize_m4_stable(tmat, 1, false);
1662             normalize_m4_ex(tmat, r_bpt->post_scale);
1663             break;
1664
1665           case BONE_INHERIT_SCALE_NONE_LEGACY:
1666             /* Remove only scale - bad legacy way. */
1667             normalize_m4(tmat);
1668             break;
1669
1670           default:
1671             BLI_assert(false);
1672         }
1673       }
1674       /* If removing parent pose rotation: */
1675       else {
1676         copy_m4_m4(tmat, parent_arm_mat);
1677
1678         /* Copy the parent scale when needed. */
1679         switch (inherit_scale_mode) {
1680           case BONE_INHERIT_SCALE_FULL:
1681             /* Ignore effects of shear. */
1682             mat4_to_size(tscale, parent_pose_mat);
1683             rescale_m4(tmat, tscale);
1684             break;
1685
1686           case BONE_INHERIT_SCALE_FIX_SHEAR:
1687             /* Take the effects of parent shear into account to get exact volume. */
1688             mat4_to_size_fix_shear(tscale, parent_pose_mat);
1689             rescale_m4(tmat, tscale);
1690             break;
1691
1692           case BONE_INHERIT_SCALE_ALIGNED:
1693             mat4_to_size_fix_shear(r_bpt->post_scale, parent_pose_mat);
1694             break;
1695
1696           case BONE_INHERIT_SCALE_NONE:
1697           case BONE_INHERIT_SCALE_AVERAGE:
1698           case BONE_INHERIT_SCALE_NONE_LEGACY:
1699             /* Keep unscaled. */
1700             break;
1701
1702           default:
1703             BLI_assert(false);
1704         }
1705       }
1706
1707       /* Apply the average parent scale when needed. */
1708       if (inherit_scale_mode == BONE_INHERIT_SCALE_AVERAGE) {
1709         mul_mat3_m4_fl(tmat, cbrtf(fabsf(mat4_to_volume_scale(parent_pose_mat))));
1710       }
1711
1712       mul_m4_m4m4(r_bpt->rotscale_mat, tmat, offs_bone);
1713
1714       /* Remove remaining shear when needed, preserving volume. */
1715       if (inherit_scale_mode == BONE_INHERIT_SCALE_FIX_SHEAR) {
1716         orthogonalize_m4_stable(r_bpt->rotscale_mat, 1, false);
1717       }
1718     }
1719
1720     /* Compose the loc matrix for this bone. */
1721     /* NOTE: That version does not modify bone's loc when HINGE/NO_SCALE options are set. */
1722
1723     /* In this case, use the object's space *orientation*. */
1724     if (bone_flag & BONE_NO_LOCAL_LOCATION) {
1725       /* XXX I'm sure that code can be simplified! */
1726       float bone_loc[4][4], bone_rotscale[3][3], tmat4[4][4], tmat3[3][3];
1727       unit_m4(bone_loc);
1728       unit_m4(r_bpt->loc_mat);
1729       unit_m4(tmat4);
1730
1731       mul_v3_m4v3(bone_loc[3], parent_pose_mat, offs_bone[3]);
1732
1733       unit_m3(bone_rotscale);
1734       copy_m3_m4(tmat3, parent_pose_mat);
1735       mul_m3_m3m3(bone_rotscale, tmat3, bone_rotscale);
1736
1737       copy_m4_m3(tmat4, bone_rotscale);
1738       mul_m4_m4m4(r_bpt->loc_mat, bone_loc, tmat4);
1739     }
1740     /* Those flags do not affect position, use plain parent transform space! */
1741     else if (!full_transform) {
1742       mul_m4_m4m4(r_bpt->loc_mat, parent_pose_mat, offs_bone);
1743     }
1744     /* Else (i.e. default, usual case),
1745      * just use the same matrix for rotation/scaling, and location. */
1746     else {
1747       copy_m4_m4(r_bpt->loc_mat, r_bpt->rotscale_mat);
1748     }
1749   }
1750   /* Root bones. */
1751   else {
1752     /* Rotation/scaling. */
1753     copy_m4_m4(r_bpt->rotscale_mat, offs_bone);
1754     /* Translation. */
1755     if (bone_flag & BONE_NO_LOCAL_LOCATION) {
1756       /* Translation of arm_mat, without the rotation. */
1757       unit_m4(r_bpt->loc_mat);
1758       copy_v3_v3(r_bpt->loc_mat[3], offs_bone[3]);
1759     }
1760     else {
1761       copy_m4_m4(r_bpt->loc_mat, r_bpt->rotscale_mat);
1762     }
1763   }
1764 }
1765
1766 void BKE_bone_parent_transform_clear(struct BoneParentTransform *bpt)
1767 {
1768   unit_m4(bpt->rotscale_mat);
1769   unit_m4(bpt->loc_mat);
1770   copy_v3_fl(bpt->post_scale, 1.0f);
1771 }
1772
1773 void BKE_bone_parent_transform_invert(struct BoneParentTransform *bpt)
1774 {
1775   invert_m4(bpt->rotscale_mat);
1776   invert_m4(bpt->loc_mat);
1777   invert_v3(bpt->post_scale);
1778 }
1779
1780 void BKE_bone_parent_transform_combine(const struct BoneParentTransform *in1,
1781                                        const struct BoneParentTransform *in2,
1782                                        struct BoneParentTransform *result)
1783 {
1784   mul_m4_m4m4(result->rotscale_mat, in1->rotscale_mat, in2->rotscale_mat);
1785   mul_m4_m4m4(result->loc_mat, in1->loc_mat, in2->loc_mat);
1786   mul_v3_v3v3(result->post_scale, in1->post_scale, in2->post_scale);
1787 }
1788
1789 void BKE_bone_parent_transform_apply(const struct BoneParentTransform *bpt,
1790                                      const float inmat[4][4],
1791                                      float outmat[4][4])
1792 {
1793   /* in case inmat == outmat */
1794   float tmploc[3];
1795   copy_v3_v3(tmploc, inmat[3]);
1796
1797   mul_m4_m4m4(outmat, bpt->rotscale_mat, inmat);
1798   mul_v3_m4v3(outmat[3], bpt->loc_mat, tmploc);
1799   rescale_m4(outmat, bpt->post_scale);
1800 }
1801
1802 /* Convert Pose-Space Matrix to Bone-Space Matrix.
1803  * NOTE: this cannot be used to convert to pose-space transforms of the supplied
1804  *       pose-channel into its local space (i.e. 'visual'-keyframing) */
1805 void BKE_armature_mat_pose_to_bone(bPoseChannel *pchan,
1806                                    const float inmat[4][4],
1807                                    float outmat[4][4])
1808 {
1809   BoneParentTransform bpt;
1810
1811   BKE_bone_parent_transform_calc_from_pchan(pchan, &bpt);
1812   BKE_bone_parent_transform_invert(&bpt);
1813   BKE_bone_parent_transform_apply(&bpt, inmat, outmat);
1814 }
1815
1816 /* Convert Bone-Space Matrix to Pose-Space Matrix. */
1817 void BKE_armature_mat_bone_to_pose(bPoseChannel *pchan,
1818                                    const float inmat[4][4],
1819                                    float outmat[4][4])
1820 {
1821   BoneParentTransform bpt;
1822
1823   BKE_bone_parent_transform_calc_from_pchan(pchan, &bpt);
1824   BKE_bone_parent_transform_apply(&bpt, inmat, outmat);
1825 }
1826
1827 /* Convert Pose-Space Location to Bone-Space Location
1828  * NOTE: this cannot be used to convert to pose-space location of the supplied
1829  *       pose-channel into its local space (i.e. 'visual'-keyframing) */
1830 void BKE_armature_loc_pose_to_bone(bPoseChannel *pchan, const float inloc[3], float outloc[3])
1831 {
1832   float xLocMat[4][4];
1833   float nLocMat[4][4];
1834
1835   /* build matrix for location */
1836   unit_m4(xLocMat);
1837   copy_v3_v3(xLocMat[3], inloc);
1838
1839   /* get bone-space cursor matrix and extract location */
1840   BKE_armature_mat_pose_to_bone(pchan, xLocMat, nLocMat);
1841   copy_v3_v3(outloc, nLocMat[3]);
1842 }
1843
1844 /** \} */
1845
1846 /* -------------------------------------------------------------------- */
1847 /** \name Bone Matrix Read/Write API
1848  *
1849  * High level functions for transforming bones and reading the transform values.
1850  * \{ */
1851
1852 void BKE_armature_mat_pose_to_bone_ex(struct Depsgraph *depsgraph,
1853                                       Object *ob,
1854                                       bPoseChannel *pchan,
1855                                       const float inmat[4][4],
1856                                       float outmat[4][4])
1857 {
1858   bPoseChannel work_pchan = *pchan;
1859
1860   /* recalculate pose matrix with only parent transformations,
1861    * bone loc/sca/rot is ignored, scene and frame are not used. */
1862   BKE_pose_where_is_bone(depsgraph, NULL, ob, &work_pchan, 0.0f, false);
1863
1864   /* find the matrix, need to remove the bone transforms first so this is
1865    * calculated as a matrix to set rather then a difference ontop of what's
1866    * already there. */
1867   unit_m4(outmat);
1868   BKE_pchan_apply_mat4(&work_pchan, outmat, false);
1869
1870   BKE_armature_mat_pose_to_bone(&work_pchan, inmat, outmat);
1871 }
1872
1873 /**
1874  * Same as #BKE_object_mat3_to_rot().
1875  */
1876 void BKE_pchan_mat3_to_rot(bPoseChannel *pchan, const float mat[3][3], bool use_compat)
1877 {
1878   BLI_ASSERT_UNIT_M3(mat);
1879
1880   switch (pchan->rotmode) {
1881     case ROT_MODE_QUAT:
1882       mat3_normalized_to_quat(pchan->quat, mat);
1883       break;
1884     case ROT_MODE_AXISANGLE:
1885       mat3_normalized_to_axis_angle(pchan->rotAxis, &pchan->rotAngle, mat);
1886       break;
1887     default: /* euler */
1888       if (use_compat) {
1889         mat3_normalized_to_compatible_eulO(pchan->eul, pchan->eul, pchan->rotmode, mat);
1890       }
1891       else {
1892         mat3_normalized_to_eulO(pchan->eul, pchan->rotmode, mat);
1893       }
1894       break;
1895   }
1896 }
1897
1898 /**
1899  * Same as #BKE_object_rot_to_mat3().
1900  */
1901 void BKE_pchan_rot_to_mat3(const bPoseChannel *pchan, float r_mat[3][3])
1902 {
1903   /* rotations may either be quats, eulers (with various rotation orders), or axis-angle */
1904   if (pchan->rotmode > 0) {
1905     /* euler rotations (will cause gimble lock,
1906      * but this can be alleviated a bit with rotation orders) */
1907     eulO_to_mat3(r_mat, pchan->eul, pchan->rotmode);
1908   }
1909   else if (pchan->rotmode == ROT_MODE_AXISANGLE) {
1910     /* axis-angle - not really that great for 3D-changing orientations */
1911     axis_angle_to_mat3(r_mat, pchan->rotAxis, pchan->rotAngle);
1912   }
1913   else {
1914     /* quats are normalized before use to eliminate scaling issues */
1915     float quat[4];
1916
1917     /* NOTE: we now don't normalize the stored values anymore,
1918      * since this was kindof evil in some cases but if this proves to be too problematic,
1919      * switch back to the old system of operating directly on the stored copy. */
1920     normalize_qt_qt(quat, pchan->quat);
1921     quat_to_mat3(r_mat, quat);
1922   }
1923 }
1924
1925 /**
1926  * Apply a 4x4 matrix to the pose bone,
1927  * similar to #BKE_object_apply_mat4().
1928  */
1929 void BKE_pchan_apply_mat4(bPoseChannel *pchan, const float mat[4][4], bool use_compat)
1930 {
1931   float rot[3][3];
1932   mat4_to_loc_rot_size(pchan->loc, rot, pchan->size, mat);
1933   BKE_pchan_mat3_to_rot(pchan, rot, use_compat);
1934 }
1935
1936 /**
1937  * Remove rest-position effects from pose-transform for obtaining
1938  * 'visual' transformation of pose-channel.
1939  * (used by the Visual-Keyframing stuff).
1940  */
1941 void BKE_armature_mat_pose_to_delta(float delta_mat[4][4],
1942                                     float pose_mat[4][4],
1943                                     float arm_mat[4][4])
1944 {
1945   float imat[4][4];
1946
1947   invert_m4_m4(imat, arm_mat);
1948   mul_m4_m4m4(delta_mat, imat, pose_mat);
1949 }
1950
1951 /** \} */
1952
1953 /* -------------------------------------------------------------------- */
1954 /** \name Rotation Mode Conversions
1955  *
1956  * Used for Objects and Pose Channels, since both can have multiple rotation representations.
1957  * \{ */
1958
1959 /* Called from RNA when rotation mode changes
1960  * - the result should be that the rotations given in the provided pointers have had conversions
1961  *   applied (as appropriate), such that the rotation of the element hasn't 'visually' changed  */
1962 void BKE_rotMode_change_values(
1963     float quat[4], float eul[3], float axis[3], float *angle, short oldMode, short newMode)
1964 {
1965   /* check if any change - if so, need to convert data */
1966   if (newMode > 0) { /* to euler */
1967     if (oldMode == ROT_MODE_AXISANGLE) {
1968       /* axis-angle to euler */
1969       axis_angle_to_eulO(eul, newMode, axis, *angle);
1970     }
1971     else if (oldMode == ROT_MODE_QUAT) {
1972       /* quat to euler */
1973       normalize_qt(quat);
1974       quat_to_eulO(eul, newMode, quat);
1975     }
1976     /* else { no conversion needed } */
1977   }
1978   else if (newMode == ROT_MODE_QUAT) { /* to quat */
1979     if (oldMode == ROT_MODE_AXISANGLE) {
1980       /* axis angle to quat */
1981       axis_angle_to_quat(quat, axis, *angle);
1982     }
1983     else if (oldMode > 0) {
1984       /* euler to quat */
1985       eulO_to_quat(quat, eul, oldMode);
1986     }
1987     /* else { no conversion needed } */
1988   }
1989   else if (newMode == ROT_MODE_AXISANGLE) { /* to axis-angle */
1990     if (oldMode > 0) {
1991       /* euler to axis angle */
1992       eulO_to_axis_angle(axis, angle, eul, oldMode);
1993     }
1994     else if (oldMode == ROT_MODE_QUAT) {
1995       /* quat to axis angle */
1996       normalize_qt(quat);
1997       quat_to_axis_angle(axis, angle, quat);
1998     }
1999
2000     /* When converting to axis-angle,
2001      * we need a special exception for the case when there is no axis. */
2002     if (IS_EQF(axis[0], axis[1]) && IS_EQF(axis[1], axis[2])) {
2003       /* for now, rotate around y-axis then (so that it simply becomes the roll) */
2004       axis[1] = 1.0f;
2005     }
2006   }
2007 }
2008
2009 /** \} */
2010
2011 /* -------------------------------------------------------------------- */
2012 /** \name Bone Vector, Roll Conversion
2013  *
2014  * Used for Objects and Pose Channels, since both can have multiple rotation representations.
2015  *
2016  * How it Works
2017  * ============
2018  *
2019  * This is the bone transformation trick; they're hierarchical so each bone(b)
2020  * is in the coord system of bone(b-1):
2021  *
2022  * arm_mat(b)= arm_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b)
2023  *
2024  * -> yoffs is just the y axis translation in parent's coord system
2025  * -> d_root is the translation of the bone root, also in parent's coord system
2026  *
2027  * pose_mat(b)= pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b) * chan_mat(b)
2028  *
2029  * we then - in init deform - store the deform in chan_mat, such that:
2030  *
2031  * pose_mat(b)= arm_mat(b) * chan_mat(b)
2032  *
2033  * \{ */
2034
2035 /* Computes vector and roll based on a rotation.
2036  * "mat" must contain only a rotation, and no scaling. */
2037 void mat3_to_vec_roll(const float mat[3][3], float r_vec[3], float *r_roll)
2038 {
2039   if (r_vec) {
2040     copy_v3_v3(r_vec, mat[1]);
2041   }
2042
2043   if (r_roll) {
2044     mat3_vec_to_roll(mat, mat[1], r_roll);
2045   }
2046 }
2047
2048 /* Computes roll around the vector that best approximates the matrix.
2049  * If vec is the Y vector from purely rotational mat, result should be exact. */
2050 void mat3_vec_to_roll(const float mat[3][3], const float vec[3], float *r_roll)
2051 {
2052   float vecmat[3][3], vecmatinv[3][3], rollmat[3][3], q[4];
2053
2054   /* Compute the orientation relative to the vector with zero roll. */
2055   vec_roll_to_mat3(vec, 0.0f, vecmat);
2056   invert_m3_m3(vecmatinv, vecmat);
2057   mul_m3_m3m3(rollmat, vecmatinv, mat);
2058
2059   /* Extract the twist angle as the roll value. */
2060   mat3_to_quat(q, rollmat);
2061
2062   *r_roll = quat_split_swing_and_twist(q, 1, NULL, NULL);
2063 }
2064
2065 /* Calculates the rest matrix of a bone based on its vector and a roll around that vector. */
2066 /**
2067  * Given `v = (v.x, v.y, v.z)` our (normalized) bone vector, we want the rotation matrix M
2068  * from the Y axis (so that `M * (0, 1, 0) = v`).
2069  * - The rotation axis a lays on XZ plane, and it is orthonormal to v,
2070  *   hence to the projection of v onto XZ plane.
2071  * - `a = (v.z, 0, -v.x)`
2072  *
2073  * We know a is eigenvector of M (so M * a = a).
2074  * Finally, we have w, such that M * w = (0, 1, 0)
2075  * (i.e. the vector that will be aligned with Y axis once transformed).
2076  * We know w is symmetric to v by the Y axis.
2077  * - `w = (-v.x, v.y, -v.z)`
2078  *
2079  * Solving this, we get (x, y and z being the components of v):
2080  * <pre>
2081  *     ┌ (x^2 * y + z^2) / (x^2 + z^2),   x,   x * z * (y - 1) / (x^2 + z^2) ┐
2082  * M = │  x * (y^2 - 1)  / (x^2 + z^2),   y,    z * (y^2 - 1)  / (x^2 + z^2) │
2083  *     └ x * z * (y - 1) / (x^2 + z^2),   z,   (x^2 + z^2 * y) / (x^2 + z^2) ┘
2084  * </pre>
2085  *
2086  * This is stable as long as v (the bone) is not too much aligned with +/-Y
2087  * (i.e. x and z components are not too close to 0).
2088  *
2089  * Since v is normalized, we have `x^2 + y^2 + z^2 = 1`,
2090  * hence `x^2 + z^2 = 1 - y^2 = (1 - y)(1 + y)`.
2091  *
2092  * This allows to simplifies M like this:
2093  * <pre>
2094  *     ┌ 1 - x^2 / (1 + y),   x,     -x * z / (1 + y) ┐
2095  * M = │                -x,   y,                   -z │
2096  *     └  -x * z / (1 + y),   z,    1 - z^2 / (1 + y) ┘
2097  * </pre>
2098  *
2099  * Written this way, we see the case v = +Y is no more a singularity.
2100  * The only one
2101  * remaining is the bone being aligned with -Y.
2102  *
2103  * Let's handle
2104  * the asymptotic behavior when bone vector is reaching the limit of y = -1.
2105  * Each of the four corner elements can vary from -1 to 1,
2106  * depending on the axis a chosen for doing the rotation.
2107  * And the "rotation" here is in fact established by mirroring XZ plane by that given axis,
2108  * then inversing the Y-axis.
2109  * For sufficiently small x and z, and with y approaching -1,
2110  * all elements but the four corner ones of M will degenerate.
2111  * So let's now focus on these corner elements.
2112  *
2113  * We rewrite M so that it only contains its four corner elements,
2114  * and combine the `1 / (1 + y)` factor:
2115  * <pre>
2116  *                    ┌ 1 + y - x^2,        -x * z ┐
2117  * M* = 1 / (1 + y) * │                            │
2118  *                    └      -x * z,   1 + y - z^2 ┘
2119  * </pre>
2120  *
2121  * When y is close to -1, computing 1 / (1 + y) will cause severe numerical instability,
2122  * so we ignore it and normalize M instead.
2123  * We know `y^2 = 1 - (x^2 + z^2)`, and `y < 0`, hence `y = -sqrt(1 - (x^2 + z^2))`.
2124  *
2125  * Since x and z are both close to 0, we apply the binomial expansion to the first order:
2126  * `y = -sqrt(1 - (x^2 + z^2)) = -1 + (x^2 + z^2) / 2`. Which gives:
2127  * <pre>
2128  *                        ┌  z^2 - x^2,  -2 * x * z ┐
2129  * M* = 1 / (x^2 + z^2) * │                         │
2130  *                        └ -2 * x * z,   x^2 - z^2 ┘
2131  * </pre>
2132  */
2133 void vec_roll_to_mat3_normalized(const float nor[3], const float roll, float r_mat[3][3])
2134 {
2135 #define THETA_THRESHOLD_NEGY 1.0e-9f
2136 #define THETA_THRESHOLD_NEGY_CLOSE 1.0e-5f
2137
2138   float theta;
2139   float rMatrix[3][3], bMatrix[3][3];
2140
2141   BLI_ASSERT_UNIT_V3(nor);
2142
2143   theta = 1.0f + nor[1];
2144
2145   /* With old algo, 1.0e-13f caused T23954 and T31333, 1.0e-6f caused T27675 and T30438,
2146    * so using 1.0e-9f as best compromise.
2147    *
2148    * New algo is supposed much more precise, since less complex computations are performed,
2149    * but it uses two different threshold values...
2150    *
2151    * Note: When theta is close to zero, we have to check we do have non-null X/Z components as well
2152    *       (due to float precision errors, we can have nor = (0.0, 0.99999994, 0.0)...).
2153    */
2154   if (theta > THETA_THRESHOLD_NEGY_CLOSE || ((nor[0] || nor[2]) && theta > THETA_THRESHOLD_NEGY)) {
2155     /* nor is *not* -Y.
2156      * We got these values for free... so be happy with it... ;)
2157      */
2158     bMatrix[0][1] = -nor[0];
2159     bMatrix[1][0] = nor[0];
2160     bMatrix[1][1] = nor[1];
2161     bMatrix[1][2] = nor[2];
2162     bMatrix[2][1] = -nor[2];
2163     if (theta > THETA_THRESHOLD_NEGY_CLOSE) {
2164       /* If nor is far enough from -Y, apply the general case. */
2165       bMatrix[0][0] = 1 - nor[0] * nor[0] / theta;
2166       bMatrix[2][2] = 1 - nor[2] * nor[2] / theta;
2167       bMatrix[2][0] = bMatrix[0][2] = -nor[0] * nor[2] / theta;
2168     }
2169     else {
2170       /* If nor is too close to -Y, apply the special case. */
2171       theta = nor[0] * nor[0] + nor[2] * nor[2];
2172       bMatrix[0][0] = (nor[0] + nor[2]) * (nor[0] - nor[2]) / -theta;
2173       bMatrix[2][2] = -bMatrix[0][0];
2174       bMatrix[2][0] = bMatrix[0][2] = 2.0f * nor[0] * nor[2] / theta;
2175     }
2176   }
2177   else {
2178     /* If nor is -Y, simple symmetry by Z axis. */
2179     unit_m3(bMatrix);
2180     bMatrix[0][0] = bMatrix[1][1] = -1.0;
2181   }
2182
2183   /* Make Roll matrix */
2184   axis_angle_normalized_to_mat3(rMatrix, nor, roll);
2185
2186   /* Combine and output result */
2187   mul_m3_m3m3(r_mat, rMatrix, bMatrix);
2188
2189 #undef THETA_THRESHOLD_NEGY
2190 #undef THETA_THRESHOLD_NEGY_CLOSE
2191 }
2192
2193 void vec_roll_to_mat3(const float vec[3], const float roll, float r_mat[3][3])
2194 {
2195   float nor[3];
2196
2197   normalize_v3_v3(nor, vec);
2198   vec_roll_to_mat3_normalized(nor, roll, r_mat);
2199 }
2200
2201 /** \} */
2202
2203 /* -------------------------------------------------------------------- */
2204 /** \name Armature Bone Matrix Calculation (Recursive)
2205  * \{ */
2206
2207 /**
2208  * Recursive part, calculates rest-position of entire tree of children.
2209  * \note Used when exiting edit-mode too.
2210  */
2211 void BKE_armature_where_is_bone(Bone *bone, const Bone *bone_parent, const bool use_recursion)
2212 {
2213   float vec[3];
2214
2215   /* Bone Space */
2216   sub_v3_v3v3(vec, bone->tail, bone->head);
2217   bone->length = len_v3(vec);
2218   vec_roll_to_mat3(vec, bone->roll, bone->bone_mat);
2219
2220   /* this is called on old file reading too... */
2221   if (bone->xwidth == 0.0f) {
2222     bone->xwidth = 0.1f;
2223     bone->zwidth = 0.1f;
2224     bone->segments = 1;
2225   }
2226
2227   if (bone_parent) {
2228     float offs_bone[4][4];
2229     /* yoffs(b-1) + root(b) + bonemat(b) */
2230     BKE_bone_offset_matrix_get(bone, offs_bone);
2231
2232     /* Compose the matrix for this bone  */
2233     mul_m4_m4m4(bone->arm_mat, bone_parent->arm_mat, offs_bone);
2234   }
2235   else {
2236     copy_m4_m3(bone->arm_mat, bone->bone_mat);
2237     copy_v3_v3(bone->arm_mat[3], bone->head);
2238   }
2239
2240   /* and the kiddies */
2241   if (use_recursion) {
2242     bone_parent = bone;
2243     for (bone = bone->childbase.first; bone; bone = bone->next) {
2244       BKE_armature_where_is_bone(bone, bone_parent, use_recursion);
2245     }
2246   }
2247 }
2248
2249 /* updates vectors and matrices on rest-position level, only needed
2250  * after editing armature itself, now only on reading file */
2251 void BKE_armature_where_is(bArmature *arm)
2252 {
2253   Bone *bone;
2254
2255   /* hierarchical from root to children */
2256   for (bone = arm->bonebase.first; bone; bone = bone->next) {
2257     BKE_armature_where_is_bone(bone, NULL, true);
2258   }
2259 }
2260
2261 /** \} */
2262
2263 /* -------------------------------------------------------------------- */
2264 /** \name Pose Rebuild
2265  * \{ */
2266
2267 /* if bone layer is protected, copy the data from from->pose
2268  * when used with linked libraries this copies from the linked pose into the local pose */
2269 static void pose_proxy_sync(Object *ob, Object *from, int layer_protected)
2270 {
2271   bPose *pose = ob->pose, *frompose = from->pose;
2272   bPoseChannel *pchan, *pchanp;
2273   bConstraint *con;
2274   int error = 0;
2275
2276   if (frompose == NULL) {
2277     return;
2278   }
2279
2280   /* in some cases when rigs change, we cant synchronize
2281    * to avoid crashing check for possible errors here */
2282   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
2283     if (pchan->bone->layer & layer_protected) {
2284       if (BKE_pose_channel_find_name(frompose, pchan->name) == NULL) {
2285         CLOG_ERROR(&LOG,
2286                    "failed to sync proxy armature because '%s' is missing pose channel '%s'",
2287                    from->id.name,
2288                    pchan->name);
2289         error = 1;
2290       }
2291     }
2292   }
2293
2294   if (error) {
2295     return;
2296   }
2297
2298   /* clear all transformation values from library */
2299   BKE_pose_rest(frompose, false);
2300
2301   /* copy over all of the proxy's bone groups */
2302   /* TODO for later
2303    * - implement 'local' bone groups as for constraints
2304    * Note: this isn't trivial, as bones reference groups by index not by pointer,
2305    *       so syncing things correctly needs careful attention */
2306   BLI_freelistN(&pose->agroups);
2307   BLI_duplicatelist(&pose->agroups, &frompose->agroups);
2308   pose->active_group = frompose->active_group;
2309
2310   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
2311     pchanp = BKE_pose_channel_find_name(frompose, pchan->name);
2312
2313     if (UNLIKELY(pchanp == NULL)) {
2314       /* happens for proxies that become invalid because of a missing link
2315        * for regular cases it shouldn't happen at all */
2316     }
2317     else if (pchan->bone->layer & layer_protected) {
2318       ListBase proxylocal_constraints = {NULL, NULL};
2319       bPoseChannel pchanw;
2320
2321       /* copy posechannel to temp, but restore important pointers */
2322       pchanw = *pchanp;
2323       pchanw.bone = pchan->bone;
2324       pchanw.prev = pchan->prev;
2325       pchanw.next = pchan->next;
2326       pchanw.parent = pchan->parent;
2327       pchanw.child = pchan->child;
2328       pchanw.custom_tx = pchan->custom_tx;
2329       pchanw.bbone_prev = pchan->bbone_prev;
2330       pchanw.bbone_next = pchan->bbone_next;
2331
2332       pchanw.mpath = pchan->mpath;
2333       pchan->mpath = NULL;
2334
2335       /* Reset runtime data, we don't want to share that with the proxy. */
2336       BKE_pose_channel_runtime_reset_on_copy(&pchanw.runtime);
2337
2338       /* this is freed so copy a copy, else undo crashes */
2339       if (pchanw.prop) {
2340         pchanw.prop = IDP_CopyProperty(pchanw.prop);
2341
2342         /* use the values from the existing props */
2343         if (pchan->prop) {
2344           IDP_SyncGroupValues(pchanw.prop, pchan->prop);
2345         }
2346       }
2347
2348       /* Constraints - proxy constraints are flushed... local ones are added after
2349        * 1: extract constraints not from proxy (CONSTRAINT_PROXY_LOCAL) from pchan's constraints.
2350        * 2: copy proxy-pchan's constraints on-to new.
2351        * 3: add extracted local constraints back on top.
2352        *
2353        * Note for BKE_constraints_copy:
2354        * When copying constraints, disable 'do_extern' otherwise
2355        * we get the libs direct linked in this blend.
2356        */
2357       BKE_constraints_proxylocal_extract(&proxylocal_constraints, &pchan->constraints);
2358       BKE_constraints_copy(&pchanw.constraints, &pchanp->constraints, false);
2359       BLI_movelisttolist(&pchanw.constraints, &proxylocal_constraints);
2360
2361       /* constraints - set target ob pointer to own object */
2362       for (con = pchanw.constraints.first; con; con = con->next) {
2363         const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
2364         ListBase targets = {NULL, NULL};
2365         bConstraintTarget *ct;
2366
2367         if (cti && cti->get_constraint_targets) {
2368           cti->get_constraint_targets(con, &targets);
2369
2370           for (ct = targets.first; ct; ct = ct->next) {
2371             if (ct->tar == from) {
2372               ct->tar = ob;
2373             }
2374           }
2375
2376           if (cti->flush_constraint_targets) {
2377             cti->flush_constraint_targets(con, &targets, 0);
2378           }
2379         }
2380       }
2381
2382       /* free stuff from current channel */
2383       BKE_pose_channel_free(pchan);
2384
2385       /* copy data in temp back over to the cleaned-out (but still allocated) original channel */
2386       *pchan = pchanw;
2387       if (pchan->custom) {
2388         id_us_plus(&pchan->custom->id);
2389       }
2390     }
2391     else {
2392       /* always copy custom shape */
2393       pchan->custom = pchanp->custom;
2394       if (pchan->custom) {
2395         id_us_plus(&pchan->custom->id);
2396       }
2397       if (pchanp->custom_tx) {
2398         pchan->custom_tx = BKE_pose_channel_find_name(pose, pchanp->custom_tx->name);
2399       }
2400
2401       /* ID-Property Syncing */
2402       {
2403         IDProperty *prop_orig = pchan->prop;
2404         if (pchanp->prop) {
2405           pchan->prop = IDP_CopyProperty(pchanp->prop);
2406           if (prop_orig) {
2407             /* copy existing values across when types match */
2408             IDP_SyncGroupValues(pchan->prop, prop_orig);
2409           }
2410         }
2411         else {
2412           pchan->prop = NULL;
2413         }
2414         if (prop_orig) {
2415           IDP_FreeProperty(prop_orig);
2416         }
2417       }
2418     }
2419   }
2420 }
2421
2422 static int rebuild_pose_bone(bPose *pose, Bone *bone, bPoseChannel *parchan, int counter)
2423 {
2424   bPoseChannel *pchan = BKE_pose_channel_verify(pose, bone->name); /* verify checks and/or adds */
2425
2426   pchan->bone = bone;
2427   pchan->parent = parchan;
2428
2429   counter++;
2430
2431   for (bone = bone->childbase.first; bone; bone = bone->next) {
2432     counter = rebuild_pose_bone(pose, bone, pchan, counter);
2433     /* for quick detecting of next bone in chain, only b-bone uses it now */
2434     if (bone->flag & BONE_CONNECTED) {
2435       pchan->child = BKE_pose_channel_find_name(pose, bone->name);
2436     }
2437   }
2438
2439   return counter;
2440 }
2441
2442 /**
2443  * Clear pointers of object's pose
2444  * (needed in remap case, since we cannot always wait for a complete pose rebuild).
2445  */
2446 void BKE_pose_clear_pointers(bPose *pose)
2447 {
2448   LISTBASE_FOREACH (bPoseChannel *, pchan, &pose->chanbase) {
2449     pchan->bone = NULL;
2450     pchan->child = NULL;
2451   }
2452 }
2453
2454 void BKE_pose_remap_bone_pointers(bArmature *armature, bPose *pose)
2455 {
2456   LISTBASE_FOREACH (bPoseChannel *, pchan, &pose->chanbase) {
2457     pchan->bone = BKE_armature_find_bone_name(armature, pchan->name);
2458   }
2459 }
2460
2461 /** Find the matching pose channel using the bone name, if not NULL. */
2462 static bPoseChannel *pose_channel_find_bone(bPose *pose, Bone *bone)
2463 {
2464   return (bone != NULL) ? BKE_pose_channel_find_name(pose, bone->name) : NULL;
2465 }
2466
2467 /** Update the links for the B-Bone handles from Bone data. */
2468 void BKE_pchan_rebuild_bbone_handles(bPose *pose, bPoseChannel *pchan)
2469 {
2470   pchan->bbone_prev = pose_channel_find_bone(pose, pchan->bone->bbone_prev);
2471   pchan->bbone_next = pose_channel_find_bone(pose, pchan->bone->bbone_next);
2472 }
2473
2474 /**
2475  * Only after leave editmode, duplicating, validating older files, library syncing.
2476  *
2477  * \note pose->flag is set for it.
2478  *
2479  * \param bmain: May be NULL, only used to tag depsgraph as being dirty...
2480  */
2481 void BKE_pose_rebuild(Main *bmain, Object *ob, bArmature *arm, const bool do_id_user)
2482 {
2483   Bone *bone;
2484   bPose *pose;
2485   bPoseChannel *pchan, *next;
2486   int counter = 0;
2487
2488   /* only done here */
2489   if (ob->pose == NULL) {
2490     /* create new pose */
2491     ob->pose = MEM_callocN(sizeof(bPose), "new pose");
2492
2493     /* set default settings for animviz */
2494     animviz_settings_init(&ob->pose->avs);
2495   }
2496   pose = ob->pose;
2497
2498   /* clear */
2499   BKE_pose_clear_pointers(pose);
2500
2501   /* first step, check if all channels are there */
2502   for (bone = arm->bonebase.first; bone; bone = bone->next) {
2503     counter = rebuild_pose_bone(pose, bone, NULL, counter);
2504   }
2505
2506   /* and a check for garbage */
2507   for (pchan = pose->chanbase.first; pchan; pchan = next) {
2508     next = pchan->next;
2509     if (pchan->bone == NULL) {
2510       BKE_pose_channel_free_ex(pchan, do_id_user);
2511       BKE_pose_channels_hash_free(pose);
2512       BLI_freelinkN(&pose->chanbase, pchan);
2513     }
2514   }
2515
2516   BKE_pose_channels_hash_make(pose);
2517
2518   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
2519     /* Find the custom B-Bone handles. */
2520     BKE_pchan_rebuild_bbone_handles(pose, pchan);
2521   }
2522
2523   /* printf("rebuild pose %s, %d bones\n", ob->id.name, counter); */
2524
2525   /* synchronize protected layers with proxy */
2526   /* HACK! To preserve 2.7x behavior that you always can pose even locked bones,
2527    * do not do any restoration if this is a COW temp copy! */
2528   /* Switched back to just NO_MAIN tag, for some reasons (c)
2529    * using COW tag was working this morning, but not anymore... */
2530   if (ob->proxy != NULL && (ob->id.tag & LIB_TAG_NO_MAIN) == 0) {
2531     BKE_object_copy_proxy_drivers(ob, ob->proxy);
2532     pose_proxy_sync(ob, ob->proxy, arm->layer_protected);
2533   }
2534
2535   BKE_pose_update_constraint_flags(pose); /* for IK detection for example */
2536
2537   pose->flag &= ~POSE_RECALC;
2538   pose->flag |= POSE_WAS_REBUILT;
2539
2540   /* Rebuilding poses forces us to also rebuild the dependency graph,
2541    * since there is one node per pose/bone. */
2542   if (bmain != NULL) {
2543     DEG_relations_tag_update(bmain);
2544   }
2545 }
2546
2547 /** \} */
2548
2549 /* -------------------------------------------------------------------- */
2550 /** \name Pose Solver
2551  * \{ */
2552
2553 /**
2554  * Convert the loc/rot/size to \a r_chanmat (typically #bPoseChannel.chan_mat).
2555  */
2556 void BKE_pchan_to_mat4(const bPoseChannel *pchan, float r_chanmat[4][4])
2557 {
2558   float smat[3][3];
2559   float rmat[3][3];
2560   float tmat[3][3];
2561
2562   /* get scaling matrix */
2563   size_to_mat3(smat, pchan->size);
2564
2565   /* get rotation matrix */
2566   BKE_pchan_rot_to_mat3(pchan, rmat);
2567
2568   /* calculate matrix of bone (as 3x3 matrix, but then copy the 4x4) */
2569   mul_m3_m3m3(tmat, rmat, smat);
2570   copy_m4_m3(r_chanmat, tmat);
2571
2572   /* prevent action channels breaking chains */
2573   /* need to check for bone here, CONSTRAINT_TYPE_ACTION uses this call */
2574   if ((pchan->bone == NULL) || !(pchan->bone->flag & BONE_CONNECTED)) {
2575     copy_v3_v3(r_chanmat[3], pchan->loc);
2576   }
2577 }
2578
2579 /* loc/rot/size to mat4 */
2580 /* used in constraint.c too */
2581 void BKE_pchan_calc_mat(bPoseChannel *pchan)
2582 {
2583   /* this is just a wrapper around the copy of this function which calculates the matrix
2584    * and stores the result in any given channel
2585    */
2586   BKE_pchan_to_mat4(pchan, pchan->chan_mat);
2587 }
2588
2589 /* calculate tail of posechannel */
2590 void BKE_pose_where_is_bone_tail(bPoseChannel *pchan)
2591 {
2592   float vec[3];
2593
2594   copy_v3_v3(vec, pchan->pose_mat[1]);
2595   mul_v3_fl(vec, pchan->bone->length);
2596   add_v3_v3v3(pchan->pose_tail, pchan->pose_head, vec);
2597 }
2598
2599 /* The main armature solver, does all constraints excluding IK */
2600 /* pchan is validated, as having bone and parent pointer
2601  * 'do_extra': when zero skips loc/size/rot, constraints and strip modifiers.
2602  */
2603 void BKE_pose_where_is_bone(struct Depsgraph *depsgraph,
2604                             Scene *scene,
2605                             Object *ob,
2606                             bPoseChannel *pchan,
2607                             float ctime,
2608                             bool do_extra)
2609 {
2610   /* This gives a chan_mat with actions (ipos) results. */
2611   if (do_extra) {
2612     BKE_pchan_calc_mat(pchan);
2613   }
2614   else {
2615     unit_m4(pchan->chan_mat);
2616   }
2617
2618   /* Construct the posemat based on PoseChannels, that we do before applying constraints. */
2619   /* pose_mat(b) = pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b) * chan_mat(b) */
2620   BKE_armature_mat_bone_to_pose(pchan, pchan->chan_mat, pchan->pose_mat);
2621
2622   /* Only rootbones get the cyclic offset (unless user doesn't want that). */
2623   /* XXX That could be a problem for snapping and other "reverse transform" features... */
2624   if (!pchan->parent) {
2625     if ((pchan->bone->flag & BONE_NO_CYCLICOFFSET) == 0) {
2626       add_v3_v3(pchan->pose_mat[3], ob->pose->cyclic_offset);
2627     }
2628   }
2629
2630   if (do_extra) {
2631     /* Do constraints */
2632     if (pchan->constraints.first) {
2633       bConstraintOb *cob;
2634       float vec[3];
2635
2636       /* make a copy of location of PoseChannel for later */
2637       copy_v3_v3(vec, pchan->pose_mat[3]);
2638
2639       /* prepare PoseChannel for Constraint solving
2640        * - makes a copy of matrix, and creates temporary struct to use
2641        */
2642       cob = BKE_constraints_make_evalob(depsgraph, scene, ob, pchan, CONSTRAINT_OBTYPE_BONE);
2643
2644       /* Solve PoseChannel's Constraints */
2645
2646       /* ctime doesn't alter objects. */
2647       BKE_constraints_solve(depsgraph, &pchan->constraints, cob, ctime);
2648
2649       /* cleanup after Constraint Solving
2650        * - applies matrix back to pchan, and frees temporary struct used
2651        */
2652       BKE_constraints_clear_evalob(cob);
2653
2654       /* prevent constraints breaking a chain */
2655       if (pchan->bone->flag & BONE_CONNECTED) {
2656         copy_v3_v3(pchan->pose_mat[3], vec);
2657       }
2658     }
2659   }
2660
2661   /* calculate head */
2662   copy_v3_v3(pchan->pose_head, pchan->pose_mat[3]);
2663   /* calculate tail */
2664   BKE_pose_where_is_bone_tail(pchan);
2665 }
2666
2667 /* This only reads anim data from channels, and writes to channels */
2668 /* This is the only function adding poses */
2669 void BKE_pose_where_is(struct Depsgraph *depsgraph, Scene *scene, Object *ob)
2670 {
2671   bArmature *arm;
2672   Bone *bone;
2673   bPoseChannel *pchan;
2674   float imat[4][4];
2675   float ctime;
2676
2677   if (ob->type != OB_ARMATURE) {
2678     return;
2679   }
2680   arm = ob->data;
2681
2682   if (ELEM(NULL, arm, scene)) {
2683     return;
2684   }
2685   if ((ob->pose == NULL) || (ob->pose->flag & POSE_RECALC)) {
2686     /* WARNING! passing NULL bmain here means we won't tag depsgraph's as dirty -
2687      * hopefully this is OK. */
2688     BKE_pose_rebuild(NULL, ob, arm, true);
2689   }
2690
2691   ctime = BKE_scene_frame_get(scene); /* not accurate... */
2692
2693   /* In edit-mode or rest-position we read the data from the bones. */
2694   if (arm->edbo || (arm->flag & ARM_RESTPOS)) {
2695     for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2696       bone = pchan->bone;
2697       if (bone) {
2698         copy_m4_m4(pchan->pose_mat, bone->arm_mat);
2699         copy_v3_v3(pchan->pose_head, bone->arm_head);
2700         copy_v3_v3(pchan->pose_tail, bone->arm_tail);
2701       }
2702     }
2703   }
2704   else {
2705     invert_m4_m4(ob->imat, ob->obmat); /* imat is needed */
2706
2707     /* 1. clear flags */
2708     for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2709       pchan->flag &= ~(POSE_DONE | POSE_CHAIN | POSE_IKTREE | POSE_IKSPLINE);
2710     }
2711
2712     /* 2a. construct the IK tree (standard IK) */
2713     BIK_init_tree(depsgraph, scene, ob, ctime);
2714
2715     /* 2b. construct the Spline IK trees
2716      * - this is not integrated as an IK plugin, since it should be able
2717      *   to function in conjunction with standard IK
2718      */
2719     BKE_pose_splineik_init_tree(scene, ob, ctime);
2720
2721     /* 3. the main loop, channels are already hierarchical sorted from root to children */
2722     for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2723       /* 4a. if we find an IK root, we handle it separated */
2724       if (pchan->flag & POSE_IKTREE) {
2725         BIK_execute_tree(depsgraph, scene, ob, pchan, ctime);
2726       }
2727       /* 4b. if we find a Spline IK root, we handle it separated too */
2728       else if (pchan->flag & POSE_IKSPLINE) {
2729         BKE_splineik_execute_tree(depsgraph, scene, ob, pchan, ctime);
2730       }
2731       /* 5. otherwise just call the normal solver */
2732       else if (!(pchan->flag & POSE_DONE)) {
2733         BKE_pose_where_is_bone(depsgraph, scene, ob, pchan, ctime, 1);
2734       }
2735     }
2736     /* 6. release the IK tree */
2737     BIK_release_tree(scene, ob, ctime);
2738   }
2739
2740   /* calculating deform matrices */
2741   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2742     if (pchan->bone) {
2743       invert_m4_m4(imat, pchan->bone->arm_mat);
2744       mul_m4_m4m4(pchan->chan_mat, pchan->pose_mat, imat);
2745     }
2746   }
2747 }
2748
2749 /** \} */
2750
2751 /* -------------------------------------------------------------------- */
2752 /** \name Calculate Bounding Box (Armature & Pose)
2753  * \{ */
2754
2755 static int minmax_armature(Object *ob, float r_min[3], float r_max[3])
2756 {
2757   bPoseChannel *pchan;
2758
2759   /* For now, we assume BKE_pose_where_is has already been called
2760    * (hence we have valid data in pachan). */
2761   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2762     minmax_v3v3_v3(r_min, r_max, pchan->pose_head);
2763     minmax_v3v3_v3(r_min, r_max, pchan->pose_tail);
2764   }
2765
2766   return (BLI_listbase_is_empty(&ob->pose->chanbase) == false);
2767 }
2768
2769 static void boundbox_armature(Object *ob)
2770 {
2771   BoundBox *bb;
2772   float min[3], max[3];
2773
2774   if (ob->runtime.bb == NULL) {
2775     ob->runtime.bb = MEM_callocN(sizeof(BoundBox), "Armature boundbox");
2776   }
2777   bb = ob->runtime.bb;
2778
2779   INIT_MINMAX(min, max);
2780   if (!minmax_armature(ob, min, max)) {
2781     min[0] = min[1] = min[2] = -1.0f;
2782     max[0] = max[1] = max[2] = 1.0f;
2783   }
2784
2785   BKE_boundbox_init_from_minmax(bb, min, max);
2786
2787   bb->flag &= ~BOUNDBOX_DIRTY;
2788 }
2789
2790 BoundBox *BKE_armature_boundbox_get(Object *ob)
2791 {
2792   boundbox_armature(ob);
2793
2794   return ob->runtime.bb;
2795 }
2796
2797 bool BKE_pose_minmax(Object *ob, float r_min[3], float r_max[3], bool use_hidden, bool use_select)
2798 {
2799   bool changed = false;
2800
2801   if (ob->pose) {
2802     bArmature *arm = ob->data;
2803     bPoseChannel *pchan;
2804
2805     for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2806       /* XXX pchan->bone may be NULL for duplicated bones, see duplicateEditBoneObjects() comment
2807        *     (editarmature.c:2592)... Skip in this case too! */
2808       if (pchan->bone && (!((use_hidden == false) && (PBONE_VISIBLE(arm, pchan->bone) == false)) &&
2809                           !((use_select == true) && ((pchan->bone->flag & BONE_SELECTED) == 0)))) {
2810         bPoseChannel *pchan_tx = (pchan->custom && pchan->custom_tx) ? pchan->custom_tx : pchan;
2811         BoundBox *bb_custom = ((pchan->custom) && !(arm->flag & ARM_NO_CUSTOM)) ?
2812                                   BKE_object_boundbox_get(pchan->custom) :
2813                                   NULL;
2814         if (bb_custom) {
2815           float mat[4][4], smat[4][4];
2816           scale_m4_fl(smat, PCHAN_CUSTOM_DRAW_SIZE(pchan));
2817           mul_m4_series(mat, ob->obmat, pchan_tx->pose_mat, smat);
2818           BKE_boundbox_minmax(bb_custom, mat, r_min, r_max);
2819         }
2820         else {
2821           float vec[3];
2822           mul_v3_m4v3(vec, ob->obmat, pchan_tx->pose_head);
2823           minmax_v3v3_v3(r_min, r_max, vec);
2824           mul_v3_m4v3(vec, ob->obmat, pchan_tx->pose_tail);
2825           minmax_v3v3_v3(r_min, r_max, vec);
2826         }
2827
2828         changed = true;
2829       }
2830     }
2831   }
2832
2833   return changed;
2834 }
2835
2836 /** \} */
2837
2838 /* -------------------------------------------------------------------- */
2839 /** \name Graph Evaluation
2840  * \{ */
2841
2842 bPoseChannel *BKE_armature_ik_solver_find_root(bPoseChannel *pchan, bKinematicConstraint *data)
2843 {
2844   bPoseChannel *rootchan = pchan;
2845   if (!(data->flag & CONSTRAINT_IK_TIP)) {
2846     /* Exclude tip from chain. */
2847     rootchan = rootchan->parent;
2848   }
2849   if (rootchan != NULL) {
2850     int segcount = 0;
2851     while (rootchan->parent) {
2852       /* Continue up chain, until we reach target number of items. */
2853       segcount++;
2854       if (segcount == data->rootbone) {
2855         break;
2856       }
2857       rootchan = rootchan->parent;
2858     }
2859   }
2860   return rootchan;
2861 }
2862
2863 bPoseChannel *BKE_armature_splineik_solver_find_root(bPoseChannel *pchan,
2864                                                      bSplineIKConstraint *data)
2865 {
2866   bPoseChannel *rootchan = pchan;
2867   int segcount = 0;
2868   BLI_assert(rootchan != NULL);
2869   while (rootchan->parent) {
2870     /* Continue up chain, until we reach target number of items. */
2871     segcount++;
2872     if (segcount == data->chainlen) {
2873       break;
2874     }
2875     rootchan = rootchan->parent;
2876   }
2877   return rootchan;
2878 }
2879
2880 /** \} */