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