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