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