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