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