Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / action.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <string.h>
25 #include <math.h>
26 #include <stdlib.h>
27 #include <stddef.h>
28
29 #include "MEM_guardedalloc.h"
30
31 #include "DNA_anim_types.h"
32 #include "DNA_armature_types.h"
33 #include "DNA_constraint_types.h"
34 #include "DNA_scene_types.h"
35 #include "DNA_object_types.h"
36
37 #include "BLI_blenlib.h"
38 #include "BLI_math.h"
39 #include "BLI_string_utils.h"
40 #include "BLI_utildefines.h"
41 #include "BLI_ghash.h"
42
43 #include "BLT_translation.h"
44
45 #include "BKE_action.h"
46 #include "BKE_anim.h"
47 #include "BKE_animsys.h"
48 #include "BKE_constraint.h"
49 #include "BKE_deform.h"
50 #include "BKE_fcurve.h"
51 #include "BKE_idprop.h"
52 #include "BKE_library.h"
53 #include "BKE_main.h"
54 #include "BKE_object.h"
55
56 #include "DEG_depsgraph_build.h"
57
58 #include "BIK_api.h"
59
60 #include "RNA_access.h"
61
62 #include "CLG_log.h"
63
64 static CLG_LogRef LOG = {"bke.action"};
65
66 /* *********************** NOTE ON POSE AND ACTION **********************
67  *
68  * - Pose is the local (object level) component of armature. The current
69  *   object pose is saved in files, and (will be) is presorted for dependency
70  * - Actions have fewer (or other) channels, and write data to a Pose
71  * - Currently ob->pose data is controlled in BKE_pose_where_is only. The (recalc)
72  *   event system takes care of calling that
73  * - The NLA system (here too) uses Poses as interpolation format for Actions
74  * - Therefore we assume poses to be static, and duplicates of poses have channels in
75  *   same order, for quick interpolation reasons
76  *
77  * ****************************** (ton) ************************************ */
78
79 /* ***************** Library data level operations on action ************** */
80
81 bAction *BKE_action_add(Main *bmain, const char name[])
82 {
83   bAction *act;
84
85   act = BKE_libblock_alloc(bmain, ID_AC, name, 0);
86
87   return act;
88 }
89
90 /* .................................. */
91
92 // does copy_fcurve...
93 void BKE_action_make_local(Main *bmain, bAction *act, const bool lib_local)
94 {
95   BKE_id_make_local_generic(bmain, &act->id, true, lib_local);
96 }
97
98 /* .................................. */
99
100 /** Free (or release) any data used by this action (does not free the action itself). */
101 void BKE_action_free(bAction *act)
102 {
103   /* No animdata here. */
104
105   /* Free F-Curves */
106   free_fcurves(&act->curves);
107
108   /* Free groups */
109   BLI_freelistN(&act->groups);
110
111   /* Free pose-references (aka local markers) */
112   BLI_freelistN(&act->markers);
113 }
114
115 /* .................................. */
116
117 /**
118  * Only copy internal data of Action ID from source
119  * to already allocated/initialized destination.
120  * You probably never want to use that directly,
121  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
122  *
123  * WARNING! This function will not handle ID user count!
124  *
125  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
126  */
127 void BKE_action_copy_data(Main *UNUSED(bmain),
128                           bAction *act_dst,
129                           const bAction *act_src,
130                           const int UNUSED(flag))
131 {
132   bActionGroup *grp_dst, *grp_src;
133   FCurve *fcu_dst, *fcu_src;
134
135   /* duplicate the lists of groups and markers */
136   BLI_duplicatelist(&act_dst->groups, &act_src->groups);
137   BLI_duplicatelist(&act_dst->markers, &act_src->markers);
138
139   /* copy F-Curves, fixing up the links as we go */
140   BLI_listbase_clear(&act_dst->curves);
141
142   for (fcu_src = act_src->curves.first; fcu_src; fcu_src = fcu_src->next) {
143     /* duplicate F-Curve */
144
145     /* XXX TODO pass subdata flag?
146      * But surprisingly does not seem to be doing any ID refcounting... */
147     fcu_dst = copy_fcurve(fcu_src);
148
149     BLI_addtail(&act_dst->curves, fcu_dst);
150
151     /* fix group links (kindof bad list-in-list search, but this is the most reliable way) */
152     for (grp_dst = act_dst->groups.first, grp_src = act_src->groups.first; grp_dst && grp_src;
153          grp_dst = grp_dst->next, grp_src = grp_src->next) {
154       if (fcu_src->grp == grp_src) {
155         fcu_dst->grp = grp_dst;
156
157         if (grp_dst->channels.first == fcu_src) {
158           grp_dst->channels.first = fcu_dst;
159         }
160         if (grp_dst->channels.last == fcu_src) {
161           grp_dst->channels.last = fcu_dst;
162         }
163         break;
164       }
165     }
166   }
167 }
168
169 bAction *BKE_action_copy(Main *bmain, const bAction *act_src)
170 {
171   bAction *act_copy;
172   BKE_id_copy(bmain, &act_src->id, (ID **)&act_copy);
173   return act_copy;
174 }
175
176 /* *************** Action Groups *************** */
177
178 /* Get the active action-group for an Action */
179 bActionGroup *get_active_actiongroup(bAction *act)
180 {
181   bActionGroup *agrp = NULL;
182
183   if (act && act->groups.first) {
184     for (agrp = act->groups.first; agrp; agrp = agrp->next) {
185       if (agrp->flag & AGRP_ACTIVE) {
186         break;
187       }
188     }
189   }
190
191   return agrp;
192 }
193
194 /* Make the given Action-Group the active one */
195 void set_active_action_group(bAction *act, bActionGroup *agrp, short select)
196 {
197   bActionGroup *grp;
198
199   /* sanity checks */
200   if (act == NULL) {
201     return;
202   }
203
204   /* Deactivate all others */
205   for (grp = act->groups.first; grp; grp = grp->next) {
206     if ((grp == agrp) && (select)) {
207       grp->flag |= AGRP_ACTIVE;
208     }
209     else {
210       grp->flag &= ~AGRP_ACTIVE;
211     }
212   }
213 }
214
215 /* Sync colors used for action/bone group with theme settings */
216 void action_group_colors_sync(bActionGroup *grp, const bActionGroup *ref_grp)
217 {
218   /* only do color copying if using a custom color (i.e. not default color)  */
219   if (grp->customCol) {
220     if (grp->customCol > 0) {
221       /* copy theme colors on-to group's custom color in case user tries to edit color */
222       bTheme *btheme = U.themes.first;
223       ThemeWireColor *col_set = &btheme->tarm[(grp->customCol - 1)];
224
225       memcpy(&grp->cs, col_set, sizeof(ThemeWireColor));
226     }
227     else {
228       /* if a reference group is provided, use the custom color from there... */
229       if (ref_grp) {
230         /* assumption: reference group has a color set */
231         memcpy(&grp->cs, &ref_grp->cs, sizeof(ThemeWireColor));
232       }
233       /* otherwise, init custom color with a generic/placeholder color set if
234        * no previous theme color was used that we can just keep using
235        */
236       else if (grp->cs.solid[0] == 0) {
237         /* define for setting colors in theme below */
238         rgba_char_args_set(grp->cs.solid, 0xff, 0x00, 0x00, 255);
239         rgba_char_args_set(grp->cs.select, 0x81, 0xe6, 0x14, 255);
240         rgba_char_args_set(grp->cs.active, 0x18, 0xb6, 0xe0, 255);
241       }
242     }
243   }
244 }
245
246 /* Add a new action group with the given name to the action */
247 bActionGroup *action_groups_add_new(bAction *act, const char name[])
248 {
249   bActionGroup *agrp;
250
251   /* sanity check: must have action and name */
252   if (ELEM(NULL, act, name)) {
253     return NULL;
254   }
255
256   /* allocate a new one */
257   agrp = MEM_callocN(sizeof(bActionGroup), "bActionGroup");
258
259   /* make it selected, with default name */
260   agrp->flag = AGRP_SELECTED;
261   BLI_strncpy(agrp->name, name[0] ? name : DATA_("Group"), sizeof(agrp->name));
262
263   /* add to action, and validate */
264   BLI_addtail(&act->groups, agrp);
265   BLI_uniquename(
266       &act->groups, agrp, DATA_("Group"), '.', offsetof(bActionGroup, name), sizeof(agrp->name));
267
268   /* return the new group */
269   return agrp;
270 }
271
272 /* Add given channel into (active) group
273  * - assumes that channel is not linked to anything anymore
274  * - always adds at the end of the group
275  */
276 void action_groups_add_channel(bAction *act, bActionGroup *agrp, FCurve *fcurve)
277 {
278   /* sanity checks */
279   if (ELEM(NULL, act, agrp, fcurve)) {
280     return;
281   }
282
283   /* if no channels anywhere, just add to two lists at the same time */
284   if (BLI_listbase_is_empty(&act->curves)) {
285     fcurve->next = fcurve->prev = NULL;
286
287     agrp->channels.first = agrp->channels.last = fcurve;
288     act->curves.first = act->curves.last = fcurve;
289   }
290
291   /* if the group already has channels, the F-Curve can simply be added to the list
292    * (i.e. as the last channel in the group)
293    */
294   else if (agrp->channels.first) {
295     /* if the group's last F-Curve is the action's last F-Curve too,
296      * then set the F-Curve as the last for the action first so that
297      * the lists will be in sync after linking
298      */
299     if (agrp->channels.last == act->curves.last) {
300       act->curves.last = fcurve;
301     }
302
303     /* link in the given F-Curve after the last F-Curve in the group,
304      * which means that it should be able to fit in with the rest of the
305      * list seamlessly
306      */
307     BLI_insertlinkafter(&agrp->channels, agrp->channels.last, fcurve);
308   }
309
310   /* otherwise, need to find the nearest F-Curve in group before/after current to link with */
311   else {
312     bActionGroup *grp;
313
314     /* firstly, link this F-Curve to the group */
315     agrp->channels.first = agrp->channels.last = fcurve;
316
317     /* Step through the groups preceding this one,
318      * finding the F-Curve there to attach this one after. */
319     for (grp = agrp->prev; grp; grp = grp->prev) {
320       /* if this group has F-Curves, we want weave the given one in right after the last channel
321        * there, but via the Action's list not this group's list
322        * - this is so that the F-Curve is in the right place in the Action,
323        *   but won't be included in the previous group.
324        */
325       if (grp->channels.last) {
326         /* once we've added, break here since we don't need to search any further... */
327         BLI_insertlinkafter(&act->curves, grp->channels.last, fcurve);
328         break;
329       }
330     }
331
332     /* If grp is NULL, that means we fell through, and this F-Curve should be added as the new
333      * first since group is (effectively) the first group. Thus, the existing first F-Curve becomes
334      * the second in the chain, etc. etc.
335      */
336     if (grp == NULL) {
337       BLI_insertlinkbefore(&act->curves, act->curves.first, fcurve);
338     }
339   }
340
341   /* set the F-Curve's new group */
342   fcurve->grp = agrp;
343 }
344
345 /* Remove the given channel from all groups */
346 void action_groups_remove_channel(bAction *act, FCurve *fcu)
347 {
348   /* sanity checks */
349   if (ELEM(NULL, act, fcu)) {
350     return;
351   }
352
353   /* check if any group used this directly */
354   if (fcu->grp) {
355     bActionGroup *agrp = fcu->grp;
356
357     if (agrp->channels.first == agrp->channels.last) {
358       if (agrp->channels.first == fcu) {
359         BLI_listbase_clear(&agrp->channels);
360       }
361     }
362     else if (agrp->channels.first == fcu) {
363       if ((fcu->next) && (fcu->next->grp == agrp)) {
364         agrp->channels.first = fcu->next;
365       }
366       else {
367         agrp->channels.first = NULL;
368       }
369     }
370     else if (agrp->channels.last == fcu) {
371       if ((fcu->prev) && (fcu->prev->grp == agrp)) {
372         agrp->channels.last = fcu->prev;
373       }
374       else {
375         agrp->channels.last = NULL;
376       }
377     }
378
379     fcu->grp = NULL;
380   }
381
382   /* now just remove from list */
383   BLI_remlink(&act->curves, fcu);
384 }
385
386 /* Find a group with the given name */
387 bActionGroup *BKE_action_group_find_name(bAction *act, const char name[])
388 {
389   /* sanity checks */
390   if (ELEM(NULL, act, act->groups.first, name) || (name[0] == 0)) {
391     return NULL;
392   }
393
394   /* do string comparisons */
395   return BLI_findstring(&act->groups, name, offsetof(bActionGroup, name));
396 }
397
398 /* Clear all 'temp' flags on all groups */
399 void action_groups_clear_tempflags(bAction *act)
400 {
401   bActionGroup *agrp;
402
403   /* sanity checks */
404   if (ELEM(NULL, act, act->groups.first)) {
405     return;
406   }
407
408   /* flag clearing loop */
409   for (agrp = act->groups.first; agrp; agrp = agrp->next) {
410     agrp->flag &= ~AGRP_TEMP;
411   }
412 }
413
414 /* *************** Pose channels *************** */
415
416 /**
417  * Return a pointer to the pose channel of the given name
418  * from this pose.
419  */
420 bPoseChannel *BKE_pose_channel_find_name(const bPose *pose, const char *name)
421 {
422   if (ELEM(NULL, pose, name) || (name[0] == '\0')) {
423     return NULL;
424   }
425
426   if (pose->chanhash) {
427     return BLI_ghash_lookup(pose->chanhash, (const void *)name);
428   }
429
430   return BLI_findstring(&((const bPose *)pose)->chanbase, name, offsetof(bPoseChannel, name));
431 }
432
433 /**
434  * Looks to see if the channel with the given name
435  * already exists in this pose - if not a new one is
436  * allocated and initialized.
437  *
438  * \note Use with care, not on Armature poses but for temporal ones.
439  * \note (currently used for action constraints and in rebuild_pose).
440  */
441 bPoseChannel *BKE_pose_channel_verify(bPose *pose, const char *name)
442 {
443   bPoseChannel *chan;
444
445   if (pose == NULL) {
446     return NULL;
447   }
448
449   /* See if this channel exists */
450   chan = BKE_pose_channel_find_name(pose, name);
451   if (chan) {
452     return chan;
453   }
454
455   /* If not, create it and add it */
456   chan = MEM_callocN(sizeof(bPoseChannel), "verifyPoseChannel");
457
458   BLI_strncpy(chan->name, name, sizeof(chan->name));
459
460   chan->custom_scale = 1.0f;
461
462   /* init vars to prevent math errors */
463   unit_qt(chan->quat);
464   unit_axis_angle(chan->rotAxis, &chan->rotAngle);
465   chan->size[0] = chan->size[1] = chan->size[2] = 1.0f;
466
467   chan->scale_in_x = chan->scale_in_y = 1.0f;
468   chan->scale_out_x = chan->scale_out_y = 1.0f;
469
470   chan->limitmin[0] = chan->limitmin[1] = chan->limitmin[2] = -M_PI;
471   chan->limitmax[0] = chan->limitmax[1] = chan->limitmax[2] = M_PI;
472   chan->stiffness[0] = chan->stiffness[1] = chan->stiffness[2] = 0.0f;
473   chan->ikrotweight = chan->iklinweight = 0.0f;
474   unit_m4(chan->constinv);
475
476   chan->protectflag = OB_LOCK_ROT4D; /* lock by components by default */
477
478   BLI_addtail(&pose->chanbase, chan);
479   if (pose->chanhash) {
480     BLI_ghash_insert(pose->chanhash, chan->name, chan);
481   }
482
483   return chan;
484 }
485
486 #ifndef NDEBUG
487 bool BKE_pose_channels_is_valid(const bPose *pose)
488 {
489   if (pose->chanhash) {
490     bPoseChannel *pchan;
491     for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
492       if (BLI_ghash_lookup(pose->chanhash, pchan->name) != pchan) {
493         return false;
494       }
495     }
496   }
497
498   return true;
499 }
500
501 #endif
502
503 /**
504  * Find the active posechannel for an object (we can't just use pose, as layer info is in armature)
505  *
506  * \note: Object, not bPose is used here, as we need layer info from Armature)
507  */
508 bPoseChannel *BKE_pose_channel_active(Object *ob)
509 {
510   bArmature *arm = (ob) ? ob->data : NULL;
511   bPoseChannel *pchan;
512
513   if (ELEM(NULL, ob, ob->pose, arm)) {
514     return NULL;
515   }
516
517   /* find active */
518   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
519     if ((pchan->bone) && (pchan->bone == arm->act_bone) && (pchan->bone->layer & arm->layer)) {
520       return pchan;
521     }
522   }
523
524   return NULL;
525 }
526
527 /**
528  * \see #ED_armature_ebone_get_mirrored (edit-mode, matching function)
529  */
530 bPoseChannel *BKE_pose_channel_get_mirrored(const bPose *pose, const char *name)
531 {
532   char name_flip[MAXBONENAME];
533
534   BLI_string_flip_side_name(name_flip, name, false, sizeof(name_flip));
535
536   if (!STREQ(name_flip, name)) {
537     return BKE_pose_channel_find_name(pose, name_flip);
538   }
539
540   return NULL;
541 }
542
543 const char *BKE_pose_ikparam_get_name(bPose *pose)
544 {
545   if (pose) {
546     switch (pose->iksolver) {
547       case IKSOLVER_STANDARD:
548         return NULL;
549       case IKSOLVER_ITASC:
550         return "bItasc";
551     }
552   }
553   return NULL;
554 }
555
556 /**
557  * Allocate a new pose on the heap, and copy the src pose and it's channels
558  * into the new pose. *dst is set to the newly allocated structure, and assumed to be NULL.
559  *
560  * \param dst: Should be freed already, makes entire duplicate.
561  */
562 void BKE_pose_copy_data_ex(bPose **dst,
563                            const bPose *src,
564                            const int flag,
565                            const bool copy_constraints)
566 {
567   bPose *outPose;
568   bPoseChannel *pchan;
569   ListBase listb;
570
571   if (!src) {
572     *dst = NULL;
573     return;
574   }
575
576   outPose = MEM_callocN(sizeof(bPose), "pose");
577
578   BLI_duplicatelist(&outPose->chanbase, &src->chanbase);
579
580   /* Rebuild ghash here too, so that name lookups below won't be too bad...
581    * BUT this will have the penalty that the ghash will be built twice
582    * if BKE_pose_rebuild() gets called after this...
583    */
584   if (outPose->chanbase.first != outPose->chanbase.last) {
585     outPose->chanhash = NULL;
586     BKE_pose_channels_hash_make(outPose);
587   }
588
589   outPose->iksolver = src->iksolver;
590   outPose->ikdata = NULL;
591   outPose->ikparam = MEM_dupallocN(src->ikparam);
592   outPose->avs = src->avs;
593
594   for (pchan = outPose->chanbase.first; pchan; pchan = pchan->next) {
595     if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
596       id_us_plus((ID *)pchan->custom);
597     }
598
599     /* warning, O(n2) here, if done without the hash, but these are rarely used features. */
600     if (pchan->custom_tx) {
601       pchan->custom_tx = BKE_pose_channel_find_name(outPose, pchan->custom_tx->name);
602     }
603     if (pchan->bbone_prev) {
604       pchan->bbone_prev = BKE_pose_channel_find_name(outPose, pchan->bbone_prev->name);
605     }
606     if (pchan->bbone_next) {
607       pchan->bbone_next = BKE_pose_channel_find_name(outPose, pchan->bbone_next->name);
608     }
609
610     if (copy_constraints) {
611       BKE_constraints_copy_ex(
612           &listb, &pchan->constraints, flag, true);  // BKE_constraints_copy NULLs listb
613       pchan->constraints = listb;
614
615       /* XXX: This is needed for motionpath drawing to work.
616        * Dunno why it was setting to null before... */
617       pchan->mpath = animviz_copy_motionpath(pchan->mpath);
618     }
619
620     if (pchan->prop) {
621       pchan->prop = IDP_CopyProperty_ex(pchan->prop, flag);
622     }
623
624     pchan->draw_data = NULL; /* Drawing cache, no need to copy. */
625
626     /* Runtime data, no need to copy. */
627     memset(&pchan->runtime, 0, sizeof(pchan->runtime));
628   }
629
630   /* for now, duplicate Bone Groups too when doing this */
631   if (copy_constraints) {
632     BLI_duplicatelist(&outPose->agroups, &src->agroups);
633   }
634
635   *dst = outPose;
636 }
637
638 void BKE_pose_copy_data(bPose **dst, const bPose *src, const bool copy_constraints)
639 {
640   BKE_pose_copy_data_ex(dst, src, 0, copy_constraints);
641 }
642
643 void BKE_pose_itasc_init(bItasc *itasc)
644 {
645   if (itasc) {
646     itasc->iksolver = IKSOLVER_ITASC;
647     itasc->minstep = 0.01f;
648     itasc->maxstep = 0.06f;
649     itasc->numiter = 100;
650     itasc->numstep = 4;
651     itasc->precision = 0.005f;
652     itasc->flag = ITASC_AUTO_STEP | ITASC_INITIAL_REITERATION;
653     itasc->feedback = 20.0f;
654     itasc->maxvel = 50.0f;
655     itasc->solver = ITASC_SOLVER_SDLS;
656     itasc->dampmax = 0.5;
657     itasc->dampeps = 0.15;
658   }
659 }
660 void BKE_pose_ikparam_init(bPose *pose)
661 {
662   bItasc *itasc;
663   switch (pose->iksolver) {
664     case IKSOLVER_ITASC:
665       itasc = MEM_callocN(sizeof(bItasc), "itasc");
666       BKE_pose_itasc_init(itasc);
667       pose->ikparam = itasc;
668       break;
669     case IKSOLVER_STANDARD:
670     default:
671       pose->ikparam = NULL;
672       break;
673   }
674 }
675
676 /* only for real IK, not for auto-IK */
677 static bool pose_channel_in_IK_chain(Object *ob, bPoseChannel *pchan, int level)
678 {
679   bConstraint *con;
680   Bone *bone;
681
682   /* No need to check if constraint is active (has influence),
683    * since all constraints with CONSTRAINT_IK_AUTO are active */
684   for (con = pchan->constraints.first; con; con = con->next) {
685     if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
686       bKinematicConstraint *data = con->data;
687       if ((data->rootbone == 0) || (data->rootbone > level)) {
688         if ((data->flag & CONSTRAINT_IK_AUTO) == 0) {
689           return true;
690         }
691       }
692     }
693   }
694   for (bone = pchan->bone->childbase.first; bone; bone = bone->next) {
695     pchan = BKE_pose_channel_find_name(ob->pose, bone->name);
696     if (pchan && pose_channel_in_IK_chain(ob, pchan, level + 1)) {
697       return true;
698     }
699   }
700   return false;
701 }
702
703 bool BKE_pose_channel_in_IK_chain(Object *ob, bPoseChannel *pchan)
704 {
705   return pose_channel_in_IK_chain(ob, pchan, 0);
706 }
707
708 /**
709  * Removes the hash for quick lookup of channels, must
710  * be done when adding/removing channels.
711  */
712 void BKE_pose_channels_hash_make(bPose *pose)
713 {
714   if (!pose->chanhash) {
715     bPoseChannel *pchan;
716
717     pose->chanhash = BLI_ghash_str_new("make_pose_chan gh");
718     for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
719       BLI_ghash_insert(pose->chanhash, pchan->name, pchan);
720     }
721   }
722 }
723
724 void BKE_pose_channels_hash_free(bPose *pose)
725 {
726   if (pose->chanhash) {
727     BLI_ghash_free(pose->chanhash, NULL, NULL);
728     pose->chanhash = NULL;
729   }
730 }
731
732 /**
733  * Selectively remove pose channels.
734  */
735 void BKE_pose_channels_remove(Object *ob,
736                               bool (*filter_fn)(const char *bone_name, void *user_data),
737                               void *user_data)
738 {
739   /* Erase any associated pose channel, along with any references to them */
740   if (ob->pose) {
741     bPoseChannel *pchan, *pchan_next;
742     bConstraint *con;
743
744     for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan_next) {
745       pchan_next = pchan->next;
746
747       if (filter_fn(pchan->name, user_data)) {
748         /* Bone itself is being removed */
749         BKE_pose_channel_free(pchan);
750         if (ob->pose->chanhash) {
751           BLI_ghash_remove(ob->pose->chanhash, pchan->name, NULL, NULL);
752         }
753         BLI_freelinkN(&ob->pose->chanbase, pchan);
754       }
755       else {
756         /* Maybe something the bone references is being removed instead? */
757         for (con = pchan->constraints.first; con; con = con->next) {
758           const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
759           ListBase targets = {NULL, NULL};
760           bConstraintTarget *ct;
761
762           if (cti && cti->get_constraint_targets) {
763             cti->get_constraint_targets(con, &targets);
764
765             for (ct = targets.first; ct; ct = ct->next) {
766               if (ct->tar == ob) {
767                 if (ct->subtarget[0]) {
768                   if (filter_fn(ct->subtarget, user_data)) {
769                     con->flag |= CONSTRAINT_DISABLE;
770                     ct->subtarget[0] = 0;
771                   }
772                 }
773               }
774             }
775
776             if (cti->flush_constraint_targets) {
777               cti->flush_constraint_targets(con, &targets, 0);
778             }
779           }
780         }
781
782         if (pchan->bbone_prev) {
783           if (filter_fn(pchan->bbone_prev->name, user_data)) {
784             pchan->bbone_prev = NULL;
785           }
786         }
787         if (pchan->bbone_next) {
788           if (filter_fn(pchan->bbone_next->name, user_data)) {
789             pchan->bbone_next = NULL;
790           }
791         }
792
793         if (pchan->custom_tx) {
794           if (filter_fn(pchan->custom_tx->name, user_data)) {
795             pchan->custom_tx = NULL;
796           }
797         }
798       }
799     }
800   }
801 }
802
803 /**
804  * Deallocates a pose channel.
805  * Does not free the pose channel itself.
806  */
807 void BKE_pose_channel_free_ex(bPoseChannel *pchan, bool do_id_user)
808 {
809   if (pchan->custom) {
810     if (do_id_user) {
811       id_us_min(&pchan->custom->id);
812     }
813     pchan->custom = NULL;
814   }
815
816   if (pchan->mpath) {
817     animviz_free_motionpath(pchan->mpath);
818     pchan->mpath = NULL;
819   }
820
821   BKE_constraints_free_ex(&pchan->constraints, do_id_user);
822
823   if (pchan->prop) {
824     IDP_FreeProperty(pchan->prop);
825     MEM_freeN(pchan->prop);
826   }
827
828   /* Cached data, for new draw manager rendering code. */
829   MEM_SAFE_FREE(pchan->draw_data);
830
831   /* Cached B-Bone shape and other data. */
832   BKE_pose_channel_runtime_free(&pchan->runtime);
833 }
834
835 /** Clears the runtime cache of a pose channel without free. */
836 void BKE_pose_channel_runtime_reset(bPoseChannel_Runtime *runtime)
837 {
838   memset(runtime, 0, sizeof(*runtime));
839 }
840
841 /** Deallocates runtime cache of a pose channel */
842 void BKE_pose_channel_runtime_free(bPoseChannel_Runtime *runtime)
843 {
844   BKE_pose_channel_free_bbone_cache(runtime);
845 }
846
847 /** Deallocates runtime cache of a pose channel's B-Bone shape. */
848 void BKE_pose_channel_free_bbone_cache(bPoseChannel_Runtime *runtime)
849 {
850   runtime->bbone_segments = 0;
851   MEM_SAFE_FREE(runtime->bbone_rest_mats);
852   MEM_SAFE_FREE(runtime->bbone_pose_mats);
853   MEM_SAFE_FREE(runtime->bbone_deform_mats);
854   MEM_SAFE_FREE(runtime->bbone_dual_quats);
855 }
856
857 void BKE_pose_channel_free(bPoseChannel *pchan)
858 {
859   BKE_pose_channel_free_ex(pchan, true);
860 }
861
862 /**
863  * Removes and deallocates all channels from a pose.
864  * Does not free the pose itself.
865  */
866 void BKE_pose_channels_free_ex(bPose *pose, bool do_id_user)
867 {
868   bPoseChannel *pchan;
869
870   if (pose->chanbase.first) {
871     for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
872       BKE_pose_channel_free_ex(pchan, do_id_user);
873     }
874
875     BLI_freelistN(&pose->chanbase);
876   }
877
878   BKE_pose_channels_hash_free(pose);
879
880   MEM_SAFE_FREE(pose->chan_array);
881 }
882
883 void BKE_pose_channels_free(bPose *pose)
884 {
885   BKE_pose_channels_free_ex(pose, true);
886 }
887
888 void BKE_pose_free_data_ex(bPose *pose, bool do_id_user)
889 {
890   /* free pose-channels */
891   BKE_pose_channels_free_ex(pose, do_id_user);
892
893   /* free pose-groups */
894   if (pose->agroups.first) {
895     BLI_freelistN(&pose->agroups);
896   }
897
898   /* free IK solver state */
899   BIK_clear_data(pose);
900
901   /* free IK solver param */
902   if (pose->ikparam) {
903     MEM_freeN(pose->ikparam);
904   }
905 }
906
907 void BKE_pose_free_data(bPose *pose)
908 {
909   BKE_pose_free_data_ex(pose, true);
910 }
911
912 /**
913  * Removes and deallocates all data from a pose, and also frees the pose.
914  */
915 void BKE_pose_free_ex(bPose *pose, bool do_id_user)
916 {
917   if (pose) {
918     BKE_pose_free_data_ex(pose, do_id_user);
919     /* free pose */
920     MEM_freeN(pose);
921   }
922 }
923
924 void BKE_pose_free(bPose *pose)
925 {
926   BKE_pose_free_ex(pose, true);
927 }
928
929 /**
930  * Copy the internal members of each pose channel including constraints
931  * and ID-Props, used when duplicating bones in editmode.
932  * (unlike copy_pose_channel_data which only does posing-related stuff).
933  *
934  * \note use when copying bones in editmode (on returned value from #BKE_pose_channel_verify)
935  */
936 void BKE_pose_channel_copy_data(bPoseChannel *pchan, const bPoseChannel *pchan_from)
937 {
938   /* copy transform locks */
939   pchan->protectflag = pchan_from->protectflag;
940
941   /* copy rotation mode */
942   pchan->rotmode = pchan_from->rotmode;
943
944   /* copy bone group */
945   pchan->agrp_index = pchan_from->agrp_index;
946
947   /* ik (dof) settings */
948   pchan->ikflag = pchan_from->ikflag;
949   copy_v3_v3(pchan->limitmin, pchan_from->limitmin);
950   copy_v3_v3(pchan->limitmax, pchan_from->limitmax);
951   copy_v3_v3(pchan->stiffness, pchan_from->stiffness);
952   pchan->ikstretch = pchan_from->ikstretch;
953   pchan->ikrotweight = pchan_from->ikrotweight;
954   pchan->iklinweight = pchan_from->iklinweight;
955
956   /* bbone settings (typically not animated) */
957   pchan->bbone_next = pchan_from->bbone_next;
958   pchan->bbone_prev = pchan_from->bbone_prev;
959
960   /* constraints */
961   BKE_constraints_copy(&pchan->constraints, &pchan_from->constraints, true);
962
963   /* id-properties */
964   if (pchan->prop) {
965     /* unlikely but possible it exists */
966     IDP_FreeProperty(pchan->prop);
967     MEM_freeN(pchan->prop);
968     pchan->prop = NULL;
969   }
970   if (pchan_from->prop) {
971     pchan->prop = IDP_CopyProperty(pchan_from->prop);
972   }
973
974   /* custom shape */
975   pchan->custom = pchan_from->custom;
976   if (pchan->custom) {
977     id_us_plus(&pchan->custom->id);
978   }
979
980   pchan->custom_scale = pchan_from->custom_scale;
981 }
982
983 /* checks for IK constraint, Spline IK, and also for Follow-Path constraint.
984  * can do more constraints flags later
985  */
986 /* pose should be entirely OK */
987 void BKE_pose_update_constraint_flags(bPose *pose)
988 {
989   bPoseChannel *pchan, *parchan;
990   bConstraint *con;
991
992   /* clear */
993   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
994     pchan->constflag = 0;
995   }
996   pose->flag &= ~POSE_CONSTRAINTS_TIMEDEPEND;
997
998   /* detect */
999   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
1000     for (con = pchan->constraints.first; con; con = con->next) {
1001       if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
1002         bKinematicConstraint *data = (bKinematicConstraint *)con->data;
1003
1004         pchan->constflag |= PCHAN_HAS_IK;
1005
1006         if (data->tar == NULL || (data->tar->type == OB_ARMATURE && data->subtarget[0] == 0)) {
1007           pchan->constflag |= PCHAN_HAS_TARGET;
1008         }
1009
1010         /* negative rootbone = recalc rootbone index. used in do_versions */
1011         if (data->rootbone < 0) {
1012           data->rootbone = 0;
1013
1014           if (data->flag & CONSTRAINT_IK_TIP) {
1015             parchan = pchan;
1016           }
1017           else {
1018             parchan = pchan->parent;
1019           }
1020
1021           while (parchan) {
1022             data->rootbone++;
1023             if ((parchan->bone->flag & BONE_CONNECTED) == 0) {
1024               break;
1025             }
1026             parchan = parchan->parent;
1027           }
1028         }
1029       }
1030       else if (con->type == CONSTRAINT_TYPE_FOLLOWPATH) {
1031         bFollowPathConstraint *data = (bFollowPathConstraint *)con->data;
1032
1033         /* for drawing constraint colors when color set allows this */
1034         pchan->constflag |= PCHAN_HAS_CONST;
1035
1036         /* if we have a valid target, make sure that this will get updated on frame-change
1037          * (needed for when there is no anim-data for this pose)
1038          */
1039         if ((data->tar) && (data->tar->type == OB_CURVE)) {
1040           pose->flag |= POSE_CONSTRAINTS_TIMEDEPEND;
1041         }
1042       }
1043       else if (con->type == CONSTRAINT_TYPE_SPLINEIK) {
1044         pchan->constflag |= PCHAN_HAS_SPLINEIK;
1045       }
1046       else {
1047         pchan->constflag |= PCHAN_HAS_CONST;
1048       }
1049     }
1050   }
1051   pose->flag &= ~POSE_CONSTRAINTS_NEED_UPDATE_FLAGS;
1052 }
1053
1054 void BKE_pose_tag_update_constraint_flags(bPose *pose)
1055 {
1056   pose->flag |= POSE_CONSTRAINTS_NEED_UPDATE_FLAGS;
1057 }
1058
1059 /* Clears all BONE_UNKEYED flags for every pose channel in every pose
1060  * This should only be called on frame changing, when it is acceptable to
1061  * do this. Otherwise, these flags should not get cleared as poses may get lost.
1062  */
1063 void framechange_poses_clear_unkeyed(Main *bmain)
1064 {
1065   Object *ob;
1066   bPose *pose;
1067   bPoseChannel *pchan;
1068
1069   /* This needs to be done for each object that has a pose */
1070   /* TODO: proxies may/may not be correctly handled here... (this needs checking) */
1071   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1072     /* we only need to do this on objects with a pose */
1073     if ((pose = ob->pose)) {
1074       for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
1075         if (pchan->bone) {
1076           pchan->bone->flag &= ~BONE_UNKEYED;
1077         }
1078       }
1079     }
1080   }
1081 }
1082
1083 /* ************************** Bone Groups ************************** */
1084
1085 /* Adds a new bone-group (name may be NULL) */
1086 bActionGroup *BKE_pose_add_group(bPose *pose, const char *name)
1087 {
1088   bActionGroup *grp;
1089
1090   if (!name) {
1091     name = DATA_("Group");
1092   }
1093
1094   grp = MEM_callocN(sizeof(bActionGroup), "PoseGroup");
1095   BLI_strncpy(grp->name, name, sizeof(grp->name));
1096   BLI_addtail(&pose->agroups, grp);
1097   BLI_uniquename(&pose->agroups, grp, name, '.', offsetof(bActionGroup, name), sizeof(grp->name));
1098
1099   pose->active_group = BLI_listbase_count(&pose->agroups);
1100
1101   return grp;
1102 }
1103
1104 /* Remove the given bone-group (expects 'virtual' index (+1 one, used by active_group etc.))
1105  * index might be invalid ( < 1), in which case it will be find from grp. */
1106 void BKE_pose_remove_group(bPose *pose, bActionGroup *grp, const int index)
1107 {
1108   bPoseChannel *pchan;
1109   int idx = index;
1110
1111   if (idx < 1) {
1112     idx = BLI_findindex(&pose->agroups, grp) + 1;
1113   }
1114
1115   BLI_assert(idx > 0);
1116
1117   /* adjust group references (the trouble of using indices!):
1118    * - firstly, make sure nothing references it
1119    * - also, make sure that those after this item get corrected
1120    */
1121   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
1122     if (pchan->agrp_index == idx) {
1123       pchan->agrp_index = 0;
1124     }
1125     else if (pchan->agrp_index > idx) {
1126       pchan->agrp_index--;
1127     }
1128   }
1129
1130   /* now, remove it from the pose */
1131   BLI_freelinkN(&pose->agroups, grp);
1132   if (pose->active_group >= idx) {
1133     const bool has_groups = !BLI_listbase_is_empty(&pose->agroups);
1134     pose->active_group--;
1135     if (pose->active_group == 0 && has_groups) {
1136       pose->active_group = 1;
1137     }
1138     else if (pose->active_group < 0 || !has_groups) {
1139       pose->active_group = 0;
1140     }
1141   }
1142 }
1143
1144 /* Remove the indexed bone-group (expects 'virtual' index (+1 one, used by active_group etc.)) */
1145 void BKE_pose_remove_group_index(bPose *pose, const int index)
1146 {
1147   bActionGroup *grp = NULL;
1148
1149   /* get group to remove */
1150   grp = BLI_findlink(&pose->agroups, index - 1);
1151   if (grp) {
1152     BKE_pose_remove_group(pose, grp, index);
1153   }
1154 }
1155
1156 /* ************** F-Curve Utilities for Actions ****************** */
1157
1158 /* Check if the given action has any keyframes */
1159 bool action_has_motion(const bAction *act)
1160 {
1161   FCurve *fcu;
1162
1163   /* return on the first F-Curve that has some keyframes/samples defined */
1164   if (act) {
1165     for (fcu = act->curves.first; fcu; fcu = fcu->next) {
1166       if (fcu->totvert) {
1167         return true;
1168       }
1169     }
1170   }
1171
1172   /* nothing found */
1173   return false;
1174 }
1175
1176 /* Calculate the extents of given action */
1177 void calc_action_range(const bAction *act, float *start, float *end, short incl_modifiers)
1178 {
1179   FCurve *fcu;
1180   float min = 999999999.0f, max = -999999999.0f;
1181   short foundvert = 0, foundmod = 0;
1182
1183   if (act) {
1184     for (fcu = act->curves.first; fcu; fcu = fcu->next) {
1185       /* if curve has keyframes, consider them first */
1186       if (fcu->totvert) {
1187         float nmin, nmax;
1188
1189         /* get extents for this curve
1190          * - no "selected only", since this is often used in the backend
1191          * - no "minimum length" (we will apply this later), otherwise
1192          *   single-keyframe curves will increase the overall length by
1193          *   a phantom frame (T50354)
1194          */
1195         calc_fcurve_range(fcu, &nmin, &nmax, false, false);
1196
1197         /* compare to the running tally */
1198         min = min_ff(min, nmin);
1199         max = max_ff(max, nmax);
1200
1201         foundvert = 1;
1202       }
1203
1204       /* if incl_modifiers is enabled, need to consider modifiers too
1205        * - only really care about the last modifier
1206        */
1207       if ((incl_modifiers) && (fcu->modifiers.last)) {
1208         FModifier *fcm = fcu->modifiers.last;
1209
1210         /* only use the maximum sensible limits of the modifiers if they are more extreme */
1211         switch (fcm->type) {
1212           case FMODIFIER_TYPE_LIMITS: /* Limits F-Modifier */
1213           {
1214             FMod_Limits *fmd = (FMod_Limits *)fcm->data;
1215
1216             if (fmd->flag & FCM_LIMIT_XMIN) {
1217               min = min_ff(min, fmd->rect.xmin);
1218             }
1219             if (fmd->flag & FCM_LIMIT_XMAX) {
1220               max = max_ff(max, fmd->rect.xmax);
1221             }
1222             break;
1223           }
1224           case FMODIFIER_TYPE_CYCLES: /* Cycles F-Modifier */
1225           {
1226             FMod_Cycles *fmd = (FMod_Cycles *)fcm->data;
1227
1228             if (fmd->before_mode != FCM_EXTRAPOLATE_NONE) {
1229               min = MINAFRAMEF;
1230             }
1231             if (fmd->after_mode != FCM_EXTRAPOLATE_NONE) {
1232               max = MAXFRAMEF;
1233             }
1234             break;
1235           }
1236             /* TODO: function modifier may need some special limits */
1237
1238           default: /* all other standard modifiers are on the infinite range... */
1239             min = MINAFRAMEF;
1240             max = MAXFRAMEF;
1241             break;
1242         }
1243
1244         foundmod = 1;
1245       }
1246     }
1247   }
1248
1249   if (foundvert || foundmod) {
1250     /* ensure that action is at least 1 frame long (for NLA strips to have a valid length) */
1251     if (min == max) {
1252       max += 1.0f;
1253     }
1254
1255     *start = min;
1256     *end = max;
1257   }
1258   else {
1259     *start = 0.0f;
1260     *end = 1.0f;
1261   }
1262 }
1263
1264 /* Return flags indicating which transforms the given object/posechannel has
1265  * - if 'curves' is provided, a list of links to these curves are also returned
1266  */
1267 short action_get_item_transforms(bAction *act, Object *ob, bPoseChannel *pchan, ListBase *curves)
1268 {
1269   PointerRNA ptr;
1270   FCurve *fcu;
1271   char *basePath = NULL;
1272   short flags = 0;
1273
1274   /* build PointerRNA from provided data to obtain the paths to use */
1275   if (pchan) {
1276     RNA_pointer_create((ID *)ob, &RNA_PoseBone, pchan, &ptr);
1277   }
1278   else if (ob) {
1279     RNA_id_pointer_create((ID *)ob, &ptr);
1280   }
1281   else {
1282     return 0;
1283   }
1284
1285   /* get the basic path to the properties of interest */
1286   basePath = RNA_path_from_ID_to_struct(&ptr);
1287   if (basePath == NULL) {
1288     return 0;
1289   }
1290
1291   /* search F-Curves for the given properties
1292    * - we cannot use the groups, since they may not be grouped in that way...
1293    */
1294   for (fcu = act->curves.first; fcu; fcu = fcu->next) {
1295     const char *bPtr = NULL, *pPtr = NULL;
1296
1297     /* If enough flags have been found,
1298      * we can stop checking unless we're also getting the curves. */
1299     if ((flags == ACT_TRANS_ALL) && (curves == NULL)) {
1300       break;
1301     }
1302
1303     /* just in case... */
1304     if (fcu->rna_path == NULL) {
1305       continue;
1306     }
1307
1308     /* step 1: check for matching base path */
1309     bPtr = strstr(fcu->rna_path, basePath);
1310
1311     if (bPtr) {
1312       /* we must add len(basePath) bytes to the match so that we are at the end of the
1313        * base path so that we don't get false positives with these strings in the names
1314        */
1315       bPtr += strlen(basePath);
1316
1317       /* step 2: check for some property with transforms
1318        * - to speed things up, only check for the ones not yet found
1319        *   unless we're getting the curves too
1320        * - if we're getting the curves, the BLI_genericNodeN() creates a LinkData
1321        *   node wrapping the F-Curve, which then gets added to the list
1322        * - once a match has been found, the curve cannot possibly be any other one
1323        */
1324       if ((curves) || (flags & ACT_TRANS_LOC) == 0) {
1325         pPtr = strstr(bPtr, "location");
1326         if (pPtr) {
1327           flags |= ACT_TRANS_LOC;
1328
1329           if (curves) {
1330             BLI_addtail(curves, BLI_genericNodeN(fcu));
1331           }
1332           continue;
1333         }
1334       }
1335
1336       if ((curves) || (flags & ACT_TRANS_SCALE) == 0) {
1337         pPtr = strstr(bPtr, "scale");
1338         if (pPtr) {
1339           flags |= ACT_TRANS_SCALE;
1340
1341           if (curves) {
1342             BLI_addtail(curves, BLI_genericNodeN(fcu));
1343           }
1344           continue;
1345         }
1346       }
1347
1348       if ((curves) || (flags & ACT_TRANS_ROT) == 0) {
1349         pPtr = strstr(bPtr, "rotation");
1350         if (pPtr) {
1351           flags |= ACT_TRANS_ROT;
1352
1353           if (curves) {
1354             BLI_addtail(curves, BLI_genericNodeN(fcu));
1355           }
1356           continue;
1357         }
1358       }
1359
1360       if ((curves) || (flags & ACT_TRANS_BBONE) == 0) {
1361         /* bbone shape properties */
1362         pPtr = strstr(bPtr, "bbone_");
1363         if (pPtr) {
1364           flags |= ACT_TRANS_BBONE;
1365
1366           if (curves) {
1367             BLI_addtail(curves, BLI_genericNodeN(fcu));
1368           }
1369           continue;
1370         }
1371       }
1372
1373       if ((curves) || (flags & ACT_TRANS_PROP) == 0) {
1374         /* custom properties only */
1375         pPtr = strstr(
1376             bPtr,
1377             "[\""); /* extra '"' comment here to keep my texteditor functionlist working :) */
1378         if (pPtr) {
1379           flags |= ACT_TRANS_PROP;
1380
1381           if (curves) {
1382             BLI_addtail(curves, BLI_genericNodeN(fcu));
1383           }
1384           continue;
1385         }
1386       }
1387     }
1388   }
1389
1390   /* free basePath */
1391   MEM_freeN(basePath);
1392
1393   /* return flags found */
1394   return flags;
1395 }
1396
1397 /* ************** Pose Management Tools ****************** */
1398
1399 /* for do_all_pose_actions, clears the pose. Now also exported for proxy and tools */
1400 void BKE_pose_rest(bPose *pose)
1401 {
1402   bPoseChannel *pchan;
1403
1404   if (!pose) {
1405     return;
1406   }
1407
1408   memset(pose->stride_offset, 0, sizeof(pose->stride_offset));
1409   memset(pose->cyclic_offset, 0, sizeof(pose->cyclic_offset));
1410
1411   for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
1412     zero_v3(pchan->loc);
1413     zero_v3(pchan->eul);
1414     unit_qt(pchan->quat);
1415     unit_axis_angle(pchan->rotAxis, &pchan->rotAngle);
1416     pchan->size[0] = pchan->size[1] = pchan->size[2] = 1.0f;
1417
1418     pchan->roll1 = pchan->roll2 = 0.0f;
1419     pchan->curve_in_x = pchan->curve_in_y = 0.0f;
1420     pchan->curve_out_x = pchan->curve_out_y = 0.0f;
1421     pchan->ease1 = pchan->ease2 = 0.0f;
1422     pchan->scale_in_x = pchan->scale_in_y = 1.0f;
1423     pchan->scale_out_x = pchan->scale_out_y = 1.0f;
1424
1425     pchan->flag &= ~(POSE_LOC | POSE_ROT | POSE_SIZE | POSE_BBONE_SHAPE);
1426   }
1427 }
1428
1429 void BKE_pose_copyesult_pchan_result(bPoseChannel *pchanto, const bPoseChannel *pchanfrom)
1430 {
1431   copy_m4_m4(pchanto->pose_mat, pchanfrom->pose_mat);
1432   copy_m4_m4(pchanto->chan_mat, pchanfrom->chan_mat);
1433
1434   /* used for local constraints */
1435   copy_v3_v3(pchanto->loc, pchanfrom->loc);
1436   copy_qt_qt(pchanto->quat, pchanfrom->quat);
1437   copy_v3_v3(pchanto->eul, pchanfrom->eul);
1438   copy_v3_v3(pchanto->size, pchanfrom->size);
1439
1440   copy_v3_v3(pchanto->pose_head, pchanfrom->pose_head);
1441   copy_v3_v3(pchanto->pose_tail, pchanfrom->pose_tail);
1442
1443   pchanto->roll1 = pchanfrom->roll1;
1444   pchanto->roll2 = pchanfrom->roll2;
1445   pchanto->curve_in_x = pchanfrom->curve_in_x;
1446   pchanto->curve_in_y = pchanfrom->curve_in_y;
1447   pchanto->curve_out_x = pchanfrom->curve_out_x;
1448   pchanto->curve_out_y = pchanfrom->curve_out_y;
1449   pchanto->ease1 = pchanfrom->ease1;
1450   pchanto->ease2 = pchanfrom->ease2;
1451   pchanto->scale_in_x = pchanfrom->scale_in_x;
1452   pchanto->scale_in_y = pchanfrom->scale_in_y;
1453   pchanto->scale_out_x = pchanfrom->scale_out_x;
1454   pchanto->scale_out_y = pchanfrom->scale_out_y;
1455
1456   pchanto->rotmode = pchanfrom->rotmode;
1457   pchanto->flag = pchanfrom->flag;
1458   pchanto->protectflag = pchanfrom->protectflag;
1459 }
1460
1461 /* both poses should be in sync */
1462 bool BKE_pose_copy_result(bPose *to, bPose *from)
1463 {
1464   bPoseChannel *pchanto, *pchanfrom;
1465
1466   if (to == NULL || from == NULL) {
1467     CLOG_ERROR(
1468         &LOG, "Pose copy error, pose to:%p from:%p", (void *)to, (void *)from); /* debug temp */
1469     return false;
1470   }
1471
1472   if (to == from) {
1473     CLOG_ERROR(&LOG, "source and target are the same");
1474     return false;
1475   }
1476
1477   for (pchanfrom = from->chanbase.first; pchanfrom; pchanfrom = pchanfrom->next) {
1478     pchanto = BKE_pose_channel_find_name(to, pchanfrom->name);
1479     if (pchanto != NULL) {
1480       BKE_pose_copyesult_pchan_result(pchanto, pchanfrom);
1481     }
1482   }
1483   return true;
1484 }
1485
1486 /* Tag pose for recalc. Also tag all related data to be recalc. */
1487 void BKE_pose_tag_recalc(Main *bmain, bPose *pose)
1488 {
1489   pose->flag |= POSE_RECALC;
1490   /* Depsgraph components depends on actual pose state,
1491    * if pose was changed depsgraph is to be updated as well.
1492    */
1493   DEG_relations_tag_update(bmain);
1494 }
1495
1496 /* For the calculation of the effects of an Action at the given frame on an object
1497  * This is currently only used for the Action Constraint
1498  */
1499 void what_does_obaction(
1500     Object *ob, Object *workob, bPose *pose, bAction *act, char groupname[], float cframe)
1501 {
1502   bActionGroup *agrp = BKE_action_group_find_name(act, groupname);
1503
1504   /* clear workob */
1505   BKE_object_workob_clear(workob);
1506
1507   /* init workob */
1508   copy_m4_m4(workob->obmat, ob->obmat);
1509   copy_m4_m4(workob->parentinv, ob->parentinv);
1510   copy_m4_m4(workob->constinv, ob->constinv);
1511   workob->parent = ob->parent;
1512
1513   workob->rotmode = ob->rotmode;
1514
1515   workob->trackflag = ob->trackflag;
1516   workob->upflag = ob->upflag;
1517
1518   workob->partype = ob->partype;
1519   workob->par1 = ob->par1;
1520   workob->par2 = ob->par2;
1521   workob->par3 = ob->par3;
1522
1523   workob->constraints.first = ob->constraints.first;
1524   workob->constraints.last = ob->constraints.last;
1525
1526   workob->pose =
1527       pose; /* need to set pose too, since this is used for both types of Action Constraint */
1528   if (pose) {
1529     /* This function is most likely to be used with a temporary pose with a single bone in there.
1530      * For such cases it makes no sense to create hash since it'll only waste CPU ticks on memory
1531      * allocation and also will make lookup slower.
1532      */
1533     if (pose->chanbase.first != pose->chanbase.last) {
1534       BKE_pose_channels_hash_make(pose);
1535     }
1536     if (pose->flag & POSE_CONSTRAINTS_NEED_UPDATE_FLAGS) {
1537       BKE_pose_update_constraint_flags(pose);
1538     }
1539   }
1540
1541   BLI_strncpy(workob->parsubstr, ob->parsubstr, sizeof(workob->parsubstr));
1542
1543   /* we don't use real object name, otherwise RNA screws with the real thing */
1544   BLI_strncpy(workob->id.name, "OB<ConstrWorkOb>", sizeof(workob->id.name));
1545
1546   /* If we're given a group to use, it's likely to be more efficient
1547    * (though a bit more dangerous). */
1548   if (agrp) {
1549     /* specifically evaluate this group only */
1550     PointerRNA id_ptr;
1551
1552     /* get RNA-pointer for the workob's ID */
1553     RNA_id_pointer_create(&workob->id, &id_ptr);
1554
1555     /* execute action for this group only */
1556     animsys_evaluate_action_group(&id_ptr, act, agrp, cframe);
1557   }
1558   else {
1559     AnimData adt = {NULL};
1560
1561     /* init animdata, and attach to workob */
1562     workob->adt = &adt;
1563
1564     adt.action = act;
1565
1566     /* execute effects of Action on to workob (or it's PoseChannels) */
1567     BKE_animsys_evaluate_animdata(NULL, NULL, &workob->id, &adt, cframe, ADT_RECALC_ANIM);
1568   }
1569 }