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