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