Animation: Remove depsgraph argument from a lot of API
[blender.git] / source / blender / blenkernel / intern / anim_sys.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) 2009 Blender Foundation, Joshua Leung
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdio.h>
25 #include <string.h>
26 #include <stddef.h>
27 #include <float.h>
28 #include <math.h>
29
30 #include "MEM_guardedalloc.h"
31
32 #include "BLI_utildefines.h"
33 #include "BLI_blenlib.h"
34 #include "BLI_alloca.h"
35 #include "BLI_dynstr.h"
36 #include "BLI_listbase.h"
37 #include "BLI_string_utils.h"
38 #include "BLI_math_rotation.h"
39 #include "BLI_math_vector.h"
40
41 #include "BLT_translation.h"
42
43 #include "DNA_anim_types.h"
44 #include "DNA_light_types.h"
45 #include "DNA_material_types.h"
46 #include "DNA_object_types.h"
47 #include "DNA_scene_types.h"
48 #include "DNA_screen_types.h"
49 #include "DNA_space_types.h"
50 #include "DNA_texture_types.h"
51 #include "DNA_world_types.h"
52
53 #include "BKE_action.h"
54 #include "BKE_animsys.h"
55 #include "BKE_context.h"
56 #include "BKE_fcurve.h"
57 #include "BKE_global.h"
58 #include "BKE_library.h"
59 #include "BKE_main.h"
60 #include "BKE_material.h"
61 #include "BKE_nla.h"
62 #include "BKE_node.h"
63 #include "BKE_report.h"
64 #include "BKE_texture.h"
65
66 #include "DEG_depsgraph.h"
67 #include "DEG_depsgraph_query.h"
68
69 #include "RNA_access.h"
70
71 #include "nla_private.h"
72
73 #include "atomic_ops.h"
74
75 #include "CLG_log.h"
76
77 static CLG_LogRef LOG = {"bke.anim_sys"};
78
79 /* ***************************************** */
80 /* AnimData API */
81
82 /* Getter/Setter -------------------------------------------- */
83
84 /* Check if ID can have AnimData */
85 bool id_type_can_have_animdata(const short id_type)
86 {
87   /* Only some ID-blocks have this info for now */
88   /* TODO: finish adding this for the other blocktypes */
89   switch (id_type) {
90     /* has AnimData */
91     case ID_OB:
92     case ID_ME:
93     case ID_MB:
94     case ID_CU:
95     case ID_AR:
96     case ID_LT:
97     case ID_KE:
98     case ID_PA:
99     case ID_MA:
100     case ID_TE:
101     case ID_NT:
102     case ID_LA:
103     case ID_CA:
104     case ID_WO:
105     case ID_LS:
106     case ID_LP:
107     case ID_SPK:
108     case ID_SCE:
109     case ID_MC:
110     case ID_MSK:
111     case ID_GD:
112     case ID_CF:
113       return true;
114
115     /* no AnimData */
116     default:
117       return false;
118   }
119 }
120
121 bool id_can_have_animdata(const ID *id)
122 {
123   /* sanity check */
124   if (id == NULL) {
125     return false;
126   }
127
128   return id_type_can_have_animdata(GS(id->name));
129 }
130
131 /* Get AnimData from the given ID-block. In order for this to work, we assume that
132  * the AnimData pointer is stored immediately after the given ID-block in the struct,
133  * as per IdAdtTemplate.
134  */
135 AnimData *BKE_animdata_from_id(ID *id)
136 {
137   /* only some ID-blocks have this info for now, so we cast the
138    * types that do to be of type IdAdtTemplate, and extract the
139    * AnimData that way
140    */
141   if (id_can_have_animdata(id)) {
142     IdAdtTemplate *iat = (IdAdtTemplate *)id;
143     return iat->adt;
144   }
145   else {
146     return NULL;
147   }
148 }
149
150 /* Add AnimData to the given ID-block. In order for this to work, we assume that
151  * the AnimData pointer is stored immediately after the given ID-block in the struct,
152  * as per IdAdtTemplate. Also note that
153  */
154 AnimData *BKE_animdata_add_id(ID *id)
155 {
156   /* Only some ID-blocks have this info for now, so we cast the
157    * types that do to be of type IdAdtTemplate, and add the AnimData
158    * to it using the template
159    */
160   if (id_can_have_animdata(id)) {
161     IdAdtTemplate *iat = (IdAdtTemplate *)id;
162
163     /* check if there's already AnimData, in which case, don't add */
164     if (iat->adt == NULL) {
165       AnimData *adt;
166
167       /* add animdata */
168       adt = iat->adt = MEM_callocN(sizeof(AnimData), "AnimData");
169
170       /* set default settings */
171       adt->act_influence = 1.0f;
172     }
173
174     return iat->adt;
175   }
176   else {
177     return NULL;
178   }
179 }
180
181 /* Action Setter --------------------------------------- */
182
183 /** Called when user tries to change the active action of an AnimData block
184  * (via RNA, Outliner, etc.) */
185 bool BKE_animdata_set_action(ReportList *reports, ID *id, bAction *act)
186 {
187   AnimData *adt = BKE_animdata_from_id(id);
188   bool ok = false;
189
190   /* animdata validity check */
191   if (adt == NULL) {
192     BKE_report(reports, RPT_WARNING, "No AnimData to set action on");
193     return ok;
194   }
195
196   /* active action is only editable when it is not a tweaking strip
197    * see rna_AnimData_action_editable() in rna_animation.c
198    */
199   if ((adt->flag & ADT_NLA_EDIT_ON) || (adt->actstrip) || (adt->tmpact)) {
200     /* cannot remove, otherwise things turn to custard */
201     BKE_report(reports, RPT_ERROR, "Cannot change action, as it is still being edited in NLA");
202     return ok;
203   }
204
205   /* manage usercount for current action */
206   if (adt->action) {
207     id_us_min((ID *)adt->action);
208   }
209
210   /* assume that AnimData's action can in fact be edited... */
211   if (act) {
212     /* action must have same type as owner */
213     if (ELEM(act->idroot, 0, GS(id->name))) {
214       /* can set */
215       adt->action = act;
216       id_us_plus((ID *)adt->action);
217       ok = true;
218     }
219     else {
220       /* cannot set */
221       BKE_reportf(
222           reports,
223           RPT_ERROR,
224           "Could not set action '%s' onto ID '%s', as it does not have suitably rooted paths "
225           "for this purpose",
226           act->id.name + 2,
227           id->name);
228       /* ok = false; */
229     }
230   }
231   else {
232     /* just clearing the action... */
233     adt->action = NULL;
234     ok = true;
235   }
236
237   return ok;
238 }
239
240 /* Freeing -------------------------------------------- */
241
242 /* Free AnimData used by the nominated ID-block, and clear ID-block's AnimData pointer */
243 void BKE_animdata_free(ID *id, const bool do_id_user)
244 {
245   /* Only some ID-blocks have this info for now, so we cast the
246    * types that do to be of type IdAdtTemplate
247    */
248   if (id_can_have_animdata(id)) {
249     IdAdtTemplate *iat = (IdAdtTemplate *)id;
250     AnimData *adt = iat->adt;
251
252     /* check if there's any AnimData to start with */
253     if (adt) {
254       if (do_id_user) {
255         /* unlink action (don't free, as it's in its own list) */
256         if (adt->action) {
257           id_us_min(&adt->action->id);
258         }
259         /* same goes for the temporarily displaced action */
260         if (adt->tmpact) {
261           id_us_min(&adt->tmpact->id);
262         }
263       }
264
265       /* free nla data */
266       BKE_nla_tracks_free(&adt->nla_tracks, do_id_user);
267
268       /* free drivers - stored as a list of F-Curves */
269       free_fcurves(&adt->drivers);
270
271       /* free driver array cache */
272       MEM_SAFE_FREE(adt->driver_array);
273
274       /* free overrides */
275       /* TODO... */
276
277       /* free animdata now */
278       MEM_freeN(adt);
279       iat->adt = NULL;
280     }
281   }
282 }
283
284 /* Copying -------------------------------------------- */
285
286 /**
287  * Make a copy of the given AnimData - to be used when copying data-blocks.
288  * \param flag: Control ID pointers management,
289  * see LIB_ID_CREATE_.../LIB_ID_COPY_... flags in BKE_library.h
290  * \return The copied animdata.
291  */
292 AnimData *BKE_animdata_copy(Main *bmain, AnimData *adt, const int flag)
293 {
294   AnimData *dadt;
295
296   const bool do_action = (flag & LIB_ID_COPY_ACTIONS) != 0 && (flag & LIB_ID_CREATE_NO_MAIN) == 0;
297   const bool do_id_user = (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0;
298
299   /* sanity check before duplicating struct */
300   if (adt == NULL) {
301     return NULL;
302   }
303   dadt = MEM_dupallocN(adt);
304
305   /* make a copy of action - at worst, user has to delete copies... */
306   if (do_action) {
307     BLI_assert(bmain != NULL);
308     BKE_id_copy(bmain, (ID *)dadt->action, (ID **)&dadt->action);
309     BKE_id_copy(bmain, (ID *)dadt->tmpact, (ID **)&dadt->tmpact);
310   }
311   else if (do_id_user) {
312     id_us_plus((ID *)dadt->action);
313     id_us_plus((ID *)dadt->tmpact);
314   }
315
316   /* duplicate NLA data */
317   BKE_nla_tracks_copy(bmain, &dadt->nla_tracks, &adt->nla_tracks, flag);
318
319   /* duplicate drivers (F-Curves) */
320   copy_fcurves(&dadt->drivers, &adt->drivers);
321   dadt->driver_array = NULL;
322
323   /* don't copy overrides */
324   BLI_listbase_clear(&dadt->overrides);
325
326   /* return */
327   return dadt;
328 }
329
330 /**
331  * \param flag: Control ID pointers management,
332  * see LIB_ID_CREATE_.../LIB_ID_COPY_... flags in BKE_library.h
333  * \return true is succesfully copied.
334  */
335 bool BKE_animdata_copy_id(Main *bmain, ID *id_to, ID *id_from, const int flag)
336 {
337   AnimData *adt;
338
339   if ((id_to && id_from) && (GS(id_to->name) != GS(id_from->name))) {
340     return false;
341   }
342
343   BKE_animdata_free(id_to, (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0);
344
345   adt = BKE_animdata_from_id(id_from);
346   if (adt) {
347     IdAdtTemplate *iat = (IdAdtTemplate *)id_to;
348     iat->adt = BKE_animdata_copy(bmain, adt, flag);
349   }
350
351   return true;
352 }
353
354 void BKE_animdata_copy_id_action(Main *bmain, ID *id, const bool set_newid)
355 {
356   AnimData *adt = BKE_animdata_from_id(id);
357   if (adt) {
358     if (adt->action) {
359       id_us_min((ID *)adt->action);
360       adt->action = set_newid ? ID_NEW_SET(adt->action, BKE_action_copy(bmain, adt->action)) :
361                                 BKE_action_copy(bmain, adt->action);
362     }
363     if (adt->tmpact) {
364       id_us_min((ID *)adt->tmpact);
365       adt->tmpact = set_newid ? ID_NEW_SET(adt->tmpact, BKE_action_copy(bmain, adt->tmpact)) :
366                                 BKE_action_copy(bmain, adt->tmpact);
367     }
368   }
369   bNodeTree *ntree = ntreeFromID(id);
370   if (ntree) {
371     BKE_animdata_copy_id_action(bmain, &ntree->id, set_newid);
372   }
373 }
374
375 /* Merge copies of the data from the src AnimData into the destination AnimData */
376 void BKE_animdata_merge_copy(
377     Main *bmain, ID *dst_id, ID *src_id, eAnimData_MergeCopy_Modes action_mode, bool fix_drivers)
378 {
379   AnimData *src = BKE_animdata_from_id(src_id);
380   AnimData *dst = BKE_animdata_from_id(dst_id);
381
382   /* sanity checks */
383   if (ELEM(NULL, dst, src)) {
384     return;
385   }
386
387   // TODO: we must unset all "tweakmode" flags
388   if ((src->flag & ADT_NLA_EDIT_ON) || (dst->flag & ADT_NLA_EDIT_ON)) {
389     CLOG_ERROR(
390         &LOG,
391         "Merging AnimData blocks while editing NLA is dangerous as it may cause data corruption");
392     return;
393   }
394
395   /* handle actions... */
396   if (action_mode == ADT_MERGECOPY_SRC_COPY) {
397     /* make a copy of the actions */
398     dst->action = BKE_action_copy(bmain, src->action);
399     dst->tmpact = BKE_action_copy(bmain, src->tmpact);
400   }
401   else if (action_mode == ADT_MERGECOPY_SRC_REF) {
402     /* make a reference to it */
403     dst->action = src->action;
404     id_us_plus((ID *)dst->action);
405
406     dst->tmpact = src->tmpact;
407     id_us_plus((ID *)dst->tmpact);
408   }
409
410   /* duplicate NLA data */
411   if (src->nla_tracks.first) {
412     ListBase tracks = {NULL, NULL};
413
414     BKE_nla_tracks_copy(bmain, &tracks, &src->nla_tracks, 0);
415     BLI_movelisttolist(&dst->nla_tracks, &tracks);
416   }
417
418   /* duplicate drivers (F-Curves) */
419   if (src->drivers.first) {
420     ListBase drivers = {NULL, NULL};
421
422     copy_fcurves(&drivers, &src->drivers);
423
424     /* Fix up all driver targets using the old target id
425      * - This assumes that the src ID is being merged into the dst ID
426      */
427     if (fix_drivers) {
428       FCurve *fcu;
429
430       for (fcu = drivers.first; fcu; fcu = fcu->next) {
431         ChannelDriver *driver = fcu->driver;
432         DriverVar *dvar;
433
434         for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
435           DRIVER_TARGETS_USED_LOOPER_BEGIN (dvar) {
436             if (dtar->id == src_id) {
437               dtar->id = dst_id;
438             }
439           }
440           DRIVER_TARGETS_LOOPER_END;
441         }
442       }
443     }
444
445     BLI_movelisttolist(&dst->drivers, &drivers);
446   }
447 }
448
449 /* Sub-ID Regrouping ------------------------------------------- */
450
451 /**
452  * Helper heuristic for determining if a path is compatible with the basepath
453  *
454  * \param path: Full RNA-path from some data (usually an F-Curve) to compare
455  * \param basepath: Shorter path fragment to look for
456  * \return Whether there is a match
457  */
458 static bool animpath_matches_basepath(const char path[], const char basepath[])
459 {
460   /* we need start of path to be basepath */
461   return (path && basepath) && STRPREFIX(path, basepath);
462 }
463
464 /* Move F-Curves in src action to dst action, setting up all the necessary groups
465  * for this to happen, but only if the F-Curves being moved have the appropriate
466  * "base path".
467  * - This is used when data moves from one data-block to another, causing the
468  *   F-Curves to need to be moved over too
469  */
470 void action_move_fcurves_by_basepath(bAction *srcAct, bAction *dstAct, const char basepath[])
471 {
472   FCurve *fcu, *fcn = NULL;
473
474   /* sanity checks */
475   if (ELEM(NULL, srcAct, dstAct, basepath)) {
476     if (G.debug & G_DEBUG) {
477       CLOG_ERROR(&LOG,
478                  "srcAct: %p, dstAct: %p, basepath: %p has insufficient info to work with",
479                  (void *)srcAct,
480                  (void *)dstAct,
481                  (void *)basepath);
482     }
483     return;
484   }
485
486   /* clear 'temp' flags on all groups in src, as we'll be needing them later
487    * to identify groups that we've managed to empty out here
488    */
489   action_groups_clear_tempflags(srcAct);
490
491   /* iterate over all src F-Curves, moving over the ones that need to be moved */
492   for (fcu = srcAct->curves.first; fcu; fcu = fcn) {
493     /* store next pointer in case we move stuff */
494     fcn = fcu->next;
495
496     /* should F-Curve be moved over?
497      * - we only need the start of the path to match basepath
498      */
499     if (animpath_matches_basepath(fcu->rna_path, basepath)) {
500       bActionGroup *agrp = NULL;
501
502       /* if grouped... */
503       if (fcu->grp) {
504         /* make sure there will be a matching group on the other side for the migrants */
505         agrp = BKE_action_group_find_name(dstAct, fcu->grp->name);
506
507         if (agrp == NULL) {
508           /* add a new one with a similar name (usually will be the same though) */
509           agrp = action_groups_add_new(dstAct, fcu->grp->name);
510         }
511
512         /* old groups should be tagged with 'temp' flags so they can be removed later
513          * if we remove everything from them
514          */
515         fcu->grp->flag |= AGRP_TEMP;
516       }
517
518       /* perform the migration now */
519       action_groups_remove_channel(srcAct, fcu);
520
521       if (agrp) {
522         action_groups_add_channel(dstAct, agrp, fcu);
523       }
524       else {
525         BLI_addtail(&dstAct->curves, fcu);
526       }
527     }
528   }
529
530   /* cleanup groups (if present) */
531   if (srcAct->groups.first) {
532     bActionGroup *agrp, *grp = NULL;
533
534     for (agrp = srcAct->groups.first; agrp; agrp = grp) {
535       grp = agrp->next;
536
537       /* only tagged groups need to be considered - clearing these tags or removing them */
538       if (agrp->flag & AGRP_TEMP) {
539         /* if group is empty and tagged, then we can remove as this operation
540          * moved out all the channels that were formerly here
541          */
542         if (BLI_listbase_is_empty(&agrp->channels)) {
543           BLI_freelinkN(&srcAct->groups, agrp);
544         }
545         else {
546           agrp->flag &= ~AGRP_TEMP;
547         }
548       }
549     }
550   }
551 }
552
553 /* Transfer the animation data from srcID to dstID where the srcID
554  * animation data is based off "basepath", creating new AnimData and
555  * associated data as necessary
556  */
557 void BKE_animdata_separate_by_basepath(Main *bmain, ID *srcID, ID *dstID, ListBase *basepaths)
558 {
559   AnimData *srcAdt = NULL, *dstAdt = NULL;
560   LinkData *ld;
561
562   /* sanity checks */
563   if (ELEM(NULL, srcID, dstID)) {
564     if (G.debug & G_DEBUG) {
565       CLOG_ERROR(&LOG, "no source or destination ID to separate AnimData with");
566     }
567     return;
568   }
569
570   /* get animdata from src, and create for destination (if needed) */
571   srcAdt = BKE_animdata_from_id(srcID);
572   dstAdt = BKE_animdata_add_id(dstID);
573
574   if (ELEM(NULL, srcAdt, dstAdt)) {
575     if (G.debug & G_DEBUG) {
576       CLOG_ERROR(&LOG, "no AnimData for this pair of ID's");
577     }
578     return;
579   }
580
581   /* active action */
582   if (srcAdt->action) {
583     /* Set up an action if necessary,
584      * and name it in a similar way so that it can be easily found again. */
585     if (dstAdt->action == NULL) {
586       dstAdt->action = BKE_action_add(bmain, srcAdt->action->id.name + 2);
587     }
588     else if (dstAdt->action == srcAdt->action) {
589       CLOG_WARN(&LOG,
590                 "Argh! Source and Destination share animation! "
591                 "('%s' and '%s' both use '%s') Making new empty action",
592                 srcID->name,
593                 dstID->name,
594                 srcAdt->action->id.name);
595
596       /* TODO: review this... */
597       id_us_min(&dstAdt->action->id);
598       dstAdt->action = BKE_action_add(bmain, dstAdt->action->id.name + 2);
599     }
600
601     /* loop over base paths, trying to fix for each one... */
602     for (ld = basepaths->first; ld; ld = ld->next) {
603       const char *basepath = (const char *)ld->data;
604       action_move_fcurves_by_basepath(srcAdt->action, dstAdt->action, basepath);
605     }
606   }
607
608   /* drivers */
609   if (srcAdt->drivers.first) {
610     FCurve *fcu, *fcn = NULL;
611
612     /* check each driver against all the base paths to see if any should go */
613     for (fcu = srcAdt->drivers.first; fcu; fcu = fcn) {
614       fcn = fcu->next;
615
616       /* try each basepath in turn, but stop on the first one which works */
617       for (ld = basepaths->first; ld; ld = ld->next) {
618         const char *basepath = (const char *)ld->data;
619
620         if (animpath_matches_basepath(fcu->rna_path, basepath)) {
621           /* just need to change lists */
622           BLI_remlink(&srcAdt->drivers, fcu);
623           BLI_addtail(&dstAdt->drivers, fcu);
624
625           /* TODO: add depsgraph flushing calls? */
626
627           /* can stop now, as moved already */
628           break;
629         }
630       }
631     }
632   }
633 }
634
635 /**
636  * Temporary wrapper for driver operators for buttons to make it easier to create
637  * such drivers by rerouting all paths through the active object instead so that
638  * they will get picked up by the dependency system.
639  *
640  * \param C: Context pointer - for getting active data
641  * \param[in,out] ptr: RNA pointer for property's data-block.
642  * May be modified as result of path remapping.
643  * \param prop: RNA definition of property to add for
644  * \return MEM_alloc'd string representing the path to the property from the given #PointerRNA
645  */
646 char *BKE_animdata_driver_path_hack(bContext *C,
647                                     PointerRNA *ptr,
648                                     PropertyRNA *prop,
649                                     char *base_path)
650 {
651   ID *id = (ID *)ptr->id.data;
652   ScrArea *sa = CTX_wm_area(C);
653
654   /* get standard path which may be extended */
655   char *basepath = base_path ? base_path : RNA_path_from_ID_to_property(ptr, prop);
656   char *path = basepath; /* in case no remapping is needed */
657
658   /* Remapping will only be performed in the Properties Editor, as only this
659    * restricts the subspace of options to the 'active' data (a manageable state)
660    */
661   /* TODO: watch out for pinned context? */
662   if ((sa) && (sa->spacetype == SPACE_PROPERTIES)) {
663     Object *ob = CTX_data_active_object(C);
664
665     if (ob && id) {
666       /* TODO: after material textures were removed, this function serves
667        * no purpose anymore, but could be used again so was not removed. */
668
669       /* fix RNA pointer, as we've now changed the ID root by changing the paths */
670       if (basepath != path) {
671         /* rebase provided pointer so that it starts from object... */
672         RNA_pointer_create(&ob->id, ptr->type, ptr->data, ptr);
673       }
674     }
675   }
676
677   /* the path should now have been corrected for use */
678   return path;
679 }
680
681 /* Path Validation -------------------------------------------- */
682
683 /* Check if a given RNA Path is valid, by tracing it from the given ID,
684  * and seeing if we can resolve it. */
685 static bool check_rna_path_is_valid(ID *owner_id, const char *path)
686 {
687   PointerRNA id_ptr, ptr;
688   PropertyRNA *prop = NULL;
689
690   /* make initial RNA pointer to start resolving from */
691   RNA_id_pointer_create(owner_id, &id_ptr);
692
693   /* try to resolve */
694   return RNA_path_resolve_property(&id_ptr, path, &ptr, &prop);
695 }
696
697 /* Check if some given RNA Path needs fixing - free the given path and set a new one as appropriate
698  * NOTE: we assume that oldName and newName have [" "] padding around them
699  */
700 static char *rna_path_rename_fix(ID *owner_id,
701                                  const char *prefix,
702                                  const char *oldName,
703                                  const char *newName,
704                                  char *oldpath,
705                                  bool verify_paths)
706 {
707   char *prefixPtr = strstr(oldpath, prefix);
708   char *oldNamePtr = strstr(oldpath, oldName);
709   int prefixLen = strlen(prefix);
710   int oldNameLen = strlen(oldName);
711
712   /* only start fixing the path if the prefix and oldName feature in the path,
713    * and prefix occurs immediately before oldName
714    */
715   if ((prefixPtr && oldNamePtr) && (prefixPtr + prefixLen == oldNamePtr)) {
716     /* if we haven't aren't able to resolve the path now, try again after fixing it */
717     if (!verify_paths || check_rna_path_is_valid(owner_id, oldpath) == 0) {
718       DynStr *ds = BLI_dynstr_new();
719       const char *postfixPtr = oldNamePtr + oldNameLen;
720       char *newPath = NULL;
721
722       /* add the part of the string that goes up to the start of the prefix */
723       if (prefixPtr > oldpath) {
724         BLI_dynstr_nappend(ds, oldpath, prefixPtr - oldpath);
725       }
726
727       /* add the prefix */
728       BLI_dynstr_append(ds, prefix);
729
730       /* add the new name (complete with brackets) */
731       BLI_dynstr_append(ds, newName);
732
733       /* add the postfix */
734       BLI_dynstr_append(ds, postfixPtr);
735
736       /* create new path, and cleanup old data */
737       newPath = BLI_dynstr_get_cstring(ds);
738       BLI_dynstr_free(ds);
739
740       /* check if the new path will solve our problems */
741       /* TODO: will need to check whether this step really helps in practice */
742       if (!verify_paths || check_rna_path_is_valid(owner_id, newPath)) {
743         /* free the old path, and return the new one, since we've solved the issues */
744         MEM_freeN(oldpath);
745         return newPath;
746       }
747       else {
748         /* still couldn't resolve the path... so, might as well just leave it alone */
749         MEM_freeN(newPath);
750       }
751     }
752   }
753
754   /* the old path doesn't need to be changed */
755   return oldpath;
756 }
757
758 /* Check RNA-Paths for a list of F-Curves */
759 static bool fcurves_path_rename_fix(ID *owner_id,
760                                     const char *prefix,
761                                     const char *oldName,
762                                     const char *newName,
763                                     const char *oldKey,
764                                     const char *newKey,
765                                     ListBase *curves,
766                                     bool verify_paths)
767 {
768   FCurve *fcu;
769   bool is_changed = false;
770   /* We need to check every curve. */
771   for (fcu = curves->first; fcu; fcu = fcu->next) {
772     if (fcu->rna_path == NULL) {
773       continue;
774     }
775     const char *old_path = fcu->rna_path;
776     /* Firstly, handle the F-Curve's own path. */
777     fcu->rna_path = rna_path_rename_fix(
778         owner_id, prefix, oldKey, newKey, fcu->rna_path, verify_paths);
779     /* if path changed and the F-Curve is grouped, check if its group also needs renaming
780      * (i.e. F-Curve is first of a bone's F-Curves;
781      * hence renaming this should also trigger rename) */
782     if (fcu->rna_path != old_path) {
783       bActionGroup *agrp = fcu->grp;
784       is_changed = true;
785       if ((agrp != NULL) && STREQ(oldName, agrp->name)) {
786         BLI_strncpy(agrp->name, newName, sizeof(agrp->name));
787       }
788     }
789   }
790   return is_changed;
791 }
792
793 /* Check RNA-Paths for a list of Drivers */
794 static bool drivers_path_rename_fix(ID *owner_id,
795                                     ID *ref_id,
796                                     const char *prefix,
797                                     const char *oldName,
798                                     const char *newName,
799                                     const char *oldKey,
800                                     const char *newKey,
801                                     ListBase *curves,
802                                     bool verify_paths)
803 {
804   bool is_changed = false;
805   FCurve *fcu;
806   /* We need to check every curve - drivers are F-Curves too. */
807   for (fcu = curves->first; fcu; fcu = fcu->next) {
808     /* firstly, handle the F-Curve's own path */
809     if (fcu->rna_path != NULL) {
810       const char *old_rna_path = fcu->rna_path;
811       fcu->rna_path = rna_path_rename_fix(
812           owner_id, prefix, oldKey, newKey, fcu->rna_path, verify_paths);
813       is_changed |= (fcu->rna_path != old_rna_path);
814     }
815     if (fcu->driver == NULL) {
816       continue;
817     }
818     ChannelDriver *driver = fcu->driver;
819     DriverVar *dvar;
820     /* driver variables */
821     for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
822       /* only change the used targets, since the others will need fixing manually anyway */
823       DRIVER_TARGETS_USED_LOOPER_BEGIN (dvar) {
824         /* rename RNA path */
825         if (dtar->rna_path && dtar->id) {
826           const char *old_rna_path = dtar->rna_path;
827           dtar->rna_path = rna_path_rename_fix(
828               dtar->id, prefix, oldKey, newKey, dtar->rna_path, verify_paths);
829           is_changed |= (dtar->rna_path != old_rna_path);
830         }
831         /* also fix the bone-name (if applicable) */
832         if (strstr(prefix, "bones")) {
833           if (((dtar->id) && (GS(dtar->id->name) == ID_OB) &&
834                (!ref_id || ((Object *)(dtar->id))->data == ref_id)) &&
835               (dtar->pchan_name[0]) && STREQ(oldName, dtar->pchan_name)) {
836             is_changed = true;
837             BLI_strncpy(dtar->pchan_name, newName, sizeof(dtar->pchan_name));
838           }
839         }
840       }
841       DRIVER_TARGETS_LOOPER_END;
842     }
843   }
844   return is_changed;
845 }
846
847 /* Fix all RNA-Paths for Actions linked to NLA Strips */
848 static bool nlastrips_path_rename_fix(ID *owner_id,
849                                       const char *prefix,
850                                       const char *oldName,
851                                       const char *newName,
852                                       const char *oldKey,
853                                       const char *newKey,
854                                       ListBase *strips,
855                                       bool verify_paths)
856 {
857   NlaStrip *strip;
858   bool is_changed = false;
859   /* Recursively check strips, fixing only actions. */
860   for (strip = strips->first; strip; strip = strip->next) {
861     /* fix strip's action */
862     if (strip->act != NULL) {
863       is_changed |= fcurves_path_rename_fix(
864           owner_id, prefix, oldName, newName, oldKey, newKey, &strip->act->curves, verify_paths);
865     }
866     /* Ignore own F-Curves, since those are local.  */
867     /* Check sub-strips (if metas) */
868     is_changed |= nlastrips_path_rename_fix(
869         owner_id, prefix, oldName, newName, oldKey, newKey, &strip->strips, verify_paths);
870   }
871   return is_changed;
872 }
873
874 /* Rename Sub-ID Entities in RNA Paths ----------------------- */
875
876 /* Fix up the given RNA-Path
877  *
878  * This is just an external wrapper for the RNA-Path fixing function,
879  * with input validity checks on top of the basic method.
880  *
881  * NOTE: it is assumed that the structure we're replacing is <prefix><["><name><"]>
882  *       i.e. pose.bones["Bone"]
883  */
884 char *BKE_animsys_fix_rna_path_rename(ID *owner_id,
885                                       char *old_path,
886                                       const char *prefix,
887                                       const char *oldName,
888                                       const char *newName,
889                                       int oldSubscript,
890                                       int newSubscript,
891                                       bool verify_paths)
892 {
893   char *oldN, *newN;
894   char *result;
895
896   /* if no action, no need to proceed */
897   if (ELEM(NULL, owner_id, old_path)) {
898     if (G.debug & G_DEBUG) {
899       CLOG_WARN(&LOG, "early abort");
900     }
901     return old_path;
902   }
903
904   /* Name sanitation logic - copied from BKE_animdata_fix_paths_rename() */
905   if ((oldName != NULL) && (newName != NULL)) {
906     /* pad the names with [" "] so that only exact matches are made */
907     const size_t name_old_len = strlen(oldName);
908     const size_t name_new_len = strlen(newName);
909     char *name_old_esc = BLI_array_alloca(name_old_esc, (name_old_len * 2) + 1);
910     char *name_new_esc = BLI_array_alloca(name_new_esc, (name_new_len * 2) + 1);
911
912     BLI_strescape(name_old_esc, oldName, (name_old_len * 2) + 1);
913     BLI_strescape(name_new_esc, newName, (name_new_len * 2) + 1);
914     oldN = BLI_sprintfN("[\"%s\"]", name_old_esc);
915     newN = BLI_sprintfN("[\"%s\"]", name_new_esc);
916   }
917   else {
918     oldN = BLI_sprintfN("[%d]", oldSubscript);
919     newN = BLI_sprintfN("[%d]", newSubscript);
920   }
921
922   /* fix given path */
923   if (G.debug & G_DEBUG) {
924     printf("%s | %s  | oldpath = %p ", oldN, newN, old_path);
925   }
926   result = rna_path_rename_fix(owner_id, prefix, oldN, newN, old_path, verify_paths);
927   if (G.debug & G_DEBUG) {
928     printf("path rename result = %p\n", result);
929   }
930
931   /* free the temp names */
932   MEM_freeN(oldN);
933   MEM_freeN(newN);
934
935   /* return the resulting path - may be the same path again if nothing changed */
936   return result;
937 }
938
939 /* Fix all RNA_Paths in the given Action, relative to the given ID block
940  *
941  * This is just an external wrapper for the F-Curve fixing function,
942  * with input validity checks on top of the basic method.
943  *
944  * NOTE: it is assumed that the structure we're replacing is <prefix><["><name><"]>
945  *       i.e. pose.bones["Bone"]
946  */
947 void BKE_action_fix_paths_rename(ID *owner_id,
948                                  bAction *act,
949                                  const char *prefix,
950                                  const char *oldName,
951                                  const char *newName,
952                                  int oldSubscript,
953                                  int newSubscript,
954                                  bool verify_paths)
955 {
956   char *oldN, *newN;
957
958   /* if no action, no need to proceed */
959   if (ELEM(NULL, owner_id, act)) {
960     return;
961   }
962
963   /* Name sanitation logic - copied from BKE_animdata_fix_paths_rename() */
964   if ((oldName != NULL) && (newName != NULL)) {
965     /* pad the names with [" "] so that only exact matches are made */
966     const size_t name_old_len = strlen(oldName);
967     const size_t name_new_len = strlen(newName);
968     char *name_old_esc = BLI_array_alloca(name_old_esc, (name_old_len * 2) + 1);
969     char *name_new_esc = BLI_array_alloca(name_new_esc, (name_new_len * 2) + 1);
970
971     BLI_strescape(name_old_esc, oldName, (name_old_len * 2) + 1);
972     BLI_strescape(name_new_esc, newName, (name_new_len * 2) + 1);
973     oldN = BLI_sprintfN("[\"%s\"]", name_old_esc);
974     newN = BLI_sprintfN("[\"%s\"]", name_new_esc);
975   }
976   else {
977     oldN = BLI_sprintfN("[%d]", oldSubscript);
978     newN = BLI_sprintfN("[%d]", newSubscript);
979   }
980
981   /* fix paths in action */
982   fcurves_path_rename_fix(
983       owner_id, prefix, oldName, newName, oldN, newN, &act->curves, verify_paths);
984
985   /* free the temp names */
986   MEM_freeN(oldN);
987   MEM_freeN(newN);
988 }
989
990 /* Fix all RNA-Paths in the AnimData block used by the given ID block
991  * NOTE: it is assumed that the structure we're replacing is <prefix><["><name><"]>
992  *       i.e. pose.bones["Bone"]
993  */
994 void BKE_animdata_fix_paths_rename(ID *owner_id,
995                                    AnimData *adt,
996                                    ID *ref_id,
997                                    const char *prefix,
998                                    const char *oldName,
999                                    const char *newName,
1000                                    int oldSubscript,
1001                                    int newSubscript,
1002                                    bool verify_paths)
1003 {
1004   NlaTrack *nlt;
1005   char *oldN, *newN;
1006   /* If no AnimData, no need to proceed. */
1007   if (ELEM(NULL, owner_id, adt)) {
1008     return;
1009   }
1010   bool is_self_changed = false;
1011   /* Name sanitation logic - shared with BKE_action_fix_paths_rename(). */
1012   if ((oldName != NULL) && (newName != NULL)) {
1013     /* Pad the names with [" "] so that only exact matches are made. */
1014     const size_t name_old_len = strlen(oldName);
1015     const size_t name_new_len = strlen(newName);
1016     char *name_old_esc = BLI_array_alloca(name_old_esc, (name_old_len * 2) + 1);
1017     char *name_new_esc = BLI_array_alloca(name_new_esc, (name_new_len * 2) + 1);
1018
1019     BLI_strescape(name_old_esc, oldName, (name_old_len * 2) + 1);
1020     BLI_strescape(name_new_esc, newName, (name_new_len * 2) + 1);
1021     oldN = BLI_sprintfN("[\"%s\"]", name_old_esc);
1022     newN = BLI_sprintfN("[\"%s\"]", name_new_esc);
1023   }
1024   else {
1025     oldN = BLI_sprintfN("[%d]", oldSubscript);
1026     newN = BLI_sprintfN("[%d]", newSubscript);
1027   }
1028   /* Active action and temp action. */
1029   if (adt->action != NULL) {
1030     if (fcurves_path_rename_fix(
1031             owner_id, prefix, oldName, newName, oldN, newN, &adt->action->curves, verify_paths)) {
1032       DEG_id_tag_update(&adt->action->id, ID_RECALC_COPY_ON_WRITE);
1033     }
1034   }
1035   if (adt->tmpact) {
1036     if (fcurves_path_rename_fix(
1037             owner_id, prefix, oldName, newName, oldN, newN, &adt->tmpact->curves, verify_paths)) {
1038       DEG_id_tag_update(&adt->tmpact->id, ID_RECALC_COPY_ON_WRITE);
1039     }
1040   }
1041   /* Drivers - Drivers are really F-Curves */
1042   is_self_changed |= drivers_path_rename_fix(
1043       owner_id, ref_id, prefix, oldName, newName, oldN, newN, &adt->drivers, verify_paths);
1044   /* NLA Data - Animation Data for Strips */
1045   for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
1046     is_self_changed |= nlastrips_path_rename_fix(
1047         owner_id, prefix, oldName, newName, oldN, newN, &nlt->strips, verify_paths);
1048   }
1049   /* Tag owner ID if it */
1050   if (is_self_changed) {
1051     DEG_id_tag_update(owner_id, ID_RECALC_COPY_ON_WRITE);
1052   }
1053   /* free the temp names */
1054   MEM_freeN(oldN);
1055   MEM_freeN(newN);
1056 }
1057
1058 /* Remove FCurves with Prefix  -------------------------------------- */
1059
1060 /* Check RNA-Paths for a list of F-Curves */
1061 static bool fcurves_path_remove_fix(const char *prefix, ListBase *curves)
1062 {
1063   FCurve *fcu, *fcn;
1064   bool any_removed = false;
1065   if (!prefix) {
1066     return any_removed;
1067   }
1068
1069   /* we need to check every curve... */
1070   for (fcu = curves->first; fcu; fcu = fcn) {
1071     fcn = fcu->next;
1072
1073     if (fcu->rna_path) {
1074       if (STRPREFIX(fcu->rna_path, prefix)) {
1075         BLI_remlink(curves, fcu);
1076         free_fcurve(fcu);
1077         any_removed = true;
1078       }
1079     }
1080   }
1081   return any_removed;
1082 }
1083
1084 /* Check RNA-Paths for a list of F-Curves */
1085 static bool nlastrips_path_remove_fix(const char *prefix, ListBase *strips)
1086 {
1087   NlaStrip *strip;
1088   bool any_removed = false;
1089
1090   /* recursively check strips, fixing only actions... */
1091   for (strip = strips->first; strip; strip = strip->next) {
1092     /* fix strip's action */
1093     if (strip->act) {
1094       any_removed |= fcurves_path_remove_fix(prefix, &strip->act->curves);
1095     }
1096
1097     /* check sub-strips (if metas) */
1098     any_removed |= nlastrips_path_remove_fix(prefix, &strip->strips);
1099   }
1100   return any_removed;
1101 }
1102
1103 bool BKE_animdata_fix_paths_remove(ID *id, const char *prefix)
1104 {
1105   /* Only some ID-blocks have this info for now, so we cast the
1106    * types that do to be of type IdAdtTemplate
1107    */
1108   if (!id_can_have_animdata(id)) {
1109     return false;
1110   }
1111   bool any_removed = false;
1112   IdAdtTemplate *iat = (IdAdtTemplate *)id;
1113   AnimData *adt = iat->adt;
1114   /* check if there's any AnimData to start with */
1115   if (adt) {
1116     /* free fcurves */
1117     if (adt->action != NULL) {
1118       any_removed |= fcurves_path_remove_fix(prefix, &adt->action->curves);
1119     }
1120     if (adt->tmpact != NULL) {
1121       any_removed |= fcurves_path_remove_fix(prefix, &adt->tmpact->curves);
1122     }
1123     /* free drivers - stored as a list of F-Curves */
1124     any_removed |= fcurves_path_remove_fix(prefix, &adt->drivers);
1125     /* NLA Data - Animation Data for Strips */
1126     for (NlaTrack *nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
1127       any_removed |= nlastrips_path_remove_fix(prefix, &nlt->strips);
1128     }
1129   }
1130   return any_removed;
1131 }
1132
1133 /* Apply Op to All FCurves in Database --------------------------- */
1134
1135 /* "User-Data" wrapper used by BKE_fcurves_main_cb() */
1136 typedef struct AllFCurvesCbWrapper {
1137   ID_FCurve_Edit_Callback func; /* Operation to apply on F-Curve */
1138   void *user_data;              /* Custom data for that operation */
1139 } AllFCurvesCbWrapper;
1140
1141 /* Helper for adt_apply_all_fcurves_cb() - Apply wrapped operator to list of F-Curves */
1142 static void fcurves_apply_cb(ID *id,
1143                              ListBase *fcurves,
1144                              ID_FCurve_Edit_Callback func,
1145                              void *user_data)
1146 {
1147   FCurve *fcu;
1148
1149   for (fcu = fcurves->first; fcu; fcu = fcu->next) {
1150     func(id, fcu, user_data);
1151   }
1152 }
1153
1154 /* Helper for adt_apply_all_fcurves_cb() - Recursively go through each NLA strip */
1155 static void nlastrips_apply_all_curves_cb(ID *id, ListBase *strips, AllFCurvesCbWrapper *wrapper)
1156 {
1157   NlaStrip *strip;
1158
1159   for (strip = strips->first; strip; strip = strip->next) {
1160     /* fix strip's action */
1161     if (strip->act) {
1162       fcurves_apply_cb(id, &strip->act->curves, wrapper->func, wrapper->user_data);
1163     }
1164
1165     /* check sub-strips (if metas) */
1166     nlastrips_apply_all_curves_cb(id, &strip->strips, wrapper);
1167   }
1168 }
1169
1170 /* Helper for BKE_fcurves_main_cb() - Dispatch wrapped operator to all F-Curves */
1171 static void adt_apply_all_fcurves_cb(ID *id, AnimData *adt, void *wrapper_data)
1172 {
1173   AllFCurvesCbWrapper *wrapper = wrapper_data;
1174   NlaTrack *nlt;
1175
1176   if (adt->action) {
1177     fcurves_apply_cb(id, &adt->action->curves, wrapper->func, wrapper->user_data);
1178   }
1179
1180   if (adt->tmpact) {
1181     fcurves_apply_cb(id, &adt->tmpact->curves, wrapper->func, wrapper->user_data);
1182   }
1183
1184   /* free drivers - stored as a list of F-Curves */
1185   fcurves_apply_cb(id, &adt->drivers, wrapper->func, wrapper->user_data);
1186
1187   /* NLA Data - Animation Data for Strips */
1188   for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
1189     nlastrips_apply_all_curves_cb(id, &nlt->strips, wrapper);
1190   }
1191 }
1192
1193 void BKE_fcurves_id_cb(ID *id, ID_FCurve_Edit_Callback func, void *user_data)
1194 {
1195   AnimData *adt = BKE_animdata_from_id(id);
1196   if (adt != NULL) {
1197     AllFCurvesCbWrapper wrapper = {func, user_data};
1198     adt_apply_all_fcurves_cb(id, adt, &wrapper);
1199   }
1200 }
1201
1202 /* apply the given callback function on all F-Curves attached to data in main database */
1203 void BKE_fcurves_main_cb(Main *bmain, ID_FCurve_Edit_Callback func, void *user_data)
1204 {
1205   /* Wrap F-Curve operation stuff to pass to the general AnimData-level func */
1206   AllFCurvesCbWrapper wrapper = {func, user_data};
1207
1208   /* Use the AnimData-based function so that we don't have to reimplement all that stuff */
1209   BKE_animdata_main_cb(bmain, adt_apply_all_fcurves_cb, &wrapper);
1210 }
1211
1212 /* Whole Database Ops -------------------------------------------- */
1213
1214 /* apply the given callback function on all data in main database */
1215 void BKE_animdata_main_cb(Main *bmain, ID_AnimData_Edit_Callback func, void *user_data)
1216 {
1217   ID *id;
1218
1219   /* standard data version */
1220 #define ANIMDATA_IDS_CB(first) \
1221   for (id = first; id; id = id->next) { \
1222     AnimData *adt = BKE_animdata_from_id(id); \
1223     if (adt) \
1224       func(id, adt, user_data); \
1225   } \
1226   (void)0
1227
1228   /* "embedded" nodetree cases (i.e. scene/material/texture->nodetree) */
1229 #define ANIMDATA_NODETREE_IDS_CB(first, NtId_Type) \
1230   for (id = first; id; id = id->next) { \
1231     AnimData *adt = BKE_animdata_from_id(id); \
1232     NtId_Type *ntp = (NtId_Type *)id; \
1233     if (ntp->nodetree) { \
1234       AnimData *adt2 = BKE_animdata_from_id((ID *)ntp->nodetree); \
1235       if (adt2) \
1236         func(id, adt2, user_data); \
1237     } \
1238     if (adt) \
1239       func(id, adt, user_data); \
1240   } \
1241   (void)0
1242
1243   /* nodes */
1244   ANIMDATA_IDS_CB(bmain->nodetrees.first);
1245
1246   /* textures */
1247   ANIMDATA_NODETREE_IDS_CB(bmain->textures.first, Tex);
1248
1249   /* lights */
1250   ANIMDATA_NODETREE_IDS_CB(bmain->lights.first, Light);
1251
1252   /* materials */
1253   ANIMDATA_NODETREE_IDS_CB(bmain->materials.first, Material);
1254
1255   /* cameras */
1256   ANIMDATA_IDS_CB(bmain->cameras.first);
1257
1258   /* shapekeys */
1259   ANIMDATA_IDS_CB(bmain->shapekeys.first);
1260
1261   /* metaballs */
1262   ANIMDATA_IDS_CB(bmain->metaballs.first);
1263
1264   /* curves */
1265   ANIMDATA_IDS_CB(bmain->curves.first);
1266
1267   /* armatures */
1268   ANIMDATA_IDS_CB(bmain->armatures.first);
1269
1270   /* lattices */
1271   ANIMDATA_IDS_CB(bmain->lattices.first);
1272
1273   /* meshes */
1274   ANIMDATA_IDS_CB(bmain->meshes.first);
1275
1276   /* particles */
1277   ANIMDATA_IDS_CB(bmain->particles.first);
1278
1279   /* speakers */
1280   ANIMDATA_IDS_CB(bmain->speakers.first);
1281
1282   /* movie clips */
1283   ANIMDATA_IDS_CB(bmain->movieclips.first);
1284
1285   /* objects */
1286   ANIMDATA_IDS_CB(bmain->objects.first);
1287
1288   /* masks */
1289   ANIMDATA_IDS_CB(bmain->masks.first);
1290
1291   /* worlds */
1292   ANIMDATA_NODETREE_IDS_CB(bmain->worlds.first, World);
1293
1294   /* scenes */
1295   ANIMDATA_NODETREE_IDS_CB(bmain->scenes.first, Scene);
1296
1297   /* line styles */
1298   ANIMDATA_IDS_CB(bmain->linestyles.first);
1299
1300   /* grease pencil */
1301   ANIMDATA_IDS_CB(bmain->gpencils.first);
1302
1303   /* palettes */
1304   ANIMDATA_IDS_CB(bmain->palettes.first);
1305
1306   /* cache files */
1307   ANIMDATA_IDS_CB(bmain->cachefiles.first);
1308 }
1309
1310 /* Fix all RNA-Paths throughout the database (directly access the Global.main version)
1311  * NOTE: it is assumed that the structure we're replacing is <prefix><["><name><"]>
1312  *      i.e. pose.bones["Bone"]
1313  */
1314 /* TODO: use BKE_animdata_main_cb for looping over all data  */
1315 void BKE_animdata_fix_paths_rename_all(ID *ref_id,
1316                                        const char *prefix,
1317                                        const char *oldName,
1318                                        const char *newName)
1319 {
1320   Main *bmain = G.main; /* XXX UGLY! */
1321   ID *id;
1322
1323   /* macro for less typing
1324    * - whether animdata exists is checked for by the main renaming callback, though taking
1325    *   this outside of the function may make things slightly faster?
1326    */
1327 #define RENAMEFIX_ANIM_IDS(first) \
1328   for (id = first; id; id = id->next) { \
1329     AnimData *adt = BKE_animdata_from_id(id); \
1330     BKE_animdata_fix_paths_rename(id, adt, ref_id, prefix, oldName, newName, 0, 0, 1); \
1331   } \
1332   (void)0
1333
1334   /* another version of this macro for nodetrees */
1335 #define RENAMEFIX_ANIM_NODETREE_IDS(first, NtId_Type) \
1336   for (id = first; id; id = id->next) { \
1337     AnimData *adt = BKE_animdata_from_id(id); \
1338     NtId_Type *ntp = (NtId_Type *)id; \
1339     if (ntp->nodetree) { \
1340       AnimData *adt2 = BKE_animdata_from_id((ID *)ntp->nodetree); \
1341       BKE_animdata_fix_paths_rename( \
1342           (ID *)ntp->nodetree, adt2, ref_id, prefix, oldName, newName, 0, 0, 1); \
1343     } \
1344     BKE_animdata_fix_paths_rename(id, adt, ref_id, prefix, oldName, newName, 0, 0, 1); \
1345   } \
1346   (void)0
1347
1348   /* nodes */
1349   RENAMEFIX_ANIM_IDS(bmain->nodetrees.first);
1350
1351   /* textures */
1352   RENAMEFIX_ANIM_NODETREE_IDS(bmain->textures.first, Tex);
1353
1354   /* lights */
1355   RENAMEFIX_ANIM_NODETREE_IDS(bmain->lights.first, Light);
1356
1357   /* materials */
1358   RENAMEFIX_ANIM_NODETREE_IDS(bmain->materials.first, Material);
1359
1360   /* cameras */
1361   RENAMEFIX_ANIM_IDS(bmain->cameras.first);
1362
1363   /* shapekeys */
1364   RENAMEFIX_ANIM_IDS(bmain->shapekeys.first);
1365
1366   /* metaballs */
1367   RENAMEFIX_ANIM_IDS(bmain->metaballs.first);
1368
1369   /* curves */
1370   RENAMEFIX_ANIM_IDS(bmain->curves.first);
1371
1372   /* armatures */
1373   RENAMEFIX_ANIM_IDS(bmain->armatures.first);
1374
1375   /* lattices */
1376   RENAMEFIX_ANIM_IDS(bmain->lattices.first);
1377
1378   /* meshes */
1379   RENAMEFIX_ANIM_IDS(bmain->meshes.first);
1380
1381   /* particles */
1382   RENAMEFIX_ANIM_IDS(bmain->particles.first);
1383
1384   /* speakers */
1385   RENAMEFIX_ANIM_IDS(bmain->speakers.first);
1386
1387   /* movie clips */
1388   RENAMEFIX_ANIM_IDS(bmain->movieclips.first);
1389
1390   /* objects */
1391   RENAMEFIX_ANIM_IDS(bmain->objects.first);
1392
1393   /* masks */
1394   RENAMEFIX_ANIM_IDS(bmain->masks.first);
1395
1396   /* worlds */
1397   RENAMEFIX_ANIM_NODETREE_IDS(bmain->worlds.first, World);
1398
1399   /* linestyles */
1400   RENAMEFIX_ANIM_IDS(bmain->linestyles.first);
1401
1402   /* grease pencil */
1403   RENAMEFIX_ANIM_IDS(bmain->gpencils.first);
1404
1405   /* cache files */
1406   RENAMEFIX_ANIM_IDS(bmain->cachefiles.first);
1407
1408   /* scenes */
1409   RENAMEFIX_ANIM_NODETREE_IDS(bmain->scenes.first, Scene);
1410 }
1411
1412 /* *********************************** */
1413 /* KeyingSet API */
1414
1415 /* Finding Tools --------------------------- */
1416
1417 /* Find the first path that matches the given criteria */
1418 /* TODO: do we want some method to perform partial matches too? */
1419 KS_Path *BKE_keyingset_find_path(KeyingSet *ks,
1420                                  ID *id,
1421                                  const char group_name[],
1422                                  const char rna_path[],
1423                                  int array_index,
1424                                  int UNUSED(group_mode))
1425 {
1426   KS_Path *ksp;
1427
1428   /* sanity checks */
1429   if (ELEM(NULL, ks, rna_path, id)) {
1430     return NULL;
1431   }
1432
1433   /* loop over paths in the current KeyingSet, finding the first one where all settings match
1434    * (i.e. the first one where none of the checks fail and equal 0)
1435    */
1436   for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
1437     short eq_id = 1, eq_path = 1, eq_index = 1, eq_group = 1;
1438
1439     /* id */
1440     if (id != ksp->id) {
1441       eq_id = 0;
1442     }
1443
1444     /* path */
1445     if ((ksp->rna_path == NULL) || !STREQ(rna_path, ksp->rna_path)) {
1446       eq_path = 0;
1447     }
1448
1449     /* index - need to compare whole-array setting too... */
1450     if (ksp->array_index != array_index) {
1451       eq_index = 0;
1452     }
1453
1454     /* group */
1455     if (group_name) {
1456       /* FIXME: these checks need to be coded... for now, it's not too important though */
1457     }
1458
1459     /* if all aspects are ok, return */
1460     if (eq_id && eq_path && eq_index && eq_group) {
1461       return ksp;
1462     }
1463   }
1464
1465   /* none found */
1466   return NULL;
1467 }
1468
1469 /* Defining Tools --------------------------- */
1470
1471 /* Used to create a new 'custom' KeyingSet for the user,
1472  * that will be automatically added to the stack */
1473 KeyingSet *BKE_keyingset_add(
1474     ListBase *list, const char idname[], const char name[], short flag, short keyingflag)
1475 {
1476   KeyingSet *ks;
1477
1478   /* allocate new KeyingSet */
1479   ks = MEM_callocN(sizeof(KeyingSet), "KeyingSet");
1480
1481   BLI_strncpy(
1482       ks->idname, (idname) ? idname : (name) ? name : DATA_("KeyingSet"), sizeof(ks->idname));
1483   BLI_strncpy(ks->name, (name) ? name : (idname) ? idname : DATA_("Keying Set"), sizeof(ks->name));
1484
1485   ks->flag = flag;
1486   ks->keyingflag = keyingflag;
1487   /* NOTE: assume that if one is set one way, the other should be too, so that it'll work */
1488   ks->keyingoverride = keyingflag;
1489
1490   /* add KeyingSet to list */
1491   BLI_addtail(list, ks);
1492
1493   /* Make sure KeyingSet has a unique idname */
1494   BLI_uniquename(
1495       list, ks, DATA_("KeyingSet"), '.', offsetof(KeyingSet, idname), sizeof(ks->idname));
1496
1497   /* Make sure KeyingSet has a unique label (this helps with identification) */
1498   BLI_uniquename(list, ks, DATA_("Keying Set"), '.', offsetof(KeyingSet, name), sizeof(ks->name));
1499
1500   /* return new KeyingSet for further editing */
1501   return ks;
1502 }
1503
1504 /* Add a path to a KeyingSet. Nothing is returned for now...
1505  * Checks are performed to ensure that destination is appropriate for the KeyingSet in question
1506  */
1507 KS_Path *BKE_keyingset_add_path(KeyingSet *ks,
1508                                 ID *id,
1509                                 const char group_name[],
1510                                 const char rna_path[],
1511                                 int array_index,
1512                                 short flag,
1513                                 short groupmode)
1514 {
1515   KS_Path *ksp;
1516
1517   /* sanity checks */
1518   if (ELEM(NULL, ks, rna_path)) {
1519     CLOG_ERROR(&LOG, "no Keying Set and/or RNA Path to add path with");
1520     return NULL;
1521   }
1522
1523   /* ID is required for all types of KeyingSets */
1524   if (id == NULL) {
1525     CLOG_ERROR(&LOG, "No ID provided for Keying Set Path");
1526     return NULL;
1527   }
1528
1529   /* don't add if there is already a matching KS_Path in the KeyingSet */
1530   if (BKE_keyingset_find_path(ks, id, group_name, rna_path, array_index, groupmode)) {
1531     if (G.debug & G_DEBUG) {
1532       CLOG_ERROR(&LOG, "destination already exists in Keying Set");
1533     }
1534     return NULL;
1535   }
1536
1537   /* allocate a new KeyingSet Path */
1538   ksp = MEM_callocN(sizeof(KS_Path), "KeyingSet Path");
1539
1540   /* just store absolute info */
1541   ksp->id = id;
1542   if (group_name) {
1543     BLI_strncpy(ksp->group, group_name, sizeof(ksp->group));
1544   }
1545   else {
1546     ksp->group[0] = '\0';
1547   }
1548
1549   /* store additional info for relative paths (just in case user makes the set relative) */
1550   if (id) {
1551     ksp->idtype = GS(id->name);
1552   }
1553
1554   /* just copy path info */
1555   /* TODO: should array index be checked too? */
1556   ksp->rna_path = BLI_strdup(rna_path);
1557   ksp->array_index = array_index;
1558
1559   /* store flags */
1560   ksp->flag = flag;
1561   ksp->groupmode = groupmode;
1562
1563   /* add KeyingSet path to KeyingSet */
1564   BLI_addtail(&ks->paths, ksp);
1565
1566   /* return this path */
1567   return ksp;
1568 }
1569
1570 /* Free the given Keying Set path */
1571 void BKE_keyingset_free_path(KeyingSet *ks, KS_Path *ksp)
1572 {
1573   /* sanity check */
1574   if (ELEM(NULL, ks, ksp)) {
1575     return;
1576   }
1577
1578   /* free RNA-path info */
1579   if (ksp->rna_path) {
1580     MEM_freeN(ksp->rna_path);
1581   }
1582
1583   /* free path itself */
1584   BLI_freelinkN(&ks->paths, ksp);
1585 }
1586
1587 /* Copy all KeyingSets in the given list */
1588 void BKE_keyingsets_copy(ListBase *newlist, const ListBase *list)
1589 {
1590   KeyingSet *ksn;
1591   KS_Path *kspn;
1592
1593   BLI_duplicatelist(newlist, list);
1594
1595   for (ksn = newlist->first; ksn; ksn = ksn->next) {
1596     BLI_duplicatelist(&ksn->paths, &ksn->paths);
1597
1598     for (kspn = ksn->paths.first; kspn; kspn = kspn->next) {
1599       kspn->rna_path = MEM_dupallocN(kspn->rna_path);
1600     }
1601   }
1602 }
1603
1604 /* Freeing Tools --------------------------- */
1605
1606 /* Free data for KeyingSet but not set itself */
1607 void BKE_keyingset_free(KeyingSet *ks)
1608 {
1609   KS_Path *ksp, *kspn;
1610
1611   /* sanity check */
1612   if (ks == NULL) {
1613     return;
1614   }
1615
1616   /* free each path as we go to avoid looping twice */
1617   for (ksp = ks->paths.first; ksp; ksp = kspn) {
1618     kspn = ksp->next;
1619     BKE_keyingset_free_path(ks, ksp);
1620   }
1621 }
1622
1623 /* Free all the KeyingSets in the given list */
1624 void BKE_keyingsets_free(ListBase *list)
1625 {
1626   KeyingSet *ks, *ksn;
1627
1628   /* sanity check */
1629   if (list == NULL) {
1630     return;
1631   }
1632
1633   /* loop over KeyingSets freeing them
1634    * - BKE_keyingset_free() doesn't free the set itself, but it frees its sub-data
1635    */
1636   for (ks = list->first; ks; ks = ksn) {
1637     ksn = ks->next;
1638     BKE_keyingset_free(ks);
1639     BLI_freelinkN(list, ks);
1640   }
1641 }
1642
1643 /* ***************************************** */
1644 /* Evaluation Data-Setting Backend */
1645
1646 static bool animsys_store_rna_setting(PointerRNA *ptr,
1647                                       /* typically 'fcu->rna_path', 'fcu->array_index' */
1648                                       const char *rna_path,
1649                                       const int array_index,
1650                                       PathResolvedRNA *r_result)
1651 {
1652   bool success = false;
1653   const char *path = rna_path;
1654
1655   /* write value to setting */
1656   if (path) {
1657     /* get property to write to */
1658     if (RNA_path_resolve_property(ptr, path, &r_result->ptr, &r_result->prop)) {
1659       if ((ptr->id.data == NULL) || RNA_property_animateable(&r_result->ptr, r_result->prop)) {
1660         int array_len = RNA_property_array_length(&r_result->ptr, r_result->prop);
1661
1662         if (array_len && array_index >= array_len) {
1663           if (G.debug & G_DEBUG) {
1664             CLOG_WARN(&LOG,
1665                       "Animato: Invalid array index. ID = '%s',  '%s[%d]', array length is %d",
1666                       (ptr->id.data) ? (((ID *)ptr->id.data)->name + 2) : "<No ID>",
1667                       path,
1668                       array_index,
1669                       array_len - 1);
1670           }
1671         }
1672         else {
1673           r_result->prop_index = array_len ? array_index : -1;
1674           success = true;
1675         }
1676       }
1677     }
1678     else {
1679       /* failed to get path */
1680       /* XXX don't tag as failed yet though, as there are some legit situations (Action Constraint)
1681        * where some channels will not exist, but shouldn't lock up Action */
1682       if (G.debug & G_DEBUG) {
1683         CLOG_WARN(&LOG,
1684                   "Animato: Invalid path. ID = '%s',  '%s[%d]'",
1685                   (ptr->id.data) ? (((ID *)ptr->id.data)->name + 2) : "<No ID>",
1686                   path,
1687                   array_index);
1688       }
1689     }
1690   }
1691
1692   return success;
1693 }
1694
1695 /* less than 1.0 evaluates to false, use epsilon to avoid float error */
1696 #define ANIMSYS_FLOAT_AS_BOOL(value) ((value) > ((1.0f - FLT_EPSILON)))
1697
1698 static bool animsys_read_rna_setting(PathResolvedRNA *anim_rna, float *r_value)
1699 {
1700   PropertyRNA *prop = anim_rna->prop;
1701   PointerRNA *ptr = &anim_rna->ptr;
1702   int array_index = anim_rna->prop_index;
1703   float orig_value;
1704
1705   /* caller must ensure this is animatable */
1706   BLI_assert(RNA_property_animateable(ptr, prop) || ptr->id.data == NULL);
1707
1708   switch (RNA_property_type(prop)) {
1709     case PROP_BOOLEAN: {
1710       if (array_index != -1) {
1711         const int orig_value_coerce = RNA_property_boolean_get_index(ptr, prop, array_index);
1712         orig_value = (float)orig_value_coerce;
1713       }
1714       else {
1715         const int orig_value_coerce = RNA_property_boolean_get(ptr, prop);
1716         orig_value = (float)orig_value_coerce;
1717       }
1718       break;
1719     }
1720     case PROP_INT: {
1721       if (array_index != -1) {
1722         const int orig_value_coerce = RNA_property_int_get_index(ptr, prop, array_index);
1723         orig_value = (float)orig_value_coerce;
1724       }
1725       else {
1726         const int orig_value_coerce = RNA_property_int_get(ptr, prop);
1727         orig_value = (float)orig_value_coerce;
1728       }
1729       break;
1730     }
1731     case PROP_FLOAT: {
1732       if (array_index != -1) {
1733         const float orig_value_coerce = RNA_property_float_get_index(ptr, prop, array_index);
1734         orig_value = (float)orig_value_coerce;
1735       }
1736       else {
1737         const float orig_value_coerce = RNA_property_float_get(ptr, prop);
1738         orig_value = (float)orig_value_coerce;
1739       }
1740       break;
1741     }
1742     case PROP_ENUM: {
1743       const int orig_value_coerce = RNA_property_enum_get(ptr, prop);
1744       orig_value = (float)orig_value_coerce;
1745       break;
1746     }
1747     default:
1748       /* nothing can be done here... so it is unsuccessful? */
1749       return false;
1750   }
1751
1752   if (r_value != NULL) {
1753     *r_value = orig_value;
1754   }
1755
1756   /* successful */
1757   return true;
1758 }
1759
1760 /* Write the given value to a setting using RNA, and return success */
1761 static bool animsys_write_rna_setting(PathResolvedRNA *anim_rna, const float value)
1762 {
1763   PropertyRNA *prop = anim_rna->prop;
1764   PointerRNA *ptr = &anim_rna->ptr;
1765   int array_index = anim_rna->prop_index;
1766
1767   /* caller must ensure this is animatable */
1768   BLI_assert(RNA_property_animateable(ptr, prop) || ptr->id.data == NULL);
1769
1770   /* Check whether value is new. Otherwise we skip all the updates. */
1771   float old_value;
1772   if (!animsys_read_rna_setting(anim_rna, &old_value)) {
1773     return false;
1774   }
1775   if (old_value == value) {
1776     return true;
1777   }
1778
1779   switch (RNA_property_type(prop)) {
1780     case PROP_BOOLEAN: {
1781       const int value_coerce = ANIMSYS_FLOAT_AS_BOOL(value);
1782       if (array_index != -1) {
1783         RNA_property_boolean_set_index(ptr, prop, array_index, value_coerce);
1784       }
1785       else {
1786         RNA_property_boolean_set(ptr, prop, value_coerce);
1787       }
1788       break;
1789     }
1790     case PROP_INT: {
1791       int value_coerce = (int)value;
1792       RNA_property_int_clamp(ptr, prop, &value_coerce);
1793       if (array_index != -1) {
1794         RNA_property_int_set_index(ptr, prop, array_index, value_coerce);
1795       }
1796       else {
1797         RNA_property_int_set(ptr, prop, value_coerce);
1798       }
1799       break;
1800     }
1801     case PROP_FLOAT: {
1802       float value_coerce = value;
1803       RNA_property_float_clamp(ptr, prop, &value_coerce);
1804       if (array_index != -1) {
1805         RNA_property_float_set_index(ptr, prop, array_index, value_coerce);
1806       }
1807       else {
1808         RNA_property_float_set(ptr, prop, value_coerce);
1809       }
1810       break;
1811     }
1812     case PROP_ENUM: {
1813       const int value_coerce = (int)value;
1814       RNA_property_enum_set(ptr, prop, value_coerce);
1815       break;
1816     }
1817     default:
1818       /* nothing can be done here... so it is unsuccessful? */
1819       return false;
1820   }
1821
1822   /* successful */
1823   return true;
1824 }
1825
1826 /* Simple replacement based data-setting of the FCurve using RNA */
1827 bool BKE_animsys_execute_fcurve(PointerRNA *ptr, FCurve *fcu, float curval)
1828 {
1829   PathResolvedRNA anim_rna;
1830   bool ok = false;
1831
1832   if (animsys_store_rna_setting(ptr, fcu->rna_path, fcu->array_index, &anim_rna)) {
1833     ok = animsys_write_rna_setting(&anim_rna, curval);
1834   }
1835
1836   /* return whether we were successful */
1837   return ok;
1838 }
1839
1840 static bool animsys_construct_orig_pointer_rna(const PointerRNA *ptr, PointerRNA *ptr_orig)
1841 {
1842   *ptr_orig = *ptr;
1843   /* NOTE: nlastrip_evaluate_controls() creates PointerRNA with ID of NULL. Technically, this is
1844    * not a valid pointer, but there are exceptions in various places of this file which handles
1845    * such pointers.
1846    * We do special trickery here as well, to quickly go from evaluated to original NlaStrip. */
1847   if (ptr->id.data == NULL) {
1848     if (ptr->type != &RNA_NlaStrip) {
1849       return false;
1850     }
1851     NlaStrip *strip = ((NlaStrip *)ptr_orig->data);
1852     if (strip->orig_strip == NULL) {
1853       return false;
1854     }
1855     ptr_orig->data = strip->orig_strip;
1856   }
1857   else {
1858     ptr_orig->id.data = ((ID *)ptr_orig->id.data)->orig_id;
1859     ptr_orig->data = ptr_orig->id.data;
1860   }
1861   return true;
1862 }
1863
1864 static void animsys_write_orig_anim_rna(PointerRNA *ptr,
1865                                         const char *rna_path,
1866                                         int array_index,
1867                                         float value)
1868 {
1869   PointerRNA ptr_orig;
1870   if (!animsys_construct_orig_pointer_rna(ptr, &ptr_orig)) {
1871     return;
1872   }
1873   PathResolvedRNA orig_anim_rna;
1874   /* TODO(sergey): Should be possible to cache resolved path in dependency graph somehow. */
1875   if (animsys_store_rna_setting(&ptr_orig, rna_path, array_index, &orig_anim_rna)) {
1876     animsys_write_rna_setting(&orig_anim_rna, value);
1877   }
1878 }
1879
1880 /**
1881  * Evaluate all the F-Curves in the given list
1882  * This performs a set of standard checks. If extra checks are required,
1883  * separate code should be used.
1884  */
1885 static void animsys_evaluate_fcurves(PointerRNA *ptr,
1886                                      ListBase *list,
1887                                      float ctime,
1888                                      bool flush_to_original)
1889 {
1890   /* Calculate then execute each curve. */
1891   for (FCurve *fcu = list->first; fcu; fcu = fcu->next) {
1892     /* Check if this F-Curve doesn't belong to a muted group. */
1893     if ((fcu->grp != NULL) && (fcu->grp->flag & AGRP_MUTED)) {
1894       continue;
1895     }
1896     /* Check if this curve should be skipped. */
1897     if ((fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED))) {
1898       continue;
1899     }
1900     /* Skip empty curves, as if muted. */
1901     if (BKE_fcurve_is_empty(fcu)) {
1902       continue;
1903     }
1904     PathResolvedRNA anim_rna;
1905     if (animsys_store_rna_setting(ptr, fcu->rna_path, fcu->array_index, &anim_rna)) {
1906       const float curval = calculate_fcurve(&anim_rna, fcu, ctime);
1907       animsys_write_rna_setting(&anim_rna, curval);
1908       if (flush_to_original) {
1909         animsys_write_orig_anim_rna(ptr, fcu->rna_path, fcu->array_index, curval);
1910       }
1911     }
1912   }
1913 }
1914
1915 /* ***************************************** */
1916 /* Driver Evaluation */
1917
1918 /* Evaluate Drivers */
1919 static void animsys_evaluate_drivers(PointerRNA *ptr, AnimData *adt, float ctime)
1920 {
1921   FCurve *fcu;
1922
1923   /* drivers are stored as F-Curves, but we cannot use the standard code, as we need to check if
1924    * the depsgraph requested that this driver be evaluated...
1925    */
1926   for (fcu = adt->drivers.first; fcu; fcu = fcu->next) {
1927     ChannelDriver *driver = fcu->driver;
1928     bool ok = false;
1929
1930     /* check if this driver's curve should be skipped */
1931     if ((fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED)) == 0) {
1932       /* check if driver itself is tagged for recalculation */
1933       /* XXX driver recalc flag is not set yet by depsgraph! */
1934       if ((driver) && !(driver->flag & DRIVER_FLAG_INVALID)) {
1935         /* evaluate this using values set already in other places
1936          * NOTE: for 'layering' option later on, we should check if we should remove old value
1937          * before adding new to only be done when drivers only changed. */
1938         PathResolvedRNA anim_rna;
1939         if (animsys_store_rna_setting(ptr, fcu->rna_path, fcu->array_index, &anim_rna)) {
1940           const float curval = calculate_fcurve(&anim_rna, fcu, ctime);
1941           ok = animsys_write_rna_setting(&anim_rna, curval);
1942         }
1943
1944         /* set error-flag if evaluation failed */
1945         if (ok == 0) {
1946           driver->flag |= DRIVER_FLAG_INVALID;
1947         }
1948       }
1949     }
1950   }
1951 }
1952
1953 /* ***************************************** */
1954 /* Actions Evaluation */
1955
1956 /* strictly not necessary for actual "evaluation", but it is a useful safety check
1957  * to reduce the amount of times that users end up having to "revive" wrongly-assigned
1958  * actions
1959  */
1960 static void action_idcode_patch_check(ID *id, bAction *act)
1961 {
1962   int idcode = 0;
1963
1964   /* just in case */
1965   if (ELEM(NULL, id, act)) {
1966     return;
1967   }
1968   else {
1969     idcode = GS(id->name);
1970   }
1971
1972   /* the actual checks... hopefully not too much of a performance hit in the long run... */
1973   if (act->idroot == 0) {
1974     /* use the current root if not set already
1975      * (i.e. newly created actions and actions from 2.50-2.57 builds).
1976      * - this has problems if there are 2 users, and the first one encountered is the invalid one
1977      *   in which case, the user will need to manually fix this (?)
1978      */
1979     act->idroot = idcode;
1980   }
1981   else if (act->idroot != idcode) {
1982     /* only report this error if debug mode is enabled (to save performance everywhere else) */
1983     if (G.debug & G_DEBUG) {
1984       printf(
1985           "AnimSys Safety Check Failed: Action '%s' is not meant to be used from ID-Blocks of "
1986           "type %d such as '%s'\n",
1987           act->id.name + 2,
1988           idcode,
1989           id->name);
1990     }
1991   }
1992 }
1993
1994 /* ----------------------------------------- */
1995
1996 /* Evaluate Action Group */
1997 void animsys_evaluate_action_group(PointerRNA *ptr, bAction *act, bActionGroup *agrp, float ctime)
1998 {
1999   FCurve *fcu;
2000
2001   /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
2002   if (ELEM(NULL, act, agrp)) {
2003     return;
2004   }
2005
2006   action_idcode_patch_check(ptr->id.data, act);
2007
2008   /* if group is muted, don't evaluated any of the F-Curve */
2009   if (agrp->flag & AGRP_MUTED) {
2010     return;
2011   }
2012
2013   /* calculate then execute each curve */
2014   for (fcu = agrp->channels.first; (fcu) && (fcu->grp == agrp); fcu = fcu->next) {
2015     /* check if this curve should be skipped */
2016     if ((fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED)) == 0 && !BKE_fcurve_is_empty(fcu)) {
2017       PathResolvedRNA anim_rna;
2018       if (animsys_store_rna_setting(ptr, fcu->rna_path, fcu->array_index, &anim_rna)) {
2019         const float curval = calculate_fcurve(&anim_rna, fcu, ctime);
2020         animsys_write_rna_setting(&anim_rna, curval);
2021       }
2022     }
2023   }
2024 }
2025
2026 /* Evaluate Action (F-Curve Bag) */
2027 static void animsys_evaluate_action_ex(PointerRNA *ptr,
2028                                        bAction *act,
2029                                        float ctime,
2030                                        const bool flush_to_original)
2031 {
2032   /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
2033   if (act == NULL) {
2034     return;
2035   }
2036
2037   action_idcode_patch_check(ptr->id.data, act);
2038
2039   /* calculate then execute each curve */
2040   animsys_evaluate_fcurves(ptr, &act->curves, ctime, flush_to_original);
2041 }
2042
2043 void animsys_evaluate_action(PointerRNA *ptr,
2044                              bAction *act,
2045                              float ctime,
2046                              const bool flush_to_original)
2047 {
2048   animsys_evaluate_action_ex(ptr, act, ctime, flush_to_original);
2049 }
2050
2051 /* ***************************************** */
2052 /* NLA System - Evaluation */
2053
2054 /* calculate influence of strip based for given frame based on blendin/out values */
2055 static float nlastrip_get_influence(NlaStrip *strip, float cframe)
2056 {
2057   /* sanity checks - normalize the blendin/out values? */
2058   strip->blendin = fabsf(strip->blendin);
2059   strip->blendout = fabsf(strip->blendout);
2060
2061   /* result depends on where frame is in respect to blendin/out values */
2062   if (IS_EQF(strip->blendin, 0.0f) == false && (cframe <= (strip->start + strip->blendin))) {
2063     /* there is some blend-in */
2064     return fabsf(cframe - strip->start) / (strip->blendin);
2065   }
2066   else if (IS_EQF(strip->blendout, 0.0f) == false && (cframe >= (strip->end - strip->blendout))) {
2067     /* there is some blend-out */
2068     return fabsf(strip->end - cframe) / (strip->blendout);
2069   }
2070   else {
2071     /* in the middle of the strip, we should be full strength */
2072     return 1.0f;
2073   }
2074 }
2075
2076 /* evaluate the evaluation time and influence for the strip, storing the results in the strip */
2077 static void nlastrip_evaluate_controls(NlaStrip *strip, float ctime, const bool flush_to_original)
2078 {
2079   /* now strip's evaluate F-Curves for these settings (if applicable) */
2080   if (strip->fcurves.first) {
2081     PointerRNA strip_ptr;
2082
2083     /* create RNA-pointer needed to set values */
2084     RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &strip_ptr);
2085
2086     /* execute these settings as per normal */
2087     animsys_evaluate_fcurves(&strip_ptr, &strip->fcurves, ctime, flush_to_original);
2088   }
2089
2090   /* analytically generate values for influence and time (if applicable)
2091    * - we do this after the F-Curves have been evaluated to override the effects of those
2092    *   in case the override has been turned off.
2093    */
2094   if ((strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) == 0) {
2095     strip->influence = nlastrip_get_influence(strip, ctime);
2096   }
2097
2098   /* Bypass evaluation time computation if time mapping is disabled. */
2099   if ((strip->flag & NLASTRIP_FLAG_NO_TIME_MAP) != 0) {
2100     strip->strip_time = ctime;
2101     return;
2102   }
2103
2104   if ((strip->flag & NLASTRIP_FLAG_USR_TIME) == 0) {
2105     strip->strip_time = nlastrip_get_frame(strip, ctime, NLATIME_CONVERT_EVAL);
2106   }
2107
2108   /* if user can control the evaluation time (using F-Curves), consider the option which allows
2109    * this time to be clamped to lie within extents of the action-clip, so that a steady changing
2110    * rate of progress through several cycles of the clip can be achieved easily.
2111    */
2112   /* NOTE: if we add any more of these special cases, we better group them up nicely... */
2113   if ((strip->flag & NLASTRIP_FLAG_USR_TIME) && (strip->flag & NLASTRIP_FLAG_USR_TIME_CYCLIC)) {
2114     strip->strip_time = fmod(strip->strip_time - strip->actstart, strip->actend - strip->actstart);
2115   }
2116 }
2117
2118 /* gets the strip active at the current time for a list of strips for evaluation purposes */
2119 NlaEvalStrip *nlastrips_ctime_get_strip(
2120     ListBase *list, ListBase *strips, short index, float ctime, const bool flush_to_original)
2121 {
2122   NlaStrip *strip, *estrip = NULL;
2123   NlaEvalStrip *nes;
2124   short side = 0;
2125
2126   /* loop over strips, checking if they fall within the range */
2127   for (strip = strips->first; strip; strip = strip->next) {
2128     /* check if current time occurs within this strip  */
2129     if (IN_RANGE_INCL(ctime, strip->start, strip->end) ||
2130         (strip->flag & NLASTRIP_FLAG_NO_TIME_MAP)) {
2131       /* this strip is active, so try to use it */
2132       estrip = strip;
2133       side = NES_TIME_WITHIN;
2134       break;
2135     }
2136
2137     /* if time occurred before current strip... */
2138     if (ctime < strip->start) {
2139       if (strip == strips->first) {
2140         /* before first strip - only try to use it if it extends backwards in time too */
2141         if (strip->extendmode == NLASTRIP_EXTEND_HOLD) {
2142           estrip = strip;
2143         }
2144
2145         /* side is 'before' regardless of whether there's a useful strip */
2146         side = NES_TIME_BEFORE;
2147       }
2148       else {
2149         /* before next strip - previous strip has ended, but next hasn't begun,
2150          * so blending mode depends on whether strip is being held or not...
2151          * - only occurs when no transition strip added, otherwise the transition would have
2152          *   been picked up above...
2153          */
2154         strip = strip->prev;
2155
2156         if (strip->extendmode != NLASTRIP_EXTEND_NOTHING) {
2157           estrip = strip;
2158         }
2159         side = NES_TIME_AFTER;
2160       }
2161       break;
2162     }
2163
2164     /* if time occurred after current strip... */
2165     if (ctime > strip->end) {
2166       /* only if this is the last strip should we do anything, and only if that is being held */
2167       if (strip == strips->last) {
2168         if (strip->extendmode != NLASTRIP_EXTEND_NOTHING) {
2169           estrip = strip;
2170         }
2171
2172         side = NES_TIME_AFTER;
2173         break;
2174       }
2175
2176       /* otherwise, skip... as the 'before' case will catch it more elegantly! */
2177     }
2178   }
2179
2180   /* check if a valid strip was found
2181    * - must not be muted (i.e. will have contribution
2182    */
2183   if ((estrip == NULL) || (estrip->flag & NLASTRIP_FLAG_MUTED)) {
2184     return NULL;
2185   }
2186
2187   /* if ctime was not within the boundaries of the strip, clamp! */
2188   switch (side) {
2189     case NES_TIME_BEFORE: /* extend first frame only */
2190       ctime = estrip->start;
2191       break;
2192     case NES_TIME_AFTER: /* extend last frame only */
2193       ctime = estrip->end;
2194       break;
2195   }
2196
2197   /* evaluate strip's evaluation controls
2198    * - skip if no influence (i.e. same effect as muting the strip)
2199    * - negative influence is not supported yet... how would that be defined?
2200    */
2201   /* TODO: this sounds a bit hacky having a few isolated F-Curves
2202    * stuck on some data it operates on... */
2203   nlastrip_evaluate_controls(estrip, ctime, flush_to_original);
2204   if (estrip->influence <= 0.0f) {
2205     return NULL;
2206   }
2207
2208   /* check if strip has valid data to evaluate,
2209    * and/or perform any additional type-specific actions
2210    */
2211   switch (estrip->type) {
2212     case NLASTRIP_TYPE_CLIP:
2213       /* clip must have some action to evaluate */
2214       if (estrip->act == NULL) {
2215         return NULL;
2216       }
2217       break;
2218     case NLASTRIP_TYPE_TRANSITION:
2219       /* there must be strips to transition from and to (i.e. prev and next required) */
2220       if (ELEM(NULL, estrip->prev, estrip->next)) {
2221         return NULL;
2222       }
2223
2224       /* evaluate controls for the relevant extents of the bordering strips... */
2225       nlastrip_evaluate_controls(estrip->prev, estrip->start, flush_to_original);
2226       nlastrip_evaluate_controls(estrip->next, estrip->end, flush_to_original);
2227       break;
2228   }
2229
2230   /* add to list of strips we need to evaluate */
2231   nes = MEM_callocN(sizeof(NlaEvalStrip), "NlaEvalStrip");
2232
2233   nes->strip = estrip;
2234   nes->strip_mode = side;
2235   nes->track_index = index;
2236   nes->strip_time = estrip->strip_time;
2237
2238   if (list) {
2239     BLI_addtail(list, nes);
2240   }
2241
2242   return nes;
2243 }
2244
2245 /* ---------------------- */
2246
2247 /* Initialize a valid mask, allocating memory if necessary. */
2248 static void nlavalidmask_init(NlaValidMask *mask, int bits)
2249 {
2250   if (BLI_BITMAP_SIZE(bits) > sizeof(mask->buffer)) {
2251     mask->ptr = BLI_BITMAP_NEW(bits, "NlaValidMask");
2252   }
2253   else {
2254     mask->ptr = mask->buffer;
2255   }
2256 }
2257
2258 /* Free allocated memory for the mask. */
2259 static void nlavalidmask_free(NlaValidMask *mask)
2260 {
2261   if (mask->ptr != mask->buffer) {
2262     MEM_freeN(mask->ptr);
2263   }
2264 }
2265
2266 /* ---------------------- */
2267
2268 /* Hashing functions for NlaEvalChannelKey. */
2269 static uint nlaevalchan_keyhash(const void *ptr)
2270 {
2271   const NlaEvalChannelKey *key = ptr;
2272   uint hash = BLI_ghashutil_ptrhash(key->ptr.data);
2273   return hash ^ BLI_ghashutil_ptrhash(key->prop);
2274 }
2275
2276 static bool nlaevalchan_keycmp(const void *a, const void *b)
2277 {
2278   const NlaEvalChannelKey *A = a;
2279   const NlaEvalChannelKey *B = b;
2280
2281   return ((A->ptr.data != B->ptr.data) || (A->prop != B->prop));
2282 }
2283
2284 /* ---------------------- */
2285
2286 /* Allocate a new blending value snapshot for the channel. */
2287 static NlaEvalChannelSnapshot *nlaevalchan_snapshot_new(NlaEvalChannel *nec)
2288 {
2289   int length = nec->base_snapshot.length;
2290
2291   size_t byte_size = sizeof(NlaEvalChannelSnapshot) + sizeof(float) * length;
2292   NlaEvalChannelSnapshot *nec_snapshot = MEM_callocN(byte_size, "NlaEvalChannelSnapshot");
2293
2294   nec_snapshot->channel = nec;
2295   nec_snapshot->length = length;
2296
2297   return nec_snapshot;
2298 }
2299
2300 /* Free a channel's blending value snapshot. */
2301 static void nlaevalchan_snapshot_free(NlaEvalChannelSnapshot *nec_snapshot)
2302 {
2303   BLI_assert(!nec_snapshot->is_base);
2304
2305   MEM_freeN(nec_snapshot);
2306 }
2307
2308 /* Copy all data in the snapshot. */
2309 static void nlaevalchan_snapshot_copy(NlaEvalChannelSnapshot *dst,
2310                                       const NlaEvalChannelSnapshot *src)
2311 {
2312   BLI_assert(dst->channel == src->channel);
2313
2314   memcpy(dst->values, src->values, sizeof(float) * dst->length);
2315 }
2316
2317 /* ---------------------- */
2318
2319 /* Initialize a blending state snapshot structure. */
2320 static void nlaeval_snapshot_init(NlaEvalSnapshot *snapshot,
2321                                   NlaEvalData *nlaeval,
2322                                   NlaEvalSnapshot *base)
2323 {
2324   snapshot->base = base;
2325   snapshot->size = MAX2(16, nlaeval->num_channels);
2326   snapshot->channels = MEM_callocN(sizeof(*snapshot->channels) * snapshot->size,
2327                                    "NlaEvalSnapshot::channels");
2328 }
2329
2330 /* Retrieve the individual channel snapshot. */
2331 static NlaEvalChannelSnapshot *nlaeval_snapshot_get(NlaEvalSnapshot *snapshot, int index)
2332 {
2333   return (index < snapshot->size) ? snapshot->channels[index] : NULL;
2334 }
2335
2336 /* Ensure at least this number of slots exists. */
2337 static void nlaeval_snapshot_ensure_size(NlaEvalSnapshot *snapshot, int size)
2338 {
2339   if (size > snapshot->size) {
2340     snapshot->size *= 2;
2341     CLAMP_MIN(snapshot->size, size);
2342     CLAMP_MIN(snapshot->size, 16);
2343
2344     size_t byte_size = sizeof(*snapshot->channels) * snapshot->size;
2345     snapshot->channels = MEM_recallocN_id(
2346         snapshot->channels, byte_size, "NlaEvalSnapshot::channels");
2347   }
2348 }
2349
2350 /* Retrieve the address of a slot in the blending state snapshot for this channel (may realloc). */
2351 static NlaEvalChannelSnapshot **nlaeval_snapshot_ensure_slot(NlaEvalSnapshot *snapshot,
2352                                                              NlaEvalChannel *nec)
2353 {
2354   nlaeval_snapshot_ensure_size(snapshot, nec->owner->num_channels);
2355   return &snapshot->channels[nec->index];
2356 }
2357
2358 /* Retrieve the blending snapshot for the specified channel, with fallback to base. */
2359 static NlaEvalChannelSnapshot *nlaeval_snapshot_find_channel(NlaEvalSnapshot *snapshot,
2360                                                              NlaEvalChannel *nec)
2361 {
2362   while (snapshot != NULL) {
2363     NlaEvalChannelSnapshot *nec_snapshot = nlaeval_snapshot_get(snapshot, nec->index);
2364     if (nec_snapshot != NULL) {
2365       return nec_snapshot;
2366     }
2367     snapshot = snapshot->base;
2368   }
2369
2370   return &nec->base_snapshot;
2371 }
2372
2373 /* Retrieve or create the channel value snapshot, copying from the other snapshot
2374  * (or default values) */
2375 static NlaEvalChannelSnapshot *nlaeval_snapshot_ensure_channel(NlaEvalSnapshot *snapshot,
2376                                                                NlaEvalChannel *nec)
2377 {
2378   NlaEvalChannelSnapshot **slot = nlaeval_snapshot_ensure_slot(snapshot, nec);
2379
2380   if (*slot == NULL) {
2381     NlaEvalChannelSnapshot *base_snapshot, *nec_snapshot;
2382
2383     nec_snapshot = nlaevalchan_snapshot_new(nec);
2384     base_snapshot = nlaeval_snapshot_find_channel(snapshot->base, nec);
2385
2386     nlaevalchan_snapshot_copy(nec_snapshot, base_snapshot);
2387
2388     *slot = nec_snapshot;
2389   }
2390
2391   return *slot;
2392 }
2393
2394 /* Free all memory owned by this blending snapshot structure. */
2395 static void nlaeval_snapshot_free_data(NlaEvalSnapshot *snapshot)
2396 {
2397   if (snapshot->channels != NULL) {
2398     for (int i = 0; i < snapshot->size; i++) {
2399       NlaEvalChannelSnapshot *nec_snapshot = snapshot->channels[i];
2400       if (nec_snapshot != NULL) {
2401         nlaevalchan_snapshot_free(nec_snapshot);
2402       }
2403     }
2404
2405     MEM_freeN(snapshot->channels);
2406   }
2407
2408   snapshot->base = NULL;
2409   snapshot->size = 0;
2410   snapshot->channels = NULL;
2411 }
2412
2413 /* ---------------------- */
2414
2415 /* Free memory owned by this evaluation channel. */
2416 static void nlaevalchan_free_data(NlaEvalChannel *nec)
2417 {
2418   nlavalidmask_free(&nec->valid);
2419
2420   if (nec->blend_snapshot != NULL) {
2421     nlaevalchan_snapshot_free(nec->blend_snapshot);
2422   }
2423 }
2424
2425 /* Initialize a full NLA evaluation state structure. */
2426 static void nlaeval_init(NlaEvalData *nlaeval)
2427 {
2428   memset(nlaeval, 0, sizeof(*nlaeval));
2429
2430   nlaeval->path_hash = BLI_ghash_str_new("NlaEvalData::path_hash");
2431   nlaeval->key_hash = BLI_ghash_new(
2432       nlaevalchan_keyhash, nlaevalchan_keycmp, "NlaEvalData::key_hash");
2433 }
2434
2435 static void nlaeval_free(NlaEvalData *nlaeval)
2436 {
2437   /* Delete base snapshot - its channels are part of NlaEvalChannel and shouldn't be freed. */
2438   MEM_SAFE_FREE(nlaeval->base_snapshot.channels);
2439
2440   /* Delete result snapshot. */
2441   nlaeval_snapshot_free_data(&nlaeval->eval_snapshot);
2442
2443   /* Delete channels. */
2444   for (NlaEvalChannel *nec = nlaeval->channels.first; nec; nec = nec->next) {
2445     nlaevalchan_free_data(nec);
2446   }
2447
2448   BLI_freelistN(&nlaeval->channels);
2449   BLI_ghash_free(nlaeval->path_hash, NULL, NULL);
2450   BLI_ghash_free(nlaeval->key_hash, NULL, NULL);
2451 }
2452
2453 /* ---------------------- */
2454
2455 static int nlaevalchan_validate_index(NlaEvalChannel *nec, int index)
2456 {
2457   if (nec->is_array) {
2458     if (index >= 0 && index < nec->base_snapshot.length) {
2459       return index;
2460     }
2461
2462     return -1;
2463   }
2464   else {
2465     return 0;
2466   }
2467 }
2468
2469 /* Initialise default values for NlaEvalChannel from the property data. */
2470 static void nlaevalchan_get_default_values(NlaEvalChannel *nec, float *r_values)
2471 {
2472   PointerRNA *ptr = &nec->key.ptr;
2473   PropertyRNA *prop = nec->key.prop;
2474   int length = nec->base_snapshot.length;
2475
2476   /* Use unit quaternion for quaternion properties. */
2477   if (nec->mix_mode == NEC_MIX_QUATERNION) {
2478     unit_qt(r_values);
2479     return;
2480   }
2481   /* Use all zero for Axis-Angle properties. */
2482   if (nec->mix_mode == NEC_MIX_AXIS_ANGLE) {
2483     zero_v4(r_values);
2484     return;
2485   }
2486
2487   /* NOTE: while this doesn't work for all RNA properties as default values aren't in fact
2488    * set properly for most of them, at least the common ones (which also happen to get used
2489    * in NLA strips a lot, e.g. scale) are set correctly.
2490    */
2491   if (RNA_property_array_check(prop)) {
2492     BLI_assert(length == RNA_property_array_length(ptr, prop));
2493     bool *tmp_bool;
2494     int *tmp_int;
2495
2496     switch (RNA_property_type(prop)) {
2497       case PROP_BOOLEAN:
2498         tmp_bool = MEM_malloc_arrayN(sizeof(*tmp_bool), length, __func__);
2499         RNA_property_boolean_get_default_array(ptr, prop, tmp_bool);
2500         for (int i = 0; i < length; i++) {
2501           r_values[i] = (float)tmp_bool[i];
2502         }
2503         MEM_freeN(tmp_bool);
2504         break;
2505       case PROP_INT:
2506         tmp_int = MEM_malloc_arrayN(sizeof(*tmp_int), length, __func__);
2507         RNA_property_int_get_default_array(ptr, prop, tmp_int);
2508         for (int i = 0; i < length; i++) {
2509           r_values[i] = (float)tmp_int[i];
2510         }
2511         MEM_freeN(tmp_int);
2512         break;
2513       case PROP_FLOAT:
2514         RNA_property_float_get_default_array(ptr, prop, r_values);
2515         break;
2516       default:
2517         memset(r_values, 0, sizeof(float) * length);
2518     }
2519   }
2520   else {
2521     BLI_assert(length == 1);
2522
2523     switch (RNA_property_type(prop)) {
2524       case PROP_BOOLEAN:
2525         *r_values = (float)RNA_property_boolean_get_default(ptr, prop);
2526         break;
2527       case PROP_INT:
2528         *r_values = (float)RNA_property_int_get_default(ptr, prop);
2529         break;
2530       case PROP_FLOAT:
2531         *r_values = RNA_property_float_get_default(ptr, prop);
2532         break;
2533       case PROP_ENUM:
2534         *r_values = (float)RNA_property_enum_get_default(ptr, prop);
2535         break;
2536       default:
2537         *r_values = 0.0f;
2538     }
2539   }
2540
2541   /* Ensure multiplicative properties aren't reset to 0. */
2542   if (nec->mix_mode == NEC_MIX_MULTIPLY) {
2543     for (int i = 0; i < length; i++) {
2544       if (r_values[i] == 0.0f) {
2545         r_values[i] = 1.0f;
2546       }
2547     }
2548   }
2549 }
2550
2551 static char nlaevalchan_detect_mix_mode(NlaEvalChannelKey *key, int length)
2552 {
2553   PropertySubType subtype = RNA_property_subtype(key->prop);
2554
2555   if (subtype == PROP_QUATERNION && length == 4) {
2556     return NEC_MIX_QUATERNION;
2557   }
2558   else if (subtype == PROP_AXISANGLE && length == 4) {
2559     return NEC_MIX_AXIS_ANGLE;
2560   }
2561   else if (RNA_property_flag(key->prop) & PROP_PROPORTIONAL) {
2562     return NEC_MIX_MULTIPLY;
2563   }
2564   else {
2565     return NEC_MIX_ADD;
2566   }
2567 }
2568
2569 /* Verify that an appropriate NlaEvalChannel for this property exists. */
2570 static NlaEvalChannel *nlaevalchan_verify_key(NlaEvalData *nlaeval,
2571                                               const char *path,
2572                                               NlaEvalChannelKey *key)
2573 {
2574   /* Look it up in the key hash. */
2575   NlaEvalChannel **p_key_nec;
2576   NlaEvalChannelKey **p_key;
2577   bool found_key = BLI_ghash_ensure_p_ex(
2578       nlaeval->key_hash, key, (void ***)&p_key, (void ***)&p_key_nec);
2579
2580   if (found_key) {
2581     return *p_key_nec;
2582   }
2583
2584   /* Create the channel. */
2585   bool is_array = RNA_property_array_check(key->prop);
2586   int length = is_array ? RNA_property_array_length(&key->ptr, key->prop) : 1;
2587
2588   NlaEvalChannel *nec = MEM_callocN(sizeof(NlaEvalChannel) + sizeof(float) * length,
2589                                     "NlaEvalChannel");
2590
2591   /* Initialize the channel. */
2592   nec->rna_path = path;
2593   nec->key = *key;
2594
2595   nec->owner = nlaeval;
2596   nec->index = nlaeval->num_channels++;
2597   nec->is_array = is_array;
2598
2599   nec->mix_mode = nlaevalchan_detect_mix_mode(key, length);
2600
2601   nlavalidmask_init(&nec->valid, length);
2602
2603   nec->base_snapshot.channel = nec;
2604   nec->base_snapshot.length = length;
2605   nec->base_snapshot.is_base = true;
2606
2607   nlaevalchan_get_default_values(nec, nec->base_snapshot.values);
2608
2609   /* Store channel in data structures. */
2610   BLI_addtail(&nlaeval->channels, nec);
2611
2612   *nlaeval_snapshot_ensure_slot(&nlaeval->base_snapshot, nec) = &nec->base_snapshot;
2613
2614   *p_key_nec = nec;
2615   *p_key = &nec->key;
2616
2617   return nec;
2618 }
2619
2620 /* Verify that an appropriate NlaEvalChannel for this path exists. */
2621 static NlaEvalChannel *nlaevalchan_verify(PointerRNA *ptr, NlaEvalData *nlaeval, const char *path)
2622 {
2623   if (path == NULL) {
2624     return NULL;
2625   }
2626
2627   /* Lookup the path in the path based hash. */
2628   NlaEvalChannel **p_path_nec;
2629   bool found_path = BLI_ghash_ensure_p(nlaeval->path_hash, (void *)path, (void ***)&p_path_nec);
2630
2631   if (found_path) {
2632     return *p_path_nec;
2633   }
2634
2635   /* Cache NULL result for now. */
2636   *p_path_nec = NULL;
2637
2638   /* Resolve the property and look it up in the key hash. */
2639   NlaEvalChannelKey key;
2640
2641   if (!RNA_path_resolve_property(ptr, path, &key.ptr, &key.prop)) {
2642     /* Report failure to resolve the path. */
2643     if (G.debug & G_DEBUG) {
2644       CLOG_WARN(&LOG,
2645                 "Animato: Invalid path. ID = '%s',  '%s'",
2646                 (ptr->id.data) ? (((ID *)ptr->id.data)->name + 2) : "<No ID>",
2647                 path);
2648     }
2649
2650     return NULL;
2651   }
2652
2653   /* Check that the property can be animated. */
2654   if (ptr->id.data != NULL && !RNA_property_animateable(&key.ptr, key.prop)) {
2655     return NULL;
2656   }
2657
2658   NlaEvalChannel *nec = nlaevalchan_verify_key(nlaeval, path, &key);
2659
2660   if (nec->rna_path == NULL) {
2661     nec->rna_path = path;
2662   }
2663
2664   return *p_path_nec = nec;
2665 }
2666
2667 /* ---------------------- */
2668
2669 /* accumulate the old and new values of a channel according to mode and influence */
2670 static float nla_blend_value(int blendmode, float old_value, float value, float inf)
2671 {
2672   /* optimisation: no need to try applying if there is no influence */
2673   if (IS_EQF(inf, 0.0f)) {
2674     return old_value;
2675   }
2676
2677   /* perform blending */
2678   switch (blendmode) {
2679     case NLASTRIP_MODE_ADD:
2680       /* simply add the scaled value on to the stack */
2681       return old_value + (value * inf);
2682
2683     case NLASTRIP_MODE_SUBTRACT:
2684       /* simply subtract the scaled value from the stack */
2685       return old_value - (value * inf);
2686
2687     case NLASTRIP_MODE_MULTIPLY:
2688       /* multiply the scaled value with the stack */
2689       /* Formula Used:
2690        *     result = fac * (a * b) + (1 - fac) * a
2691        */
2692       return inf * (old_value * value) + (1 - inf) * old_value;
2693
2694     case NLASTRIP_MODE_COMBINE:
2695       BLI_assert(!"combine mode");
2696       ATTR_FALLTHROUGH;
2697
2698     case NLASTRIP_MODE_REPLACE:
2699     default
2700         : /* TODO: do we really want to blend by default? it seems more uses might prefer add... */
2701       /* do linear interpolation
2702        * - the influence of the accumulated data (elsewhere, that is called dstweight)
2703        *   is 1 - influence, since the strip's influence is srcweight
2704        */
2705       return old_value * (1.0f - inf) + (value * inf);
2706   }
2707 }
2708
2709 /* accumulate the old and new values of a channel according to mode and influence */
2710 static float nla_combine_value(
2711     int mix_mode, float base_value, float old_value, float value, float inf)
2712 {
2713   /* optimisation: no need to try applying if there is no influence */
2714   if (IS_EQF(inf, 0.0f)) {
2715     return old_value;
2716   }
2717
2718   /* perform blending */
2719   switch (mix_mode) {
2720     case NEC_MIX_ADD:
2721     case NEC_MIX_AXIS_ANGLE:
2722       return old_value + (value - base_value) * inf;
2723
2724     case NEC_MIX_MULTIPLY:
2725       if (base_value == 0.0f) {
2726         base_value = 1.0f;
2727       }
2728       return old_value * powf(value / base_value, inf);
2729
2730     case NEC_MIX_QUATERNION:
2731     default:
2732       BLI_assert(!"invalid mix mode");
2733       return old_value;
2734   }
2735 }
2736
2737 /* compute the value that would blend to the desired target value using nla_blend_value */
2738 static bool nla_invert_blend_value(
2739     int blend_mode, float old_value, float target_value, float influence, float *r_value)
2740 {
2741   switch (blend_mode) {
2742     case NLASTRIP_MODE_ADD:
2743       *r_value = (target_value - old_value) / influence;
2744       return true;
2745
2746     case NLASTRIP_MODE_SUBTRACT:
2747       *r_value = (old_value - target_value) / influence;
2748       return true;
2749
2750     case NLASTRIP_MODE_MULTIPLY:
2751       if (old_value == 0.0f) {
2752         /* Resolve 0/0 to 1. */
2753         if (target_value == 0.0f) {
2754           *r_value = 1.0f;
2755           return true;
2756         }
2757         /* Division by zero. */
2758         return false;
2759       }
2760       else {
2761         *r_value = (target_value - old_value) / influence / old_value + 1.0f;
2762         return true;
2763       }
2764
2765     case NLASTRIP_MODE_COMBINE:
2766       BLI_assert(!"combine mode");
2767       ATTR_FALLTHROUGH;
2768
2769     case NLASTRIP_MODE_REPLACE:
2770     default:
2771       *r_value = (target_value - old_value) / influence + old_value;
2772       return true;
2773   }
2774 }
2775
2776 /* compute the value that would blend to the desired target value using nla_combine_value */
2777 static bool nla_invert_combine_value(int mix_mode,
2778                                      float base_value,
2779                                      float old_value,
2780                                      float target_value,
2781                                      float influence,
2782                                      float *r_value)
2783 {
2784   switch (mix_mode) {
2785     case NEC_MIX_ADD:
2786     case NEC_MIX_AXIS_ANGLE:
2787       *r_value = base_value + (target_value - old_value) / influence;
2788       return true;
2789
2790     case NEC_MIX_MULTIPLY:
2791       if (base_value == 0.0f) {
2792         base_value = 1.0f;
2793       }
2794       if (old_value == 0.0f) {
2795         /* Resolve 0/0 to 1. */
2796         if (target_value == 0.0f) {
2797           *r_value = base_value;
2798           return true;
2799         }
2800         /* Division by zero. */
2801         return false;
2802       }
2803       else {
2804         *r_value = base_value * powf(target_value / old_value, 1.0f / influence);
2805         return true;
2806       }
2807
2808     case NEC_MIX_QUATERNION:
2809     default:
2810       BLI_assert(!"invalid mix mode");
2811       return false;
2812   }
2813 }
2814
2815 /* accumulate quaternion channels for Combine mode according to influence */
2816 static void nla_combine_quaternion(const float old_values[4],
2817                                    const float values[4],
2818                                    float influence,
2819                                    float result[4])
2820 {
2821   float tmp_old[4], tmp_new[4];
2822
2823   normalize_qt_qt(tmp_old, old_values);
2824   normalize_qt_qt(tmp_new, values);
2825
2826   pow_qt_fl_normalized(tmp_new, influence);
2827   mul_qt_qtqt(result, tmp_old, tmp_new);
2828 }
2829
2830 /* invert accumulation of quaternion channels for Combine mode according to influence */
2831 static void nla_invert_combine_quaternion(const float old_values[4],
2832                                           const float values[4],
2833                                           float influence,
2834                                           float result[4])
2835 {
2836   float tmp_old[4], tmp_new[4];
2837
2838   normalize_qt_qt(tmp_old, old_values);
2839   normalize_qt_qt(tmp_new, values);
2840   invert_qt_normalized(tmp_old);
2841
2842   mul_qt_qtqt(result, tmp_old, tmp_new);
2843   pow_qt_fl_normalized(result, 1.0f / influence);
2844 }
2845
2846 /* Data about the current blend mode. */
2847 typedef struct NlaBlendData {
2848   NlaEvalSnapshot *snapshot;
2849   int mode;
2850   float influence;
2851
2852   NlaEvalChannel *blend_queue;
2853 } NlaBlendData;
2854
2855 /* Queue the channel for deferred blending. */
2856 static NlaEvalChannelSnapshot *nlaevalchan_queue_blend(NlaBlendData *blend, NlaEvalChannel *nec)
2857 {
2858   if (!nec->in_blend) {
2859     if (nec->blend_snapshot == NULL) {
2860       nec->blend_snapshot = nlaevalchan_snapshot_new(nec);
2861     }
2862
2863     nec->in_blend = true;
2864     nlaevalchan_snapshot_copy(nec->blend_snapshot, &nec->base_snapshot);
2865
2866     nec->next_blend = blend->blend_queue;
2867     blend->blend_queue = nec;
2868   }
2869
2870   return nec->blend_snapshot;
2871 }
2872
2873 /* Accumulate (i.e. blend) the given value on to the channel it affects. */
2874 static bool nlaeval_blend_value(NlaBlendData *blend,
2875                                 NlaEvalChannel *nec,
2876                                 int array_index,
2877                                 float value)
2878 {
2879   if (nec == NULL) {
2880     return false;
2881   }
2882
2883   int index = nlaevalchan_validate_index(nec, array_index);
2884
2885   if (index < 0) {
2886     if (G.debug & G_DEBUG) {
2887       ID *id = nec->key.ptr.id.data;
2888       CLOG_WARN(&LOG,
2889                 "Animato: Invalid array index. ID = '%s',  '%s[%d]', array length is %d",
2890                 id ? (id->name + 2) : "<No ID>",
2891                 nec->rna_path,
2892                 array_index,
2893                 nec->base_snapshot.length);
2894     }
2895
2896     return false;
2897   }
2898
2899   if (nec->mix_mode == NEC_MIX_QUATERNION) {
2900     /* For quaternion properties, always output all sub-channels. */
2901     BLI_bitmap_set_all(nec->valid.ptr, true, 4);
2902   }
2903   else {
2904     BLI_BITMAP_ENABLE(nec->valid.ptr, index);
2905   }
2906
2907   NlaEvalChannelSnapshot *nec_snapshot = nlaeval_snapshot_ensure_channel(blend->snapshot, nec);
2908   float *p_value = &nec_snapshot->values[index];
2909
2910   if (blend->mode == NLASTRIP_MODE_COMBINE) {
2911     /* Quaternion blending is deferred until all sub-channel values are known. */
2912     if (nec->mix_mode == NEC_MIX_QUATERNION) {
2913       NlaEvalChannelSnapshot *blend_snapshot = nlaevalchan_queue_blend(blend, nec);
2914
2915       blend_snapshot->values[index] = value;
2916     }
2917     else {
2918       float base_value = nec->base_snapshot.values[index];
2919
2920       *p_value = nla_combine_value(nec->mix_mode, base_value, *p_value, value, blend->influence);
2921     }
2922   }
2923   else {
2924     *p_value = nla_blend_value(blend->mode, *p_value, value, blend->influence);
2925   }
2926
2927   return true;
2928 }
2929
2930 /* Finish deferred quaternion blending. */
2931 static void nlaeval_blend_flush(NlaBlendData *blend)
2932 {
2933   NlaEvalChannel *nec;
2934
2935   while ((nec = blend->blend_queue)) {
2936     blend->blend_queue = nec->next_blend;
2937     nec->in_blend = false;
2938
2939     NlaEvalChannelSnapshot *nec_snapshot = nlaeval_snapshot_ensure_channel(blend->snapshot, nec);
2940     NlaEvalChannelSnapshot *blend_snapshot = nec->blend_snapshot;
2941
2942     if (nec->mix_mode == NEC_MIX_QUATERNION) {
2943       nla_combine_quaternion(
2944           nec_snapshot->values, blend_snapshot->values, blend->influence, nec_snapshot->values);
2945     }
2946     else {
2947       BLI_assert(!"mix quaternion");
2948     }
2949   }
2950 }
2951
2952 /* Blend the specified snapshots into the target, and free the input snapshots. */
2953 static void nlaeval_snapshot_mix_and_free(NlaEvalData *nlaeval,
2954                                           NlaEvalSnapshot *out,
2955                                           NlaEvalSnapshot *in1,
2956                                           NlaEvalSnapshot *in2,
2957                                           float alpha)
2958 {
2959   BLI_assert(in1->base == out && in2->base == out);
2960
2961   nlaeval_snapshot_ensure_size(out, nlaeval->num_channels);
2962
2963   for (int i = 0; i < nlaeval->num_channels; i++) {
2964     NlaEvalChannelSnapshot *c_in1 = nlaeval_snapshot_get(in1, i);
2965     NlaEvalChannelSnapshot *c_in2 = nlaeval_snapshot_get(in2, i);
2966
2967     if (c_in1 || c_in2) {
2968       NlaEvalChannelSnapshot *c_out = out->channels[i];
2969
2970       /* Steal the entry from one of the input snapshots. */
2971       if (c_out == NULL) {
2972         if (c_in1 != NULL) {
2973           c_out = c_in1;
2974           in1->channels[i] = NULL;
2975         }
2976         else {
2977           c_out = c_in2;
2978           in2->channels[i] = NULL;
2979         }
2980       }
2981
2982       if (c_in1 == NULL) {
2983         c_in1 = nlaeval_snapshot_find_channel(in1->base, c_out->channel);
2984       }
2985       if (c_in2 == NULL) {
2986         c_in2 = nlaeval_snapshot_find_channel(in2->base, c_out->channel);
2987       }
2988
2989       out->channels[i] = c_out;
2990
2991       for (int j = 0; j < c_out->length; j++) {
2992         c_out->values[j] = c_in1->values[j] * (1.0f - alpha) + c_in2->values[j] * alpha;
2993       }
2994     }
2995   }
2996
2997   nlaeval_snapshot_free_data(in1);
2998   nlaeval_snapshot_free_data(in2);
2999 }
3000
3001 /* ---------------------- */
3002 /* F-Modifier stack joining/separation utilities -
3003  * should we generalize these for BLI_listbase.h interface? */
3004
3005 /* Temporarily join two lists of modifiers together, storing the result in a third list */
3006 static void nlaeval_fmodifiers_join_stacks(ListBase *result, ListBase *list1, ListBase *list2)
3007 {
3008   FModifier *fcm1, *fcm2;
3009
3010   /* if list1 is invalid...  */
3011   if (ELEM(NULL, list1, list1->first)) {
3012     if (list2 && list2->first) {
3013       result->first = list2->first;
3014       result->last = list2->last;
3015     }
3016   }
3017   /* if list 2 is invalid... */
3018   else if (ELEM(NULL, list2, list2->first)) {
3019     result->first = list1->first;
3020     result->last = list1->last;
3021   }
3022   else {
3023     /* list1 should be added first, and list2 second,
3024      * with the endpoints of these being the endpoints for result
3025      * - the original lists must be left unchanged though, as we need that fact for restoring.
3026      */
3027     result->first = list1->first;
3028     result->last = list2->last;
3029
3030     fcm1 = list1->last;
3031     fcm2 = list2->first;
3032
3033     fcm1->next = fcm2;
3034     fcm2->prev = fcm1;
3035   }
3036 }
3037
3038 /* Split two temporary lists of modifiers */
3039 static void nlaeval_fmodifiers_split_stacks(ListBase *list1, ListBase *list2)
3040 {
3041   FModifier *fcm1, *fcm2;
3042
3043   /* if list1/2 is invalid... just skip */
3044   if (ELEM(NULL, list1, list2)) {
3045     return;
3046   }
3047   if (ELEM(NULL, list1->first, list2->first)) {
3048     return;
3049   }
3050
3051   /* get endpoints */
3052   fcm1 = list1->last;
3053   fcm2 = list2->first;
3054
3055   /* clear their links */
3056   fcm1->next = NULL;
3057   fcm2->prev = NULL;
3058 }
3059
3060 /* ---------------------- */
3061
3062 /* evaluate action-clip strip */
3063 static void nlastrip_evaluate_actionclip(PointerRNA *ptr,
3064                                          NlaEvalData *channels,
3065                                          ListBase *modifiers,
3066                                          NlaEvalStrip *nes,
3067                                          NlaEvalSnapshot *snapshot)
3068 {
3069   ListBase tmp_modifiers = {NULL, NULL};
3070   NlaStrip *strip = nes->strip;
3071   FCurve *fcu;
3072   float evaltime;
3073
3074   /* sanity checks for action */
3075   if (strip == NULL) {
3076     return;
3077   }
3078
3079   if (strip->act == NULL) {
3080     CLOG_ERROR(&LOG, "NLA-Strip Eval Error: Strip '%s' has no Action", strip->name);
3081     return;
3082   }
3083
3084   action_idcode_patch_check(ptr->id.data, strip->act);
3085
3086   /* join this strip's modifiers to the parent's modifiers (own modifiers first) */
3087   nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &strip->modifiers, modifiers);
3088
3089   /* evaluate strip's modifiers which modify time to evaluate the base curves at */
3090   FModifiersStackStorage storage;
3091   storage.modifier_count = BLI_listbase_count(&tmp_modifiers);
3092   storage.size_per_modifier = evaluate_fmodifiers_storage_size_per_modifier(&tmp_modifiers);
3093   storage.buffer = alloca(storage.modifier_count * storage.size_per_modifier);
3094
3095   evaltime = evaluate_time_fmodifiers(&storage, &tmp_modifiers, NULL, 0.0f, strip->strip_time);
3096
3097   NlaBlendData blend = {
3098       .snapshot = snapshot,
3099       .mode = strip->blendmode,
3100       .influence = strip->influence,
3101   };
3102
3103   /* Evaluate all the F-Curves in the action,
3104    * saving the relevant pointers to data that will need to be used. */
3105   for (fcu = strip->act->curves.first; fcu; fcu = fcu->next) {
3106     float value = 0.0f;
3107
3108     /* check if this curve should be skipped */
3109     if (fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED)) {
3110       continue;
3111     }
3112     if ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED)) {
3113       continue;
3114     }
3115     if (BKE_fcurve_is_empty(fcu)) {
3116       continue;
3117     }
3118
3119     /* evaluate the F-Curve's value for the time given in the strip
3120      * NOTE: we use the modified time here, since strip's F-Curve Modifiers
3121      * are applied on top of this.
3122      */
3123     value = evaluate_fcurve(fcu, evaltime);
3124
3125     /* apply strip's F-Curve Modifiers on this value
3126      * NOTE: we apply the strip's original evaluation time not the modified one
3127      * (as per standard F-Curve eval)
3128      */
3129     evaluate_value_fmodifiers(&storage, &tmp_modifiers, fcu, &value, strip->strip_time);
3130
3131     /* Get an NLA evaluation channel to work with,
3132      * and accumulate the evaluated value with the value(s)
3133      * stored in this channel if it has been used already. */
3134     NlaEvalChannel *nec = nlaevalchan_verify(ptr, channels, fcu->rna_path);
3135
3136     nlaeval_blend_value(&blend, nec, fcu->array_index, value);
3137   }
3138
3139   nlaeval_blend_flush(&blend);
3140
3141   /* unlink this strip's modifiers from the parent's modifiers again */
3142   nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);
3143 }
3144
3145 /* evaluate transition strip */
3146 static void nlastrip_evaluate_transition(PointerRNA *ptr,
3147                                          NlaEvalData *channels,
3148                                          ListBase *modifiers,
3149                                          NlaEvalStrip *nes,
3150                                          NlaEvalSnapshot *snapshot,
3151                                          const bool flush_to_original)
3152 {
3153   ListBase tmp_modifiers = {NULL, NULL};
3154   NlaEvalSnapshot snapshot1, snapshot2;
3155   NlaEvalStrip tmp_nes;
3156   NlaStrip *s1, *s2;
3157
3158   /* join this strip's modifiers to the parent's modifiers (own modifiers first) */
3159   nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &nes->strip->modifiers, modifiers);
3160
3161   /* get the two strips to operate on
3162    * - we use the endpoints of the strips directly flanking our strip
3163    *   using these as the endpoints of the transition (destination and source)
3164    * - these should have already been determined to be valid...
3165    * - if this strip is being played in reverse, we need to swap these endpoints
3166    *   otherwise they will be interpolated wrong
3167    */
3168   if (nes->strip->flag & NLASTRIP_FLAG_REVERSE) {
3169     s1 = nes->strip->next;
3170     s2 = nes->strip->prev;
3171   }
3172   else {
3173     s1 = nes->strip->prev;
3174     s2 = nes->strip->next;
3175   }
3176
3177   /* prepare template for 'evaluation strip'
3178    * - based on the transition strip's evaluation strip data
3179    * - strip_mode is NES_TIME_TRANSITION_* based on which endpoint
3180    * - strip_time is the 'normalized' (i.e. in-strip) time for evaluation,
3181    *   which doubles up as an additional weighting factor for the strip influences
3182    *   which allows us to appear to be 'interpolating' between the two extremes
3183    */
3184   tmp_nes = *nes;
3185
3186   /* evaluate these strips into a temp-buffer (tmp_channels) */
3187   /* FIXME: modifier evaluation here needs some work... */
3188   /* first strip */
3189   tmp_nes.strip_mode = NES_TIME_TRANSITION_START;
3190   tmp_nes.strip = s1;
3191   nlaeval_snapshot_init(&snapshot1, channels, snapshot);
3192   nlastrip_evaluate(ptr, channels, &tmp_modifiers, &tmp_nes, &snapshot1, flush_to_original);
3193
3194   /* second strip */
3195   tmp_nes.strip_mode = NES_TIME_TRANSITION_END;
3196   tmp_nes.strip = s2;
3197   nlaeval_snapshot_init(&snapshot2, channels, snapshot);
3198   nlastrip_evaluate(ptr, channels, &tmp_modifiers, &tmp_nes, &snapshot2, flush_to_original);
3199
3200   /* accumulate temp-buffer and full-buffer, using the 'real' strip */
3201   nlaeval_snapshot_mix_and_free(channels, snapshot, &snapshot1, &snapshot2, nes->strip_time);
3202
3203   /* unlink this strip's modifiers from the parent's modifiers again */
3204   nlaeval_fmodifiers_split_stacks(&nes->strip->modifiers, modifiers);
3205 }
3206
3207 /* evaluate meta-strip */
3208 static void nlastrip_evaluate_meta(PointerRNA *ptr,
3209                                    NlaEvalData *channels,
3210                                    ListBase *modifiers,
3211                                    NlaEvalStrip *nes,
3212                                    NlaEvalSnapshot *snapshot,
3213                                    const bool flush_to_original)
3214 {
3215   ListBase tmp_modifiers = {NULL, NULL};
3216   NlaStrip *strip = nes->strip;
3217   NlaEvalStrip *tmp_nes;
3218   float evaltime;
3219
3220   /* meta-strip was calculated normally to have some time to be evaluated at
3221    * and here we 'look inside' the meta strip, treating it as a decorated window to
3222    * it's child strips, which get evaluated as if they were some tracks on a strip
3223    * (but with some extra modifiers to apply).
3224    *
3225    * NOTE: keep this in sync with animsys_evaluate_nla()
3226    */
3227
3228   /* join this strip's modifiers to the parent's modifiers (own modifiers first) */
3229   nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &strip->modifiers, modifiers);
3230
3231   /* find the child-strip to evaluate */
3232   evaltime = (nes->strip_time * (strip->end - strip->start)) + strip->start;
3233   tmp_nes = nlastrips_ctime_get_strip(NULL, &strip->strips, -1, evaltime, flush_to_original);
3234
3235   /* directly evaluate child strip into accumulation buffer...
3236    * - there's no need to use a temporary buffer (as it causes issues [T40082])
3237    */
3238   if (tmp_nes) {
3239     nlastrip_evaluate(ptr, channels, &tmp_modifiers, tmp_nes, snapshot, flush_to_original);
3240
3241     /* free temp eval-strip */
3242     MEM_freeN(tmp_nes);
3243   }
3244
3245   /* unlink this strip's modifiers from the parent's modifiers again */
3246   nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);
3247 }
3248
3249 /* evaluates the given evaluation strip */
3250 void nlastrip_evaluate(PointerRNA *ptr,
3251                        NlaEvalData *channels,
3252                        ListBase *modifiers,
3253                        NlaEvalStrip *nes,
3254                        NlaEvalSnapshot *snapshot,
3255                        const bool flush_to_original)
3256 {
3257   NlaStrip *strip = nes->strip;
3258
3259   /* To prevent potential infinite recursion problems
3260    * (i.e. transition strip, beside meta strip containing a transition
3261    * several levels deep inside it),
3262    * we tag the current strip as being evaluated, and clear this when we leave.
3263    */
3264   /* TODO: be careful with this flag, since some edit tools may be running and have
3265    * set this while animation playback was running. */
3266   if (strip->flag & NLASTRIP_FLAG_EDIT_TOUCHED) {
3267     return;
3268   }
3269   strip->flag |= NLASTRIP_FLAG_EDIT_TOUCHED;
3270
3271   /* actions to take depend on the type of strip */
3272   switch (strip->type) {
3273     case NLASTRIP_TYPE_CLIP: /* action-clip */
3274       nlastrip_evaluate_actionclip(ptr, channels, modifiers, nes, snapshot);
3275       break;
3276     case NLASTRIP_TYPE_TRANSITION: /* transition */
3277       nlastrip_evaluate_transition(ptr, channels, modifiers, nes, snapshot, flush_to_original);
3278       break;
3279     case NLASTRIP_TYPE_META: /* meta */
3280       nlastrip_evaluate_meta(ptr, channels, modifiers, nes, snapshot, flush_to_original);
3281       break;
3282
3283     default: /* do nothing */
3284       break;
3285   }
3286
3287   /* clear temp recursion safe-check */
3288   strip->flag &= ~NLASTRIP_FLAG_EDIT_TOUCHED;
3289 }
3290
3291 /* write the accumulated settings to */
3292 void nladata_flush_channels(PointerRNA *ptr,
3293                             NlaEvalData *channels,
3294                             NlaEvalSnapshot *snapshot,
3295                             const bool flush_to_original)
3296 {
3297   /* sanity checks */
3298   if (channels == NULL) {
3299     return;
3300   }
3301
3302   /* for each channel with accumulated values, write its value on the property it affects */
3303   for (NlaEvalChannel *nec = channels->channels.first; nec; nec = nec->next) {
3304     NlaEvalChannelSnapshot *nec_snapshot = nlaeval_snapshot_find_channel(snapshot, nec);
3305
3306     PathResolvedRNA rna = {nec->key.ptr, nec->key.prop, -1};
3307
3308     for (int i = 0; i < nec_snapshot->length; i++) {
3309       if (BLI_BITMAP_TEST(nec->valid.ptr, i)) {
3310         float value = nec_snapshot->values[i];
3311         if (nec->is_array) {
3312           rna.prop_index = i;
3313         }
3314         animsys_write_rna_setting(&rna, value);
3315         if (flush_to_original) {
3316           animsys_write_orig_anim_rna(ptr, nec->rna_path, rna.prop_index, value);
3317         }
3318       }
3319     }
3320   }
3321 }
3322
3323 /* ---------------------- */
3324
3325 static void nla_eval_domain_action(PointerRNA *ptr,
3326                                    NlaEvalData *channels,
3327                                    bAction *act,
3328                                    GSet *touched_actions)
3329 {
3330   if (!BLI_gset_add(touched_actions, act)) {
3331     return;
3332   }
3333
3334   for (FCurve *fcu = act->curves.first; fcu; fcu = fcu->next) {
3335     /* check if this curve should be skipped */
3336     if (fcu->flag & (FCURVE_MUTED | FCURVE_DISABLED)) {
3337       continue;
3338     }
3339     if ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED)) {
3340       continue;
3341     }
3342     if (BKE_fcurve_is_empty(fcu)) {
3343       continue;
3344     }
3345
3346     NlaEvalChannel *nec = nlaevalchan_verify(ptr, channels, fcu->rna_path);
3347
3348     if (nec != NULL) {
3349       /* For quaternion properties, enable all sub-channels. */
3350       if (nec->mix_mode == NEC_MIX_QUATERNION) {
3351         BLI_bitmap_set_all(nec->valid.ptr, true, 4);
3352         continue;
3353       }
3354
3355       int idx = nlaevalchan_validate_index(nec, fcu->array_index);
3356
3357       if (idx >= 0) {
3358         BLI_BITMAP_ENABLE(nec->valid.ptr, idx);
3359       }
3360     }
3361   }
3362 }
3363
3364 static void nla_eval_domain_strips(PointerRNA *ptr,
3365                                    NlaEvalData *channels,
3366                                    ListBase *strips,
3367                                    GSet *touched_actions)
3368 {
3369   for (NlaStrip *strip = strips->first; strip; strip = strip->next) {
3370     /* check strip's action */
3371     if (strip->act) {
3372       nla_eval_domain_action(ptr, channels, strip->act, touched_actions);
3373     }
3374
3375     /* check sub-strips (if metas) */
3376     nla_eval_domain_strips(ptr, channels, &strip->strips, touched_actions);
3377   }
3378 }
3379
3380 /**
3381  * Ensure that all channels touched by any of the actions in enabled tracks exist.
3382  * This is necessary to ensure that evaluation result depends only on current frame.
3383  */
3384 static void animsys_evaluate_nla_domain(PointerRNA *ptr, NlaEvalData *channels, AnimData *adt)
3385 {
3386   GSet *touched_actions = BLI_gset_ptr_new(__func__);
3387
3388   if (adt->action) {
3389     nla_eval_domain_action(ptr, channels, adt->action, touched_actions);
3390   }
3391
3392   /* NLA Data - Animation Data for Strips */
3393   for (NlaTrack *nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
3394     /* solo and muting are mutually exclusive... */
3395     if (adt->flag & ADT_NLA_SOLO_TRACK) {
3396       /* skip if there is a solo track, but this isn't it */
3397       if ((nlt->flag & NLATRACK_SOLO) == 0) {
3398         continue;
3399       }
3400       /* else - mute doesn't matter */
3401     }
3402     else {
3403       /* no solo tracks - skip track if muted */
3404       if (nlt->flag & NLATRACK_MUTED) {
3405         continue;
3406       }
3407     }
3408
3409     nla_eval_domain_strips(ptr, channels, &nlt->strips, touched_actions);
3410   }
3411
3412   BLI_gset_free(touched_actions, NULL);
3413 }
3414
3415 /* ---------------------- */
3416
3417 /**
3418  * NLA Evaluation function - values are calculated and stored in temporary "NlaEvalChannels"
3419  *
3420  * \param[out] echannels: Evaluation channels with calculated values
3421  * \param[out] r_context: If not NULL,
3422  * data about the currently edited strip is stored here and excluded from value calculation.
3423  * \return false if NLA evaluation isn't actually applicable.
3424  */
3425 static bool animsys_evaluate_nla(NlaEvalData *echannels,
3426                                  PointerRNA *ptr,
3427                                  AnimData *adt,
3428                                  float ctime,
3429                                  const bool flush_to_original,
3430                                  NlaKeyframingContext *r_context)
3431 {
3432   NlaTrack *nlt;
3433   short track_index = 0;
3434   bool has_strips = false;
3435
3436   ListBase estrips = {NULL, NULL};
3437   NlaEvalStrip *nes;
3438   NlaStrip dummy_strip_buf;
3439
3440   /* dummy strip for active action */
3441   NlaStrip *dummy_strip = r_context ? &r_context->strip : &dummy_strip_buf;
3442
3443   memset(dummy_strip, 0, sizeof(*dummy_strip));
3444
3445   /* 1. get the stack of strips to evaluate at current time (influence calculated here) */
3446   for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next, track_index++) {
3447     /* stop here if tweaking is on and this strip is the tweaking track
3448      * (it will be the first one that's 'disabled')... */
3449     if ((adt->flag & ADT_NLA_EDIT_ON) && (nlt->flag & NLATRACK_DISABLED)) {
3450       break;
3451     }
3452
3453     /* solo and muting are mutually exclusive... */
3454     if (adt->flag & ADT_NLA_SOLO_TRACK) {
3455       /* skip if there is a solo track, but this isn't it */
3456       if ((nlt->flag & NLATRACK_SOLO) == 0) {
3457         continue;
3458       }
3459       /* else - mute doesn't matter */
3460     }
3461     else {
3462       /* no solo tracks - skip track if muted */
3463       if (nlt->flag & NLATRACK_MUTED) {
3464         continue;
3465       }
3466     }
3467
3468     /* if this track has strips (but maybe they won't be suitable), set has_strips
3469      * - used for mainly for still allowing normal action evaluation...
3470      */
3471     if (nlt->strips.first) {
3472       has_strips = true;
3473     }
3474
3475     /* otherwise, get strip to evaluate for this channel */
3476     nes = nlastrips_ctime_get_strip(&estrips, &nlt->strips, track_index, ctime, flush_to_original);
3477     if (nes) {
3478       nes->track = nlt;
3479     }
3480   }
3481
3482   /* add 'active' Action (may be tweaking track) as last strip to evaluate in NLA stack
3483    * - only do this if we're not exclusively evaluating the 'solo' NLA-track
3484    * - however, if the 'solo' track houses the current 'tweaking' strip,
3485    *   then we should allow this to play, otherwise nothing happens
3486    */
3487   if ((adt->action) && ((adt->flag & ADT_NLA_SOLO_TRACK) == 0 || (adt->flag & ADT_NLA_EDIT_ON))) {
3488     /* if there are strips, evaluate action as per NLA rules */
3489     if ((has_strips) || (adt->actstrip)) {
3490       /* make dummy NLA strip, and add that to the stack */
3491       ListBase dummy_trackslist;
3492
3493       dummy_trackslist.first = dummy_trackslist.last = dummy_strip;
3494
3495       /* Strips with a user-defined time curve don't get properly remapped for editing
3496        * at the moment, so mapping them just for display may be confusing. */
3497       bool is_inplace_tweak = (nlt) && !(adt->flag & ADT_NLA_EDIT_NOMAP) &&
3498                               !(adt->actstrip->flag & NLASTRIP_FLAG_USR_TIME);
3499
3500       if (is_inplace_tweak) {
3501         /* edit active action in-place according to its active strip, so copy the data  */
3502         memcpy(dummy_strip, adt->actstrip, sizeof(NlaStrip));
3503         dummy_strip->next = dummy_strip->prev = NULL;
3504       }
3505       else {
3506         /* set settings of dummy NLA strip from AnimData settings */
3507         dummy_strip->act = adt->action;
3508
3509         /* action range is calculated taking F-Modifiers into account
3510          * (which making new strips doesn't do due to the troublesome nature of that) */
3511         calc_action_range(dummy_strip->act, &dummy_strip->actstart, &dummy_strip->actend, 1);
3512         dummy_strip->start = dummy_strip->actstart;
3513         dummy_strip->end = (IS_EQF(dummy_strip->actstart, dummy_strip->actend)) ?
3514                                (dummy_strip->actstart + 1.0f) :
3515                                (dummy_strip->actend);
3516
3517         /* Always use the blend mode of the strip in tweak mode, even if not in-place. */
3518         if (nlt && adt->actstrip) {
3519           dummy_strip->blendmode = adt->actstrip->blendmode;
3520           dummy_strip->extendmode = NLASTRIP_EXTEND_HOLD;
3521         }
3522         else {
3523           dummy_strip->blendmode = adt->act_blendmode;
3524           dummy_strip->extendmode = adt->act_extendmode;
3525         }
3526
3527         /* Unless extend-mode is Nothing (might be useful for flattening NLA evaluation),
3528          * disable range. */
3529         if (dummy_strip->extendmode != NLASTRIP_EXTEND_NOTHING) {
3530           dummy_strip->flag |= NLASTRIP_FLAG_NO_TIME_MAP;
3531         }
3532
3533         dummy_strip->influence = adt->act_influence;
3534
3535         /* NOTE: must set this, or else the default setting overrides,
3536          * and this setting doesn't work. */
3537         dummy_strip->flag |= NLASTRIP_FLAG_USR_INFLUENCE;
3538       }
3539
3540       /* add this to our list of evaluation strips */
3541       if (r_context == NULL) {
3542         nlastrips_ctime_get_strip(&estrips, &dummy_trackslist, -1, ctime, flush_to_original);
3543       }
3544       /* If computing the context for keyframing, store data there instead of the list. */
3545       else {
3546         /* The extend mode here effectively controls
3547          * whether it is possible to key-frame beyond the ends. */
3548         dummy_strip->extendmode = is_inplace_tweak ? NLASTRIP_EXTEND_NOTHING :
3549                                                      NLASTRIP_EXTEND_HOLD;
3550
3551         r_context->eval_strip = nes = nlastrips_ctime_get_strip(
3552             NULL, &dummy_trackslist, -1, ctime, flush_to_original);
3553
3554         /* These setting combinations require no data from strips below, so exit immediately. */
3555         if ((nes == NULL) ||
3556             (dummy_strip->blendmode == NLASTRIP_MODE_REPLACE && dummy_strip->influence == 1.0f)) {
3557           BLI_freelistN(&estrips);
3558           return true;
3559         }
3560       }
3561     }
3562     else {
3563       /* special case - evaluate as if there isn't any NLA data */
3564       BLI_freelistN(&estrips);
3565       return false;
3566     }
3567   }
3568
3569   /* only continue if there are strips to evaluate */
3570   if (BLI_listbase_is_empty(&estrips)) {
3571     return true;
3572   }
3573
3574   /* 2. for each strip, evaluate then accumulate on top of existing channels,
3575    * but don't set values yet. */
3576   for (nes = estrips.first; nes; nes = nes->next) {
3577     nlastrip_evaluate(ptr, echannels, NULL, nes, &echannels->eval_snapshot, flush_to_original);
3578   }
3579
3580   /* 3. free temporary evaluation data that's not used elsewhere */
3581   BLI_freelistN(&estrips);
3582   return true;
3583 }
3584
3585 /* NLA Evaluation function (mostly for use through do_animdata)
3586  * - All channels that will be affected are not cleared anymore. Instead, we just evaluate into
3587  *   some temp channels, where values can be accumulated in one go.
3588  */
3589 static void animsys_calculate_nla(PointerRNA *ptr,
3590                                   AnimData *adt,
3591                                   float ctime,
3592                                   const bool flush_to_original)
3593 {
3594   NlaEvalData echannels;
3595
3596   nlaeval_init(&echannels);
3597
3598   /* evaluate the NLA stack, obtaining a set of values to flush */
3599   if (animsys_evaluate_nla(&echannels, ptr, adt, ctime, flush_to_original, NULL)) {
3600     /* reset any channels touched by currently inactive actions to default value */
3601     animsys_evaluate_nla_domain(ptr, &echannels, adt);
3602
3603     /* flush effects of accumulating channels in NLA to the actual data they affect */
3604     nladata_flush_channels(ptr, &echannels, &echannels.eval_snapshot, flush_to_original);
3605   }
3606   else {
3607     /* special case - evaluate as if there isn't any NLA data */
3608     /* TODO: this is really just a stop-gap measure... */
3609     if (G.debug & G_DEBUG) {
3610       CLOG_WARN(&LOG, "NLA Eval: Stopgap for active action on NLA Stack - no strips case");
3611     }
3612
3613     animsys_evaluate_action(ptr, adt->action, ctime, flush_to_original);
3614   }
3615
3616   /* free temp data */
3617   nlaeval_free(&echannels);
3618 }
3619
3620 /* ---------------------- */
3621
3622 /**
3623  * Prepare data necessary to compute correct keyframe values for NLA strips
3624  * with non-Replace mode or influence different from 1.
3625  *
3626  * \param cache: List used to cache contexts for reuse when keying
3627  * multiple channels in one operation.
3628  * \param ptr: RNA pointer to the Object with the animation.
3629  * \return Keyframing context, or NULL if not necessary.
3630  */
3631 NlaKeyframingContext *BKE_animsys_get_nla_keyframing_context(struct ListBase *cache,