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