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