ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenkernel / intern / armature_update.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) 2015 Blender Foundation.
17  * All rights reserved.
18  *
19  * Defines and code for core node types
20  */
21
22 /** \file
23  * \ingroup bke
24  */
25
26 #include "MEM_guardedalloc.h"
27
28 #include "BLI_utildefines.h"
29 #include "BLI_listbase.h"
30 #include "BLI_math.h"
31
32 #include "DNA_armature_types.h"
33 #include "DNA_constraint_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36
37 #include "BKE_action.h"
38 #include "BKE_anim.h"
39 #include "BKE_armature.h"
40 #include "BKE_curve.h"
41 #include "BKE_displist.h"
42 #include "BKE_fcurve.h"
43 #include "BKE_object.h"
44 #include "BKE_scene.h"
45
46 #include "BIK_api.h"
47
48 #include "DEG_depsgraph.h"
49
50 /* ********************** SPLINE IK SOLVER ******************* */
51
52 /* Temporary evaluation tree data used for Spline IK */
53 typedef struct tSplineIK_Tree {
54   struct tSplineIK_Tree *next, *prev;
55
56   int type; /* type of IK that this serves (CONSTRAINT_TYPE_KINEMATIC or ..._SPLINEIK) */
57
58   short chainlen;  /* number of bones in the chain */
59   float totlength; /* total length of bones in the chain */
60
61   const float *points;  /* parametric positions for the joints along the curve */
62   bPoseChannel **chain; /* chain of bones to affect using Spline IK (ordered from the tip) */
63
64   bPoseChannel *root; /* bone that is the root node of the chain */
65
66   bConstraint *con;            /* constraint for this chain */
67   bSplineIKConstraint *ikData; /* constraint settings for this chain */
68 } tSplineIK_Tree;
69
70 /* ----------- */
71
72 /* Tag the bones in the chain formed by the given bone for IK */
73 static void splineik_init_tree_from_pchan(Scene *UNUSED(scene),
74                                           Object *UNUSED(ob),
75                                           bPoseChannel *pchan_tip)
76 {
77   bPoseChannel *pchan, *pchanRoot = NULL;
78   bPoseChannel *pchanChain[255];
79   bConstraint *con = NULL;
80   bSplineIKConstraint *ikData = NULL;
81   float boneLengths[255];
82   float totLength = 0.0f;
83   int segcount = 0;
84
85   /* find the SplineIK constraint */
86   for (con = pchan_tip->constraints.first; con; con = con->next) {
87     if (con->type == CONSTRAINT_TYPE_SPLINEIK) {
88       ikData = con->data;
89
90       /* target can only be curve */
91       if ((ikData->tar == NULL) || (ikData->tar->type != OB_CURVE))
92         continue;
93       /* skip if disabled */
94       if ((con->enforce == 0.0f) || (con->flag & (CONSTRAINT_DISABLE | CONSTRAINT_OFF)))
95         continue;
96
97       /* otherwise, constraint is ok... */
98       break;
99     }
100   }
101   if (con == NULL)
102     return;
103
104   /* find the root bone and the chain of bones from the root to the tip
105    * NOTE: this assumes that the bones are connected, but that may not be true... */
106   for (pchan = pchan_tip; pchan && (segcount < ikData->chainlen);
107        pchan = pchan->parent, segcount++) {
108     /* store this segment in the chain */
109     pchanChain[segcount] = pchan;
110
111     /* if performing rebinding, calculate the length of the bone */
112     boneLengths[segcount] = pchan->bone->length;
113     totLength += boneLengths[segcount];
114   }
115
116   if (segcount == 0)
117     return;
118   else
119     pchanRoot = pchanChain[segcount - 1];
120
121   /* perform binding step if required */
122   if ((ikData->flag & CONSTRAINT_SPLINEIK_BOUND) == 0) {
123     float segmentLen = (1.0f / (float)segcount);
124     int i;
125
126     /* setup new empty array for the points list */
127     if (ikData->points)
128       MEM_freeN(ikData->points);
129     ikData->numpoints = ikData->chainlen + 1;
130     ikData->points = MEM_mallocN(sizeof(float) * ikData->numpoints, "Spline IK Binding");
131
132     /* bind 'tip' of chain (i.e. first joint = tip of bone with the Spline IK Constraint) */
133     ikData->points[0] = 1.0f;
134
135     /* perform binding of the joints to parametric positions along the curve based
136      * proportion of the total length that each bone occupies
137      */
138     for (i = 0; i < segcount; i++) {
139       /* 'head' joints, traveling towards the root of the chain
140        * - 2 methods; the one chosen depends on whether we've got usable lengths
141        */
142       if ((ikData->flag & CONSTRAINT_SPLINEIK_EVENSPLITS) || (totLength == 0.0f)) {
143         /* 1) equi-spaced joints */
144         ikData->points[i + 1] = ikData->points[i] - segmentLen;
145       }
146       else {
147         /* 2) to find this point on the curve, we take a step from the previous joint
148          *    a distance given by the proportion that this bone takes
149          */
150         ikData->points[i + 1] = ikData->points[i] - (boneLengths[i] / totLength);
151       }
152     }
153
154     /* spline has now been bound */
155     ikData->flag |= CONSTRAINT_SPLINEIK_BOUND;
156   }
157
158   /* disallow negative values (happens with float precision) */
159   CLAMP_MIN(ikData->points[segcount], 0.0f);
160
161   /* make a new Spline-IK chain, and store it in the IK chains */
162   /* TODO: we should check if there is already an IK chain on this, since that would take precedence... */
163   {
164     /* make new tree */
165     tSplineIK_Tree *tree = MEM_callocN(sizeof(tSplineIK_Tree), "SplineIK Tree");
166     tree->type = CONSTRAINT_TYPE_SPLINEIK;
167
168     tree->chainlen = segcount;
169     tree->totlength = totLength;
170
171     /* copy over the array of links to bones in the chain (from tip to root) */
172     tree->chain = MEM_mallocN(sizeof(bPoseChannel *) * segcount, "SplineIK Chain");
173     memcpy(tree->chain, pchanChain, sizeof(bPoseChannel *) * segcount);
174
175     /* store reference to joint position array */
176     tree->points = ikData->points;
177
178     /* store references to different parts of the chain */
179     tree->root = pchanRoot;
180     tree->con = con;
181     tree->ikData = ikData;
182
183     /* AND! link the tree to the root */
184     BLI_addtail(&pchanRoot->siktree, tree);
185   }
186
187   /* mark root channel having an IK tree */
188   pchanRoot->flag |= POSE_IKSPLINE;
189 }
190
191 /* Tag which bones are members of Spline IK chains */
192 static void splineik_init_tree(Scene *scene, Object *ob, float UNUSED(ctime))
193 {
194   bPoseChannel *pchan;
195
196   /* find the tips of Spline IK chains, which are simply the bones which have been tagged as such */
197   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
198     if (pchan->constflag & PCHAN_HAS_SPLINEIK)
199       splineik_init_tree_from_pchan(scene, ob, pchan);
200   }
201 }
202
203 /* ----------- */
204
205 typedef struct tSplineIk_EvalState {
206   float curve_position;      /* Current position along the curve. */
207   float curve_scale;         /* Global scale to apply to curve positions. */
208   float locrot_offset[4][4]; /* Bone rotation and location offset inherited from parent. */
209 } tSplineIk_EvalState;
210
211 /* Prepare data to evaluate spline IK. */
212 static bool splineik_evaluate_init(tSplineIK_Tree *tree, tSplineIk_EvalState *state)
213 {
214   bSplineIKConstraint *ikData = tree->ikData;
215
216   /* Make sure that the constraint targets are ok, to avoid crashes
217    * in case of a depsgraph bug or dependency cycle.
218    */
219   if (ikData->tar == NULL) {
220     return false;
221   }
222
223   CurveCache *cache = ikData->tar->runtime.curve_cache;
224
225   if (ELEM(NULL, cache, cache->path, cache->path->data)) {
226     return false;
227   }
228
229   /* Initialize the evaluation state. */
230   state->curve_position = 0.0f;
231   state->curve_scale = 1.0f;
232   unit_m4(state->locrot_offset);
233
234   /* Apply corrections for sensitivity to scaling. */
235   if ((ikData->yScaleMode != CONSTRAINT_SPLINEIK_YS_FIT_CURVE) && (tree->totlength != 0.0f)) {
236     /* get the current length of the curve */
237     /* NOTE: this is assumed to be correct even after the curve was resized */
238     float splineLen = cache->path->totdist;
239
240     /* calculate the scale factor to multiply all the path values by so that the
241      * bone chain retains its current length, such that
242      *     maxScale * splineLen = totLength
243      */
244     state->curve_scale = tree->totlength / splineLen;
245   }
246
247   return true;
248 }
249
250 /* Evaluate spline IK for a given bone. */
251 static void splineik_evaluate_bone(
252     tSplineIK_Tree *tree, Object *ob, bPoseChannel *pchan, int index, tSplineIk_EvalState *state)
253 {
254   bSplineIKConstraint *ikData = tree->ikData;
255   float origHead[3], origTail[3], poseHead[3], poseTail[3], basePoseMat[3][3], poseMat[3][3];
256   float splineVec[3], scaleFac, radius = 1.0f;
257   float tailBlendFac = 0.0f;
258
259   mul_v3_m4v3(poseHead, state->locrot_offset, pchan->pose_head);
260   mul_v3_m4v3(poseTail, state->locrot_offset, pchan->pose_tail);
261
262   copy_v3_v3(origHead, poseHead);
263
264   /* first, adjust the point positions on the curve */
265   float curveLen = tree->points[index] - tree->points[index + 1];
266   float pointStart = state->curve_position;
267   float baseScale = 1.0f;
268
269   if (ikData->yScaleMode == CONSTRAINT_SPLINEIK_YS_ORIGINAL) {
270     /* Carry over the bone Y scale to the curve range. */
271     baseScale = len_v3v3(poseHead, poseTail) / pchan->bone->length;
272   }
273
274   float pointEnd = pointStart + curveLen * baseScale * state->curve_scale;
275
276   state->curve_position = pointEnd;
277
278   /* step 1: determine the positions for the endpoints of the bone */
279   if (pointStart < 1.0f) {
280     float vec[4], dir[3], rad;
281
282     /* determine if the bone should still be affected by SplineIK */
283     if (pointEnd >= 1.0f) {
284       /* blending factor depends on the amount of the bone still left on the chain */
285       tailBlendFac = (1.0f - pointStart) / (pointEnd - pointStart);
286     }
287     else {
288       tailBlendFac = 1.0f;
289     }
290
291     /* tail endpoint */
292     if (where_on_path(ikData->tar, pointEnd, vec, dir, NULL, &rad, NULL)) {
293       /* apply curve's object-mode transforms to the position
294        * unless the option to allow curve to be positioned elsewhere is activated (i.e. no root)
295        */
296       if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0)
297         mul_m4_v3(ikData->tar->obmat, vec);
298
299       /* convert the position to pose-space, then store it */
300       mul_m4_v3(ob->imat, vec);
301       copy_v3_v3(poseTail, vec);
302
303       /* set the new radius */
304       radius = rad;
305     }
306
307     /* head endpoint */
308     if (where_on_path(ikData->tar, pointStart, vec, dir, NULL, &rad, NULL)) {
309       /* apply curve's object-mode transforms to the position
310        * unless the option to allow curve to be positioned elsewhere is activated (i.e. no root)
311        */
312       if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0)
313         mul_m4_v3(ikData->tar->obmat, vec);
314
315       /* store the position, and convert it to pose space */
316       mul_m4_v3(ob->imat, vec);
317       copy_v3_v3(poseHead, vec);
318
319       /* set the new radius (it should be the average value) */
320       radius = (radius + rad) / 2;
321     }
322   }
323
324   /* step 2: determine the implied transform from these endpoints
325    *     - splineVec: the vector direction that the spline applies on the bone
326    *     - scaleFac: the factor that the bone length is scaled by to get the desired amount
327    */
328   sub_v3_v3v3(splineVec, poseTail, poseHead);
329   scaleFac = len_v3(splineVec) / pchan->bone->length;
330
331   /* Adjust the scale factor towards the neutral state when rolling off the curve end. */
332   scaleFac = interpf(scaleFac, baseScale, tailBlendFac);
333
334   /* step 3: compute the shortest rotation needed to map from the bone rotation to the current axis
335    *      - this uses the same method as is used for the Damped Track Constraint (see the code there for details)
336    */
337   {
338     float dmat[3][3], rmat[3][3];
339     float raxis[3], rangle;
340
341     /* compute the raw rotation matrix from the bone's current matrix by extracting only the
342      * orientation-relevant axes, and normalizing them
343      */
344     mul_m3_m4m4(basePoseMat, state->locrot_offset, pchan->pose_mat);
345     normalize_m3_m3(rmat, basePoseMat);
346
347     /* also, normalize the orientation imposed by the bone, now that we've extracted the scale factor */
348     normalize_v3(splineVec);
349
350     /* calculate smallest axis-angle rotation necessary for getting from the
351      * current orientation of the bone, to the spline-imposed direction
352      */
353     cross_v3_v3v3(raxis, rmat[1], splineVec);
354
355     rangle = dot_v3v3(rmat[1], splineVec);
356     CLAMP(rangle, -1.0f, 1.0f);
357     rangle = acosf(rangle);
358
359     /* multiply the magnitude of the angle by the influence of the constraint to
360      * control the influence of the SplineIK effect
361      */
362     rangle *= tree->con->enforce * tailBlendFac;
363
364     /* construct rotation matrix from the axis-angle rotation found above
365      * - this call takes care to make sure that the axis provided is a unit vector first
366      */
367     axis_angle_to_mat3(dmat, raxis, rangle);
368
369     /* combine these rotations so that the y-axis of the bone is now aligned as the spline dictates,
370      * while still maintaining roll control from the existing bone animation
371      */
372     mul_m3_m3m3(poseMat, dmat, rmat);
373     normalize_m3(
374         poseMat); /* attempt to reduce shearing, though I doubt this'll really help too much now... */
375
376     mul_m3_m3m3(basePoseMat, dmat, basePoseMat);
377
378     /* apply rotation to the accumulated parent transform */
379     mul_m4_m3m4(state->locrot_offset, dmat, state->locrot_offset);
380   }
381
382   /* step 4: set the scaling factors for the axes */
383   {
384     /* only multiply the y-axis by the scaling factor to get nice volume-preservation */
385     mul_v3_fl(poseMat[1], scaleFac);
386
387     /* set the scaling factors of the x and z axes from... */
388     switch (ikData->xzScaleMode) {
389       case CONSTRAINT_SPLINEIK_XZS_ORIGINAL: {
390         /* original scales get used */
391         float scale;
392
393         /* x-axis scale */
394         scale = len_v3(pchan->pose_mat[0]);
395         mul_v3_fl(poseMat[0], scale);
396         /* z-axis scale */
397         scale = len_v3(pchan->pose_mat[2]);
398         mul_v3_fl(poseMat[2], scale);
399         break;
400       }
401       case CONSTRAINT_SPLINEIK_XZS_INVERSE: {
402         /* old 'volume preservation' method using the inverse scale */
403         float scale;
404
405         /* calculate volume preservation factor which is
406          * basically the inverse of the y-scaling factor
407          */
408         if (fabsf(scaleFac) != 0.0f) {
409           scale = 1.0f / fabsf(scaleFac);
410
411           /* we need to clamp this within sensible values */
412           /* NOTE: these should be fine for now, but should get sanitised in future */
413           CLAMP(scale, 0.0001f, 100000.0f);
414         }
415         else
416           scale = 1.0f;
417
418         /* apply the scaling */
419         mul_v3_fl(poseMat[0], scale);
420         mul_v3_fl(poseMat[2], scale);
421         break;
422       }
423       case CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC: {
424         /* improved volume preservation based on the Stretch To constraint */
425         float final_scale;
426
427         /* as the basis for volume preservation, we use the inverse scale factor... */
428         if (fabsf(scaleFac) != 0.0f) {
429           /* NOTE: The method here is taken wholesale from the Stretch To constraint */
430           float bulge = powf(1.0f / fabsf(scaleFac), ikData->bulge);
431
432           if (bulge > 1.0f) {
433             if (ikData->flag & CONSTRAINT_SPLINEIK_USE_BULGE_MAX) {
434               float bulge_max = max_ff(ikData->bulge_max, 1.0f);
435               float hard = min_ff(bulge, bulge_max);
436
437               float range = bulge_max - 1.0f;
438               float scale = (range > 0.0f) ? 1.0f / range : 0.0f;
439               float soft = 1.0f + range * atanf((bulge - 1.0f) * scale) / (float)M_PI_2;
440
441               bulge = interpf(soft, hard, ikData->bulge_smooth);
442             }
443           }
444           if (bulge < 1.0f) {
445             if (ikData->flag & CONSTRAINT_SPLINEIK_USE_BULGE_MIN) {
446               float bulge_min = CLAMPIS(ikData->bulge_min, 0.0f, 1.0f);
447               float hard = max_ff(bulge, bulge_min);
448
449               float range = 1.0f - bulge_min;
450               float scale = (range > 0.0f) ? 1.0f / range : 0.0f;
451               float soft = 1.0f - range * atanf((1.0f - bulge) * scale) / (float)M_PI_2;
452
453               bulge = interpf(soft, hard, ikData->bulge_smooth);
454             }
455           }
456
457           /* compute scale factor for xz axes from this value */
458           final_scale = sqrtf(bulge);
459         }
460         else {
461           /* no scaling, so scale factor is simple */
462           final_scale = 1.0f;
463         }
464
465         /* apply the scaling (assuming normalised scale) */
466         mul_v3_fl(poseMat[0], final_scale);
467         mul_v3_fl(poseMat[2], final_scale);
468         break;
469       }
470     }
471
472     /* finally, multiply the x and z scaling by the radius of the curve too,
473      * to allow automatic scales to get tweaked still
474      */
475     if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_CURVERAD) == 0) {
476       mul_v3_fl(poseMat[0], radius);
477       mul_v3_fl(poseMat[2], radius);
478     }
479   }
480
481   /* Blend the scaling of the matrix according to the influence. */
482   sub_m3_m3m3(poseMat, poseMat, basePoseMat);
483   madd_m3_m3m3fl(poseMat, basePoseMat, poseMat, tree->con->enforce * tailBlendFac);
484
485   /* step 5: set the location of the bone in the matrix */
486   if (ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) {
487     /* when the 'no-root' option is affected, the chain can retain
488      * the shape but be moved elsewhere
489      */
490     copy_v3_v3(poseHead, origHead);
491   }
492   else if (tree->con->enforce < 1.0f) {
493     /* when the influence is too low
494      * - blend the positions for the 'root' bone
495      * - stick to the parent for any other
496      */
497     if (index < tree->chainlen - 1) {
498       copy_v3_v3(poseHead, origHead);
499     }
500     else {
501       interp_v3_v3v3(poseHead, origHead, poseHead, tree->con->enforce);
502     }
503   }
504
505   /* finally, store the new transform */
506   copy_m4_m3(pchan->pose_mat, poseMat);
507   copy_v3_v3(pchan->pose_mat[3], poseHead);
508   copy_v3_v3(pchan->pose_head, poseHead);
509
510   mul_v3_mat3_m4v3(origTail, state->locrot_offset, pchan->pose_tail);
511
512   /* recalculate tail, as it's now outdated after the head gets adjusted above! */
513   BKE_pose_where_is_bone_tail(pchan);
514
515   /* update the offset in the accumulated parent transform */
516   sub_v3_v3v3(state->locrot_offset[3], pchan->pose_tail, origTail);
517
518   /* done! */
519   pchan->flag |= POSE_DONE;
520 }
521
522 /* Evaluate the chain starting from the nominated bone */
523 static void splineik_execute_tree(
524     struct Depsgraph *depsgraph, Scene *scene, Object *ob, bPoseChannel *pchan_root, float ctime)
525 {
526   tSplineIK_Tree *tree;
527
528   /* for each pose-tree, execute it if it is spline, otherwise just free it */
529   while ((tree = pchan_root->siktree.first) != NULL) {
530     int i;
531
532     /* Firstly, calculate the bone matrix the standard way, since this is needed for roll control. */
533     for (i = tree->chainlen - 1; i >= 0; i--) {
534       BKE_pose_where_is_bone(depsgraph, scene, ob, tree->chain[i], ctime, 1);
535     }
536
537     /* After that, evaluate the actual Spline IK, unless there are missing dependencies. */
538     tSplineIk_EvalState state;
539
540     if (splineik_evaluate_init(tree, &state)) {
541       /* Walk over each bone in the chain, calculating the effects of spline IK
542        *     - the chain is traversed in the opposite order to storage order (i.e. parent to children)
543        *       so that dependencies are correct
544        */
545       for (i = tree->chainlen - 1; i >= 0; i--) {
546         bPoseChannel *pchan = tree->chain[i];
547         splineik_evaluate_bone(tree, ob, pchan, i, &state);
548       }
549     }
550
551     /* free the tree info specific to SplineIK trees now */
552     if (tree->chain)
553       MEM_freeN(tree->chain);
554
555     /* free this tree */
556     BLI_freelinkN(&pchan_root->siktree, tree);
557   }
558 }
559
560 void BKE_pose_splineik_init_tree(Scene *scene, Object *ob, float ctime)
561 {
562   splineik_init_tree(scene, ob, ctime);
563 }
564
565 void BKE_splineik_execute_tree(
566     struct Depsgraph *depsgraph, Scene *scene, Object *ob, bPoseChannel *pchan_root, float ctime)
567 {
568   splineik_execute_tree(depsgraph, scene, ob, pchan_root, ctime);
569 }
570
571 /* *************** Depsgraph evaluation callbacks ************ */
572
573 void BKE_pose_pchan_index_rebuild(bPose *pose)
574 {
575   MEM_SAFE_FREE(pose->chan_array);
576   const int num_channels = BLI_listbase_count(&pose->chanbase);
577   pose->chan_array = MEM_malloc_arrayN(num_channels, sizeof(bPoseChannel *), "pose->chan_array");
578   int pchan_index = 0;
579   for (bPoseChannel *pchan = pose->chanbase.first; pchan != NULL; pchan = pchan->next) {
580     pose->chan_array[pchan_index++] = pchan;
581   }
582 }
583
584 BLI_INLINE bPoseChannel *pose_pchan_get_indexed(Object *ob, int pchan_index)
585 {
586   bPose *pose = ob->pose;
587   BLI_assert(pose != NULL);
588   BLI_assert(pose->chan_array != NULL);
589   BLI_assert(pchan_index >= 0);
590   BLI_assert(pchan_index < MEM_allocN_len(pose->chan_array) / sizeof(bPoseChannel *));
591   return pose->chan_array[pchan_index];
592 }
593
594 void BKE_pose_eval_init(struct Depsgraph *depsgraph, Scene *UNUSED(scene), Object *object)
595 {
596   bPose *pose = object->pose;
597   BLI_assert(pose != NULL);
598
599   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
600
601   BLI_assert(object->type == OB_ARMATURE);
602
603   /* We demand having proper pose. */
604   BLI_assert(object->pose != NULL);
605   BLI_assert((object->pose->flag & POSE_RECALC) == 0);
606
607   /* imat is needed for solvers. */
608   invert_m4_m4(object->imat, object->obmat);
609
610   /* clear flags */
611   for (bPoseChannel *pchan = pose->chanbase.first; pchan != NULL; pchan = pchan->next) {
612     pchan->flag &= ~(POSE_DONE | POSE_CHAIN | POSE_IKTREE | POSE_IKSPLINE);
613
614     /* Free B-Bone shape data cache if it's not a B-Bone. */
615     if (pchan->bone == NULL || pchan->bone->segments <= 1) {
616       BKE_pose_channel_free_bbone_cache(pchan);
617     }
618   }
619
620   BLI_assert(pose->chan_array != NULL || BLI_listbase_is_empty(&pose->chanbase));
621
622   BKE_armature_cached_bbone_deformation_free_data(object);
623 }
624
625 void BKE_pose_eval_init_ik(struct Depsgraph *depsgraph, Scene *scene, Object *object)
626 {
627   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
628   BLI_assert(object->type == OB_ARMATURE);
629   const float ctime = BKE_scene_frame_get(scene); /* not accurate... */
630   bArmature *armature = (bArmature *)object->data;
631   if (armature->flag & ARM_RESTPOS) {
632     return;
633   }
634   /* construct the IK tree (standard IK) */
635   BIK_initialize_tree(depsgraph, scene, object, ctime);
636   /* construct the Spline IK trees
637    * - this is not integrated as an IK plugin, since it should be able
638    *   to function in conjunction with standard IK.  */
639   BKE_pose_splineik_init_tree(scene, object, ctime);
640 }
641
642 void BKE_pose_eval_bone(struct Depsgraph *depsgraph, Scene *scene, Object *object, int pchan_index)
643 {
644   const bArmature *armature = (bArmature *)object->data;
645   if (armature->edbo != NULL) {
646     return;
647   }
648   bPoseChannel *pchan = pose_pchan_get_indexed(object, pchan_index);
649   DEG_debug_print_eval_subdata(
650       depsgraph, __func__, object->id.name, object, "pchan", pchan->name, pchan);
651   BLI_assert(object->type == OB_ARMATURE);
652   if (armature->flag & ARM_RESTPOS) {
653     Bone *bone = pchan->bone;
654     if (bone) {
655       copy_m4_m4(pchan->pose_mat, bone->arm_mat);
656       copy_v3_v3(pchan->pose_head, bone->arm_head);
657       copy_v3_v3(pchan->pose_tail, bone->arm_tail);
658     }
659   }
660   else {
661     /* TODO(sergey): Currently if there are constraints full transform is
662      * being evaluated in BKE_pose_constraints_evaluate. */
663     if (pchan->constraints.first == NULL) {
664       if (pchan->flag & POSE_IKTREE || pchan->flag & POSE_IKSPLINE) {
665         /* pass */
666       }
667       else {
668         if ((pchan->flag & POSE_DONE) == 0) {
669           /* TODO(sergey): Use time source node for time. */
670           float ctime = BKE_scene_frame_get(scene); /* not accurate... */
671           BKE_pose_where_is_bone(depsgraph, scene, object, pchan, ctime, 1);
672         }
673       }
674     }
675   }
676 }
677
678 void BKE_pose_constraints_evaluate(struct Depsgraph *depsgraph,
679                                    Scene *scene,
680                                    Object *object,
681                                    int pchan_index)
682 {
683   const bArmature *armature = (bArmature *)object->data;
684   if (armature->edbo != NULL) {
685     return;
686   }
687   bPoseChannel *pchan = pose_pchan_get_indexed(object, pchan_index);
688   DEG_debug_print_eval_subdata(
689       depsgraph, __func__, object->id.name, object, "pchan", pchan->name, pchan);
690   if (armature->flag & ARM_RESTPOS) {
691     return;
692   }
693   else if (pchan->flag & POSE_IKTREE || pchan->flag & POSE_IKSPLINE) {
694     /* IK are being solved separately/ */
695   }
696   else {
697     if ((pchan->flag & POSE_DONE) == 0) {
698       float ctime = BKE_scene_frame_get(scene); /* not accurate... */
699       BKE_pose_where_is_bone(depsgraph, scene, object, pchan, ctime, 1);
700     }
701   }
702 }
703
704 void BKE_pose_bone_done(struct Depsgraph *depsgraph, struct Object *object, int pchan_index)
705 {
706   const bArmature *armature = (bArmature *)object->data;
707   if (armature->edbo != NULL) {
708     return;
709   }
710   bPoseChannel *pchan = pose_pchan_get_indexed(object, pchan_index);
711   float imat[4][4];
712   DEG_debug_print_eval_subdata(
713       depsgraph, __func__, object->id.name, object, "pchan", pchan->name, pchan);
714   if (pchan->bone) {
715     invert_m4_m4(imat, pchan->bone->arm_mat);
716     mul_m4_m4m4(pchan->chan_mat, pchan->pose_mat, imat);
717   }
718   if (DEG_is_active(depsgraph) && armature->edbo == NULL) {
719     bPoseChannel *pchan_orig = pchan->orig_pchan;
720     copy_m4_m4(pchan_orig->pose_mat, pchan->pose_mat);
721     copy_m4_m4(pchan_orig->chan_mat, pchan->chan_mat);
722     copy_v3_v3(pchan_orig->pose_head, pchan->pose_mat[3]);
723     copy_m4_m4(pchan_orig->constinv, pchan->constinv);
724     BKE_pose_where_is_bone_tail(pchan_orig);
725     if (pchan->bone == NULL || pchan->bone->segments <= 1) {
726       BKE_pose_channel_free_bbone_cache(pchan_orig);
727     }
728   }
729 }
730
731 void BKE_pose_eval_bbone_segments(struct Depsgraph *depsgraph,
732                                   struct Object *object,
733                                   int pchan_index)
734 {
735   const bArmature *armature = (bArmature *)object->data;
736   if (armature->edbo != NULL) {
737     return;
738   }
739   bPoseChannel *pchan = pose_pchan_get_indexed(object, pchan_index);
740   DEG_debug_print_eval_subdata(
741       depsgraph, __func__, object->id.name, object, "pchan", pchan->name, pchan);
742   if (pchan->bone != NULL && pchan->bone->segments > 1) {
743     BKE_pchan_bbone_segments_cache_compute(pchan);
744     if (DEG_is_active(depsgraph)) {
745       BKE_pchan_bbone_segments_cache_copy(pchan->orig_pchan, pchan);
746     }
747   }
748 }
749
750 void BKE_pose_iktree_evaluate(struct Depsgraph *depsgraph,
751                               Scene *scene,
752                               Object *object,
753                               int rootchan_index)
754 {
755   const bArmature *armature = (bArmature *)object->data;
756   if (armature->edbo != NULL) {
757     return;
758   }
759   bPoseChannel *rootchan = pose_pchan_get_indexed(object, rootchan_index);
760   DEG_debug_print_eval_subdata(
761       depsgraph, __func__, object->id.name, object, "rootchan", rootchan->name, rootchan);
762   BLI_assert(object->type == OB_ARMATURE);
763   const float ctime = BKE_scene_frame_get(scene); /* not accurate... */
764   if (armature->flag & ARM_RESTPOS) {
765     return;
766   }
767   BIK_execute_tree(depsgraph, scene, object, rootchan, ctime);
768 }
769
770 void BKE_pose_splineik_evaluate(struct Depsgraph *depsgraph,
771                                 Scene *scene,
772                                 Object *object,
773                                 int rootchan_index)
774
775 {
776   const bArmature *armature = (bArmature *)object->data;
777   if (armature->edbo != NULL) {
778     return;
779   }
780   bPoseChannel *rootchan = pose_pchan_get_indexed(object, rootchan_index);
781   DEG_debug_print_eval_subdata(
782       depsgraph, __func__, object->id.name, object, "rootchan", rootchan->name, rootchan);
783   BLI_assert(object->type == OB_ARMATURE);
784   const float ctime = BKE_scene_frame_get(scene); /* not accurate... */
785   if (armature->flag & ARM_RESTPOS) {
786     return;
787   }
788   BKE_splineik_execute_tree(depsgraph, scene, object, rootchan, ctime);
789 }
790
791 /* Common part for both original and proxy armatrues. */
792 static void pose_eval_done_common(struct Depsgraph *depsgraph, Object *object)
793 {
794   const bArmature *armature = (bArmature *)object->data;
795   if (armature->edbo != NULL) {
796     return;
797   }
798   bPose *pose = object->pose;
799   UNUSED_VARS_NDEBUG(pose);
800   BLI_assert(pose != NULL);
801   BKE_armature_cached_bbone_deformation_update(object);
802   BKE_object_eval_boundbox(depsgraph, object);
803 }
804 static void pose_eval_cleanup_common(Object *object)
805 {
806   bPose *pose = object->pose;
807   BLI_assert(pose != NULL);
808   BLI_assert(pose->chan_array != NULL || BLI_listbase_is_empty(&pose->chanbase));
809 }
810
811 void BKE_pose_eval_done(struct Depsgraph *depsgraph, Object *object)
812 {
813   bPose *pose = object->pose;
814   BLI_assert(pose != NULL);
815   UNUSED_VARS_NDEBUG(pose);
816   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
817   BLI_assert(object->type == OB_ARMATURE);
818   pose_eval_done_common(depsgraph, object);
819 }
820
821 void BKE_pose_eval_cleanup(struct Depsgraph *depsgraph, Scene *scene, Object *object)
822 {
823   bPose *pose = object->pose;
824   BLI_assert(pose != NULL);
825   UNUSED_VARS_NDEBUG(pose);
826   const float ctime = BKE_scene_frame_get(scene); /* not accurate... */
827   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
828   BLI_assert(object->type == OB_ARMATURE);
829   /* Release the IK tree. */
830   BIK_release_tree(scene, object, ctime);
831   pose_eval_cleanup_common(object);
832 }
833
834 void BKE_pose_eval_proxy_init(struct Depsgraph *depsgraph, Object *object)
835 {
836   BLI_assert(ID_IS_LINKED(object) && object->proxy_from != NULL);
837   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
838
839   BLI_assert(object->pose->chan_array != NULL || BLI_listbase_is_empty(&object->pose->chanbase));
840
841   BKE_armature_cached_bbone_deformation_free_data(object);
842 }
843
844 void BKE_pose_eval_proxy_done(struct Depsgraph *depsgraph, Object *object)
845 {
846   BLI_assert(ID_IS_LINKED(object) && object->proxy_from != NULL);
847   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
848   pose_eval_done_common(depsgraph, object);
849 }
850
851 void BKE_pose_eval_proxy_cleanup(struct Depsgraph *depsgraph, Object *object)
852 {
853   BLI_assert(ID_IS_LINKED(object) && object->proxy_from != NULL);
854   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
855   pose_eval_cleanup_common(object);
856 }
857
858 void BKE_pose_eval_proxy_copy_bone(struct Depsgraph *depsgraph, Object *object, int pchan_index)
859 {
860   const bArmature *armature = (bArmature *)object->data;
861   if (armature->edbo != NULL) {
862     return;
863   }
864   BLI_assert(ID_IS_LINKED(object) && object->proxy_from != NULL);
865   bPoseChannel *pchan = pose_pchan_get_indexed(object, pchan_index);
866   DEG_debug_print_eval_subdata(
867       depsgraph, __func__, object->id.name, object, "pchan", pchan->name, pchan);
868   /* TODO(sergey): Use indexec lookup, once it's guaranteed to be kept
869    * around for the time while proxies are evaluating.
870    */
871 #if 0
872   bPoseChannel *pchan_from = pose_pchan_get_indexed(
873           object->proxy_from, pchan_index);
874 #else
875   bPoseChannel *pchan_from = BKE_pose_channel_find_name(object->proxy_from->pose, pchan->name);
876 #endif
877   BLI_assert(pchan != NULL);
878   BLI_assert(pchan_from != NULL);
879   BKE_pose_copyesult_pchan_result(pchan, pchan_from);
880   BKE_pchan_bbone_segments_cache_copy(pchan, pchan_from);
881 }