b81d611065da584460b1cc63c67dce46cc56528a
[blender.git] / source / blender / blenkernel / intern / anim_sys.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Joshua Leung (full recode)
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <stdio.h>
31 #include <string.h>
32 #include <stddef.h>
33 #include <float.h>
34 #include <math.h>
35
36 #include "MEM_guardedalloc.h"
37
38 #include "BLI_blenlib.h"
39 #include "BKE_library.h"
40 #include "BLI_dynstr.h"
41
42 #include "DNA_anim_types.h"
43 #include "DNA_material_types.h"
44 #include "DNA_scene_types.h"
45 #include "DNA_texture_types.h"
46
47 #include "BKE_animsys.h"
48 #include "BKE_action.h"
49 #include "BKE_fcurve.h"
50 #include "BKE_nla.h"
51 #include "BKE_global.h"
52 #include "BKE_main.h"
53 #include "BKE_utildefines.h"
54
55 #include "RNA_access.h"
56
57 #include "nla_private.h"
58
59 /* ***************************************** */
60 /* AnimData API */
61
62 /* Getter/Setter -------------------------------------------- */
63
64 /* Check if ID can have AnimData */
65 short id_type_can_have_animdata (ID *id)
66 {
67         /* sanity check */
68         if (id == NULL)
69                 return 0;
70                 
71         /* Only some ID-blocks have this info for now */
72         // TODO: finish adding this for the other blocktypes
73         switch (GS(id->name)) {
74                         /* has AnimData */
75                 case ID_OB:
76                 case ID_ME: case ID_MB: case ID_CU: case ID_AR: case ID_LT:
77                 case ID_KE:
78                 case ID_PA:
79                 case ID_MA: case ID_TE: case ID_NT:
80                 case ID_LA: case ID_CA: case ID_WO:
81                 case ID_SCE:
82                 {
83                         return 1;
84                 }
85                 
86                         /* no AnimData */
87                 default:
88                         return 0;
89         }
90 }
91
92
93 /* Get AnimData from the given ID-block. In order for this to work, we assume that 
94  * the AnimData pointer is stored immediately after the given ID-block in the struct,
95  * as per IdAdtTemplate.
96  */
97 AnimData *BKE_animdata_from_id (ID *id)
98 {
99         /* only some ID-blocks have this info for now, so we cast the 
100          * types that do to be of type IdAdtTemplate, and extract the
101          * AnimData that way
102          */
103         if (id_type_can_have_animdata(id)) {
104                 IdAdtTemplate *iat= (IdAdtTemplate *)id;
105                 return iat->adt;
106         }
107         else
108                 return NULL;
109 }
110
111 /* Add AnimData to the given ID-block. In order for this to work, we assume that 
112  * the AnimData pointer is stored immediately after the given ID-block in the struct,
113  * as per IdAdtTemplate. Also note that 
114  */
115 AnimData *BKE_id_add_animdata (ID *id)
116 {
117         /* Only some ID-blocks have this info for now, so we cast the 
118          * types that do to be of type IdAdtTemplate, and add the AnimData
119          * to it using the template
120          */
121         if (id_type_can_have_animdata(id)) {
122                 IdAdtTemplate *iat= (IdAdtTemplate *)id;
123                 
124                 /* check if there's already AnimData, in which case, don't add */
125                 if (iat->adt == NULL) {
126                         AnimData *adt;
127                         
128                         /* add animdata */
129                         adt= iat->adt= MEM_callocN(sizeof(AnimData), "AnimData");
130                         
131                         /* set default settings */
132                         adt->act_influence= 1.0f;
133                 }
134                 
135                 return iat->adt;
136         }
137         else 
138                 return NULL;
139 }
140
141 /* Freeing -------------------------------------------- */
142
143 /* Free AnimData used by the nominated ID-block, and clear ID-block's AnimData pointer */
144 void BKE_free_animdata (ID *id)
145 {
146         /* Only some ID-blocks have this info for now, so we cast the 
147          * types that do to be of type IdAdtTemplate
148          */
149         if (id_type_can_have_animdata(id)) {
150                 IdAdtTemplate *iat= (IdAdtTemplate *)id;
151                 AnimData *adt= iat->adt;
152                 
153                 /* check if there's any AnimData to start with */
154                 if (adt) {
155                         /* unlink action (don't free, as it's in its own list) */
156                         if (adt->action)
157                                 adt->action->id.us--;
158                         /* same goes for the temporarily displaced action */
159                         if (adt->tmpact)
160                                 adt->tmpact->id.us--;
161                                 
162                         /* free nla data */
163                         free_nladata(&adt->nla_tracks);
164                         
165                         /* free drivers - stored as a list of F-Curves */
166                         free_fcurves(&adt->drivers);
167                         
168                         /* free overrides */
169                         // TODO...
170                         
171                         /* free animdata now */
172                         MEM_freeN(adt);
173                         iat->adt= NULL;
174                 }
175         }
176 }
177
178 /* Freeing -------------------------------------------- */
179
180 /* Make a copy of the given AnimData - to be used when copying datablocks */
181 AnimData *BKE_copy_animdata (AnimData *adt, const short do_action)
182 {
183         AnimData *dadt;
184         
185         /* sanity check before duplicating struct */
186         if (adt == NULL)
187                 return NULL;
188         dadt= MEM_dupallocN(adt);
189         
190         /* make a copy of action - at worst, user has to delete copies... */
191         if(do_action) {
192                 dadt->action= copy_action(adt->action);
193                 dadt->tmpact= copy_action(adt->tmpact);
194         }
195         else {
196                 id_us_plus((ID *)dadt->action);
197                 id_us_plus((ID *)dadt->tmpact);
198         }
199
200         /* duplicate NLA data */
201         copy_nladata(&dadt->nla_tracks, &adt->nla_tracks);
202         
203         /* duplicate drivers (F-Curves) */
204         copy_fcurves(&dadt->drivers, &adt->drivers);
205         
206         /* don't copy overrides */
207         dadt->overrides.first= dadt->overrides.last= NULL;
208         
209         /* return */
210         return dadt;
211 }
212
213 int BKE_copy_animdata_id(struct ID *id_to, struct ID *id_from, const short do_action)
214 {
215         AnimData *adt;
216
217         if((id_to && id_from) && (GS(id_to->name) != GS(id_from->name)))
218                 return 0;
219
220         BKE_free_animdata(id_to);
221
222         adt = BKE_animdata_from_id(id_from);
223         if (adt) {
224                 IdAdtTemplate *iat = (IdAdtTemplate *)id_to;
225                 iat->adt= BKE_copy_animdata(adt, do_action);
226         }
227
228         return 1;
229 }
230
231 void BKE_copy_animdata_id_action(struct ID *id)
232 {
233         AnimData *adt= BKE_animdata_from_id(id);
234         if(adt) {
235                 if(adt->action) {
236                         ((ID *)adt->action)->us--;
237                         adt->action= copy_action(adt->action);
238                 }
239                 if(adt->tmpact) {
240                         ((ID *)adt->tmpact)->us--;
241                         adt->tmpact= copy_action(adt->tmpact);
242                 }
243         }
244 }
245
246 /* Make Local -------------------------------------------- */
247
248 static void make_local_strips(ListBase *strips)
249 {
250         NlaStrip *strip;
251
252         for (strip=strips->first; strip; strip=strip->next) {
253                 if (strip->act) make_local_action(strip->act);
254                 if (strip->remap && strip->remap->target) make_local_action(strip->remap->target);
255                 
256                 make_local_strips(&strip->strips);
257         }
258 }
259
260 /* Use local copy instead of linked copy of various ID-blocks */
261 void BKE_animdata_make_local(AnimData *adt)
262 {
263         NlaTrack *nlt;
264         
265         /* Actions - Active and Temp */
266         if (adt->action) make_local_action(adt->action);
267         if (adt->tmpact) make_local_action(adt->tmpact);
268         /* Remaps */
269         if (adt->remap && adt->remap->target) make_local_action(adt->remap->target);
270         
271         /* Drivers */
272         // TODO: need to remap the ID-targets too?
273         
274         /* NLA Data */
275         for (nlt=adt->nla_tracks.first; nlt; nlt=nlt->next) 
276                 make_local_strips(&nlt->strips);
277 }
278
279 /* Sub-ID Regrouping ------------------------------------------- */
280
281 /* helper heuristic for determining if a path is compatible with the basepath 
282  * < path: (str) full RNA-path from some data (usually an F-Curve) to compare
283  * < basepath: (str) shorter path fragment to look for
284  * > returns (bool) whether there is a match
285  */
286 static short animpath_matches_basepath (const char path[], const char basepath[])
287 {
288         /* we need start of path to be basepath */
289         return (path && basepath) && (strstr(path, basepath) == path);
290 }
291
292 /* Move F-Curves in src action to dst action, setting up all the necessary groups 
293  * for this to happen, but only if the F-Curves being moved have the appropriate 
294  * "base path". 
295  *      - This is used when data moves from one datablock to another, causing the
296  *        F-Curves to need to be moved over too
297  */
298 void action_move_fcurves_by_basepath (bAction *srcAct, bAction *dstAct, const char basepath[])
299 {
300         FCurve *fcu, *fcn=NULL;
301         
302         /* sanity checks */
303         if ELEM3(NULL, srcAct, dstAct, basepath) {
304                 if (G.f & G_DEBUG) {
305                         printf("ERROR: action_partition_fcurves_by_basepath(%p, %p, %p) has insufficient info to work with\n",
306                                         srcAct, dstAct, basepath);
307                 }
308                 return;
309         }
310                 
311         /* clear 'temp' flags on all groups in src, as we'll be needing them later 
312          * to identify groups that we've managed to empty out here
313          */
314         action_groups_clear_tempflags(srcAct);
315         
316         /* iterate over all src F-Curves, moving over the ones that need to be moved */
317         for (fcu = srcAct->curves.first; fcu; fcu = fcn) {
318                 /* store next pointer in case we move stuff */
319                 fcn = fcu->next;
320                 
321                 /* should F-Curve be moved over?
322                  *      - we only need the start of the path to match basepath
323                  */
324                 if (animpath_matches_basepath(fcu->rna_path, basepath)) {                       
325                         bActionGroup *agrp = NULL;
326                         
327                         /* if grouped... */
328                         if (fcu->grp) {
329                                 /* make sure there will be a matching group on the other side for the migrants */
330                                 agrp = action_groups_find_named(dstAct, fcu->grp->name);
331                                 
332                                 if (agrp == NULL) {
333                                         /* add a new one with a similar name (usually will be the same though) */
334                                         agrp = action_groups_add_new(dstAct, fcu->grp->name);
335                                 }
336                                 
337                                 /* old groups should be tagged with 'temp' flags so they can be removed later
338                                  * if we remove everything from them
339                                  */
340                                 fcu->grp->flag |= AGRP_TEMP;
341                         }
342                         
343                         /* perform the migration now */
344                         action_groups_remove_channel(srcAct, fcu);
345                         
346                         if (agrp)
347                                 action_groups_add_channel(dstAct, agrp, fcu);
348                         else
349                                 BLI_addtail(&dstAct->curves, fcu);
350                 }
351         }
352         
353         /* cleanup groups (if present) */
354         if (srcAct->groups.first) {
355                 bActionGroup *agrp, *grp=NULL;
356                 
357                 for (agrp = srcAct->groups.first; agrp; agrp = grp) {
358                         grp = agrp->next;
359                         
360                         /* only tagged groups need to be considered - clearing these tags or removing them */
361                         if (agrp->flag & AGRP_TEMP) {
362                                 /* if group is empty and tagged, then we can remove as this operation
363                                  * moved out all the channels that were formerly here
364                                  */
365                                 if (agrp->channels.first == NULL)
366                                         BLI_freelinkN(&srcAct->groups, agrp);
367                                 else
368                                         agrp->flag &= ~AGRP_TEMP;
369                         }
370                 }
371         }
372 }
373
374 /* Transfer the animation data from srcID to dstID where the srcID
375  * animation data is based off "basepath", creating new AnimData and
376  * associated data as necessary
377  */
378 void BKE_animdata_separate_by_basepath (ID *srcID, ID *dstID, ListBase *basepaths)
379 {
380         AnimData *srcAdt=NULL, *dstAdt=NULL;
381         LinkData *ld;
382         
383         /* sanity checks */
384         if ELEM(NULL, srcID, dstID) {
385                 if (G.f & G_DEBUG)
386                         printf("ERROR: no source or destination ID to separate AnimData with\n");
387                 return;
388         }
389         
390         /* get animdata from src, and create for destination (if needed) */
391         srcAdt = BKE_animdata_from_id(srcID);
392         dstAdt = BKE_id_add_animdata(dstID);
393         
394         if ELEM(NULL, srcAdt, dstAdt) {
395                 if (G.f & G_DEBUG)
396                         printf("ERROR: no AnimData for this pair of ID's\n");
397                 return;
398         }
399         
400         /* active action */
401         if (srcAdt->action) {
402                 /* set up an action if necessary, and name it in a similar way so that it can be easily found again */
403                 if (dstAdt->action == NULL) {
404                         dstAdt->action = add_empty_action(srcAdt->action->id.name+2);
405                 }
406                 else if (dstAdt->action == srcAdt->action) {
407                         printf("Argh! Source and Destination share animation! ('%s' and '%s' both use '%s') Making new empty action\n",
408                                 srcID->name, dstID->name, srcAdt->action->id.name);
409                         
410                         // TODO: review this...
411                         id_us_min(&dstAdt->action->id);
412                         dstAdt->action = add_empty_action(dstAdt->action->id.name+2);
413                 }
414                         
415                 /* loop over base paths, trying to fix for each one... */
416                 for (ld = basepaths->first; ld; ld = ld->next) {
417                         const char *basepath = (const char *)ld->data;
418                         action_move_fcurves_by_basepath(srcAdt->action, dstAdt->action, basepath);
419                 }
420         }
421         
422         /* drivers */
423         if (srcAdt->drivers.first) {
424                 FCurve *fcu, *fcn=NULL;
425                 
426                 /* check each driver against all the base paths to see if any should go */
427                 for (fcu = srcAdt->drivers.first; fcu; fcu = fcn) {
428                         fcn = fcu->next;
429                         
430                         /* try each basepath in turn, but stop on the first one which works */
431                         for (ld = basepaths->first; ld; ld = ld->next) {
432                                 const char *basepath = (const char *)ld->data;
433                                 
434                                 if (animpath_matches_basepath(fcu->rna_path, basepath)) {
435                                         /* just need to change lists */
436                                         BLI_remlink(&srcAdt->drivers, fcu);
437                                         BLI_addtail(&dstAdt->drivers, fcu);
438                                         
439                                         // TODO: add depsgraph flushing calls?
440                                         
441                                         /* can stop now, as moved already */
442                                         break;
443                                 }
444                         }
445                 }
446         }
447 }
448
449 /* Path Validation -------------------------------------------- */
450
451 /* Check if a given RNA Path is valid, by tracing it from the given ID, and seeing if we can resolve it */
452 static short check_rna_path_is_valid (ID *owner_id, char *path)
453 {
454         PointerRNA id_ptr, ptr;
455         PropertyRNA *prop=NULL;
456         
457         /* make initial RNA pointer to start resolving from */
458         RNA_id_pointer_create(owner_id, &id_ptr);
459         
460         /* try to resolve */
461         return RNA_path_resolve(&id_ptr, path, &ptr, &prop); 
462 }
463
464 /* Check if some given RNA Path needs fixing - free the given path and set a new one as appropriate 
465  * NOTE: we assume that oldName and newName have [" "] padding around them
466  */
467 static char *rna_path_rename_fix (ID *owner_id, const char *prefix, char *oldName, char *newName, char *oldpath, int verify_paths)
468 {
469         char *prefixPtr= strstr(oldpath, prefix);
470         char *oldNamePtr= strstr(oldpath, oldName);
471         int prefixLen= strlen(prefix);
472         int oldNameLen= strlen(oldName);
473         
474         /* only start fixing the path if the prefix and oldName feature in the path,
475          * and prefix occurs immediately before oldName
476          */
477         if ( (prefixPtr && oldNamePtr) && (prefixPtr+prefixLen == oldNamePtr) ) {
478                 /* if we haven't aren't able to resolve the path now, try again after fixing it */
479                 if (!verify_paths || check_rna_path_is_valid(owner_id, oldpath) == 0) {         
480                         DynStr *ds= BLI_dynstr_new();
481                         char *postfixPtr= oldNamePtr+oldNameLen;
482                         char *newPath = NULL;
483                         char oldChar;
484                         
485                         /* add the part of the string that goes up to the start of the prefix */
486                         if (prefixPtr > oldpath) {
487                                 oldChar= prefixPtr[0]; 
488                                 prefixPtr[0]= 0;
489                                 BLI_dynstr_append(ds, oldpath);
490                                 prefixPtr[0]= oldChar;
491                         }
492                         
493                         /* add the prefix */
494                         BLI_dynstr_append(ds, prefix);
495                         
496                         /* add the new name (complete with brackets) */
497                         BLI_dynstr_append(ds, newName);
498                         
499                         /* add the postfix */
500                         BLI_dynstr_append(ds, postfixPtr);
501                         
502                         /* create new path, and cleanup old data */
503                         newPath= BLI_dynstr_get_cstring(ds);
504                         BLI_dynstr_free(ds);
505                         
506                         /* check if the new path will solve our problems */
507                         // TODO: will need to check whether this step really helps in practice
508                         if (!verify_paths || check_rna_path_is_valid(owner_id, newPath)) {
509                                 /* free the old path, and return the new one, since we've solved the issues */
510                                 MEM_freeN(oldpath);
511                                 return newPath;
512                         }
513                         else {
514                                 /* still couldn't resolve the path... so, might as well just leave it alone */
515                                 MEM_freeN(newPath);
516                         }
517                 }
518         }
519         
520         /* the old path doesn't need to be changed */
521         return oldpath;
522 }
523
524 /* Check RNA-Paths for a list of F-Curves */
525 static void fcurves_path_rename_fix (ID *owner_id, const char *prefix, char *oldName, char *newName, ListBase *curves, int verify_paths)
526 {
527         FCurve *fcu;
528         
529         /* we need to check every curve... */
530         for (fcu= curves->first; fcu; fcu= fcu->next) {
531                 /* firstly, handle the F-Curve's own path */
532                 if (fcu->rna_path)
533                         fcu->rna_path= rna_path_rename_fix(owner_id, prefix, oldName, newName, fcu->rna_path, verify_paths);
534         }
535 }
536
537 /* Check RNA-Paths for a list of Drivers */
538 static void drivers_path_rename_fix (ID *owner_id, const char *prefix, char *oldName, char *newName, char *oldKey, char *newKey, ListBase *curves, int verify_paths)
539 {
540         FCurve *fcu;
541         
542         /* we need to check every curve - drivers are F-Curves too! */
543         for (fcu= curves->first; fcu; fcu= fcu->next) {
544                 /* firstly, handle the F-Curve's own path */
545                 if (fcu->rna_path)
546                         fcu->rna_path= rna_path_rename_fix(owner_id, prefix, oldKey, newKey, fcu->rna_path, verify_paths);
547                 
548                 /* driver? */
549                 if (fcu->driver) {
550                         ChannelDriver *driver= fcu->driver;
551                         DriverVar *dvar;
552                         
553                         /* driver variables */
554                         for (dvar= driver->variables.first; dvar; dvar=dvar->next) {
555                                 /* only change the used targets, since the others will need fixing manually anyway */
556                                 DRIVER_TARGETS_USED_LOOPER(dvar) 
557                                 {
558                                         /* rename RNA path */
559                                         if (dtar->rna_path)
560                                                 dtar->rna_path= rna_path_rename_fix(dtar->id, prefix, oldKey, newKey, dtar->rna_path, verify_paths);
561                                         
562                                         /* also fix the bone-name (if applicable) */
563                                         if (strstr(prefix, "bones")) {
564                                                 if ( ((dtar->id) && (GS(dtar->id->name) == ID_OB)) &&
565                                                          (dtar->pchan_name[0]) && (strcmp(oldName, dtar->pchan_name)==0) )
566                                                 {
567                                                         BLI_strncpy(dtar->pchan_name, newName, sizeof(dtar->pchan_name));
568                                                 }
569                                         }
570                                 }
571                                 DRIVER_TARGETS_LOOPER_END
572                         }
573                 }
574         }
575 }
576
577 /* Fix all RNA-Paths for Actions linked to NLA Strips */
578 static void nlastrips_path_rename_fix (ID *owner_id, const char *prefix, char *oldName, char *newName, ListBase *strips, int verify_paths)
579 {
580         NlaStrip *strip;
581         
582         /* recursively check strips, fixing only actions... */
583         for (strip= strips->first; strip; strip= strip->next) {
584                 /* fix strip's action */
585                 if (strip->act)
586                         fcurves_path_rename_fix(owner_id, prefix, oldName, newName, &strip->act->curves, verify_paths);
587                 /* ignore own F-Curves, since those are local...  */
588                 
589                 /* check sub-strips (if metas) */
590                 nlastrips_path_rename_fix(owner_id, prefix, oldName, newName, &strip->strips, verify_paths);
591         }
592 }
593
594 /* Fix all RNA-Paths in the AnimData block used by the given ID block
595  * NOTE: it is assumed that the structure we're replacing is <prefix><["><name><"]>
596  *              i.e. pose.bones["Bone"]
597  */
598 void BKE_animdata_fix_paths_rename (ID *owner_id, AnimData *adt, const char *prefix, char *oldName, char *newName, int oldSubscript, int newSubscript, int verify_paths)
599 {
600         NlaTrack *nlt;
601         char *oldN, *newN;
602         
603         /* if no AnimData, no need to proceed */
604         if (ELEM(NULL, owner_id, adt))
605                 return;
606         
607         if ((oldName != NULL) && (newName != NULL)) {
608                 /* pad the names with [" "] so that only exact matches are made */
609                 oldN= BLI_sprintfN("[\"%s\"]", oldName);
610                 newN= BLI_sprintfN("[\"%s\"]", newName);
611         } 
612         else {
613                 oldN= BLI_sprintfN("[%d]", oldSubscript);
614                 newN= BLI_sprintfN("[%d]", newSubscript);
615         }
616         
617         /* Active action and temp action */
618         if (adt->action)
619                 fcurves_path_rename_fix(owner_id, prefix, oldN, newN, &adt->action->curves, verify_paths);
620         if (adt->tmpact)
621                 fcurves_path_rename_fix(owner_id, prefix, oldN, newN, &adt->tmpact->curves, verify_paths);
622                 
623         /* Drivers - Drivers are really F-Curves */
624         drivers_path_rename_fix(owner_id, prefix, oldName, newName, oldN, newN, &adt->drivers, verify_paths);
625         
626         /* NLA Data - Animation Data for Strips */
627         for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next)
628                 nlastrips_path_rename_fix(owner_id, prefix, oldN, newN, &nlt->strips, verify_paths);
629                 
630         /* free the temp names */
631         MEM_freeN(oldN);
632         MEM_freeN(newN);
633 }
634
635 /* Whole Database Ops -------------------------------------------- */
636
637 /* apply the given callback function on all data in main database */
638 void BKE_animdata_main_cb (Main *mainptr, ID_AnimData_Edit_Callback func, void *user_data)
639 {
640         ID *id;
641
642         /* standard data version */
643 #define ANIMDATA_IDS_CB(first) \
644         for (id= first; id; id= id->next) { \
645                 AnimData *adt= BKE_animdata_from_id(id); \
646                 if (adt) func(id, adt, user_data); \
647         }
648         
649         /* "embedded" nodetree cases (i.e. scene/material/texture->nodetree) */
650 #define ANIMDATA_NODETREE_IDS_CB(first, NtId_Type) \
651         for (id= first; id; id= id->next) { \
652                 AnimData *adt= BKE_animdata_from_id(id); \
653                 NtId_Type *ntp= (NtId_Type *)id; \
654                 if (ntp->nodetree) { \
655                         AnimData *adt2= BKE_animdata_from_id((ID *)ntp); \
656                         if (adt2) func(id, adt2, user_data); \
657                 } \
658                 if (adt) func(id, adt, user_data); \
659         }
660         
661         /* nodes */
662         ANIMDATA_IDS_CB(mainptr->nodetree.first);
663         
664         /* textures */
665         ANIMDATA_NODETREE_IDS_CB(mainptr->tex.first, Tex);
666         
667         /* lamps */
668         ANIMDATA_IDS_CB(mainptr->lamp.first);
669         
670         /* materials */
671         ANIMDATA_NODETREE_IDS_CB(mainptr->mat.first, Material);
672         
673         /* cameras */
674         ANIMDATA_IDS_CB(mainptr->camera.first);
675         
676         /* shapekeys */
677         ANIMDATA_IDS_CB(mainptr->key.first);
678         
679         /* metaballs */
680         ANIMDATA_IDS_CB(mainptr->mball.first);
681         
682         /* curves */
683         ANIMDATA_IDS_CB(mainptr->curve.first);
684         
685         /* armatures */
686         ANIMDATA_IDS_CB(mainptr->armature.first);
687         
688         /* lattices */
689         ANIMDATA_IDS_CB(mainptr->latt.first);
690         
691         /* meshes */
692         ANIMDATA_IDS_CB(mainptr->mesh.first);
693         
694         /* particles */
695         ANIMDATA_IDS_CB(mainptr->particle.first);
696         
697         /* objects */
698         ANIMDATA_IDS_CB(mainptr->object.first);
699         
700         /* worlds */
701         ANIMDATA_IDS_CB(mainptr->world.first);
702         
703         /* scenes */
704         ANIMDATA_NODETREE_IDS_CB(mainptr->scene.first, Scene);
705 }
706
707 /* Fix all RNA-Paths throughout the database (directly access the Global.main version)
708  * NOTE: it is assumed that the structure we're replacing is <prefix><["><name><"]>
709  *              i.e. pose.bones["Bone"]
710  */
711 /* TODO: use BKE_animdata_main_cb for looping over all data  */
712 void BKE_all_animdata_fix_paths_rename (char *prefix, char *oldName, char *newName)
713 {
714         Main *mainptr= G.main;
715         ID *id;
716         
717         /* macro for less typing 
718          *      - whether animdata exists is checked for by the main renaming callback, though taking 
719          *        this outside of the function may make things slightly faster?
720          */
721 #define RENAMEFIX_ANIM_IDS(first) \
722         for (id= first; id; id= id->next) { \
723                 AnimData *adt= BKE_animdata_from_id(id); \
724                 BKE_animdata_fix_paths_rename(id, adt, prefix, oldName, newName, 0, 0, 1);\
725         }
726         
727         /* another version of this macro for nodetrees */
728 #define RENAMEFIX_ANIM_NODETREE_IDS(first, NtId_Type) \
729         for (id= first; id; id= id->next) { \
730                 AnimData *adt= BKE_animdata_from_id(id); \
731                 NtId_Type *ntp= (NtId_Type *)id; \
732                 if (ntp->nodetree) { \
733                         AnimData *adt2= BKE_animdata_from_id((ID *)ntp); \
734                         BKE_animdata_fix_paths_rename((ID *)ntp, adt2, prefix, oldName, newName, 0, 0, 1);\
735                 } \
736                 BKE_animdata_fix_paths_rename(id, adt, prefix, oldName, newName, 0, 0, 1);\
737         }
738         
739         /* nodes */
740         RENAMEFIX_ANIM_IDS(mainptr->nodetree.first);
741         
742         /* textures */
743         RENAMEFIX_ANIM_NODETREE_IDS(mainptr->tex.first, Tex);
744         
745         /* lamps */
746         RENAMEFIX_ANIM_IDS(mainptr->lamp.first);
747         
748         /* materials */
749         RENAMEFIX_ANIM_NODETREE_IDS(mainptr->mat.first, Material);
750         
751         /* cameras */
752         RENAMEFIX_ANIM_IDS(mainptr->camera.first);
753         
754         /* shapekeys */
755         RENAMEFIX_ANIM_IDS(mainptr->key.first);
756         
757         /* metaballs */
758         RENAMEFIX_ANIM_IDS(mainptr->mball.first);
759         
760         /* curves */
761         RENAMEFIX_ANIM_IDS(mainptr->curve.first);
762         
763         /* armatures */
764         RENAMEFIX_ANIM_IDS(mainptr->armature.first);
765         
766         /* lattices */
767         RENAMEFIX_ANIM_IDS(mainptr->latt.first);
768         
769         /* meshes */
770         RENAMEFIX_ANIM_IDS(mainptr->mesh.first);
771         
772         /* particles */
773         RENAMEFIX_ANIM_IDS(mainptr->particle.first);
774         
775         /* objects */
776         RENAMEFIX_ANIM_IDS(mainptr->object.first); 
777         
778         /* worlds */
779         RENAMEFIX_ANIM_IDS(mainptr->world.first);
780         
781         /* scenes */
782         RENAMEFIX_ANIM_NODETREE_IDS(mainptr->scene.first, Scene);
783 }
784
785 /* *********************************** */ 
786 /* KeyingSet API */
787
788 /* Finding Tools --------------------------- */
789
790 /* Find the first path that matches the given criteria */
791 // TODO: do we want some method to perform partial matches too?
792 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))
793 {
794         KS_Path *ksp;
795         
796         /* sanity checks */
797         if ELEM3(NULL, ks, rna_path, id)
798                 return NULL;
799         
800         /* loop over paths in the current KeyingSet, finding the first one where all settings match 
801          * (i.e. the first one where none of the checks fail and equal 0)
802          */
803         for (ksp= ks->paths.first; ksp; ksp= ksp->next) {
804                 short eq_id=1, eq_path=1, eq_index=1, eq_group=1;
805                 
806                 /* id */
807                 if (id != ksp->id)
808                         eq_id= 0;
809                 
810                 /* path */
811                 if ((ksp->rna_path==0) || strcmp(rna_path, ksp->rna_path))
812                         eq_path= 0;
813                         
814                 /* index - need to compare whole-array setting too... */
815                 if (ksp->array_index != array_index)
816                         eq_index= 0;
817                         
818                 /* group */
819                 if (group_name) {
820                         // FIXME: these checks need to be coded... for now, it's not too important though
821                 }
822                         
823                 /* if all aspects are ok, return */
824                 if (eq_id && eq_path && eq_index && eq_group)
825                         return ksp;
826         }
827         
828         /* none found */
829         return NULL;
830 }
831  
832 /* Defining Tools --------------------------- */
833
834 /* Used to create a new 'custom' KeyingSet for the user, that will be automatically added to the stack */
835 KeyingSet *BKE_keyingset_add (ListBase *list, const char name[], short flag, short keyingflag)
836 {
837         KeyingSet *ks;
838         
839         /* allocate new KeyingSet */
840         ks= MEM_callocN(sizeof(KeyingSet), "KeyingSet");
841
842         BLI_strncpy(ks->name, name ? name : "KeyingSet", sizeof(ks->name));
843
844         ks->flag= flag;
845         ks->keyingflag= keyingflag;
846         
847         /* add KeyingSet to list */
848         BLI_addtail(list, ks);
849         
850         /* make sure KeyingSet has a unique name (this helps with identification) */
851         BLI_uniquename(list, ks, "KeyingSet", '.', offsetof(KeyingSet, name), sizeof(ks->name));
852         
853         /* return new KeyingSet for further editing */
854         return ks;
855 }
856
857 /* Add a path to a KeyingSet. Nothing is returned for now...
858  * Checks are performed to ensure that destination is appropriate for the KeyingSet in question
859  */
860 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)
861 {
862         KS_Path *ksp;
863         
864         /* sanity checks */
865         if ELEM(NULL, ks, rna_path) {
866                 printf("ERROR: no Keying Set and/or RNA Path to add path with \n");
867                 return NULL;
868         }
869         
870         /* ID is required for all types of KeyingSets */
871         if (id == NULL) {
872                 printf("ERROR: No ID provided for Keying Set Path. \n");
873                 return NULL;
874         }
875         
876         /* don't add if there is already a matching KS_Path in the KeyingSet */
877         if (BKE_keyingset_find_path(ks, id, group_name, rna_path, array_index, groupmode)) {
878                 if (G.f & G_DEBUG)
879                         printf("ERROR: destination already exists in Keying Set \n");
880                 return NULL;
881         }
882         
883         /* allocate a new KeyingSet Path */
884         ksp= MEM_callocN(sizeof(KS_Path), "KeyingSet Path");
885         
886         /* just store absolute info */
887         ksp->id= id;
888         if (group_name)
889                 BLI_snprintf(ksp->group, 64, group_name);
890         else
891                 ksp->group[0]= '\0';
892         
893         /* store additional info for relative paths (just in case user makes the set relative) */
894         if (id)
895                 ksp->idtype= GS(id->name);
896         
897         /* just copy path info */
898         // TODO: should array index be checked too?
899         ksp->rna_path= BLI_strdupn(rna_path, strlen(rna_path));
900         ksp->array_index= array_index;
901         
902         /* store flags */
903         ksp->flag= flag;
904         ksp->groupmode= groupmode;
905         
906         /* add KeyingSet path to KeyingSet */
907         BLI_addtail(&ks->paths, ksp);
908         
909         /* return this path */
910         return ksp;
911 }       
912
913 /* Free the given Keying Set path */
914 void BKE_keyingset_free_path (KeyingSet *ks, KS_Path *ksp)
915 {
916         /* sanity check */
917         if ELEM(NULL, ks, ksp)
918                 return;
919         
920         /* free RNA-path info */
921         MEM_freeN(ksp->rna_path);
922         
923         /* free path itself */
924         BLI_freelinkN(&ks->paths, ksp);
925 }
926
927 /* Copy all KeyingSets in the given list */
928 void BKE_keyingsets_copy (ListBase *newlist, ListBase *list)
929 {
930         KeyingSet *ksn;
931         KS_Path *kspn;
932         
933         BLI_duplicatelist(newlist, list);
934
935         for (ksn=newlist->first; ksn; ksn=ksn->next) {
936                 BLI_duplicatelist(&ksn->paths, &ksn->paths);
937                 
938                 for (kspn=ksn->paths.first; kspn; kspn=kspn->next)
939                         kspn->rna_path= MEM_dupallocN(kspn->rna_path);
940         }
941 }
942
943 /* Freeing Tools --------------------------- */
944
945 /* Free data for KeyingSet but not set itself */
946 void BKE_keyingset_free (KeyingSet *ks)
947 {
948         KS_Path *ksp, *kspn;
949         
950         /* sanity check */
951         if (ks == NULL)
952                 return;
953         
954         /* free each path as we go to avoid looping twice */
955         for (ksp= ks->paths.first; ksp; ksp= kspn) {
956                 kspn= ksp->next;
957                 BKE_keyingset_free_path(ks, ksp);
958         }
959 }
960
961 /* Free all the KeyingSets in the given list */
962 void BKE_keyingsets_free (ListBase *list)
963 {
964         KeyingSet *ks, *ksn;
965         
966         /* sanity check */
967         if (list == NULL)
968                 return;
969         
970         /* loop over KeyingSets freeing them 
971          *      - BKE_keyingset_free() doesn't free the set itself, but it frees its sub-data
972          */
973         for (ks= list->first; ks; ks= ksn) {
974                 ksn= ks->next;
975                 BKE_keyingset_free(ks);
976                 BLI_freelinkN(list, ks);
977         }
978 }
979
980 /* ***************************************** */
981 /* Evaluation Data-Setting Backend */
982
983 /* Retrieve string to act as RNA-path, adjusted using mapping-table if provided 
984  * It returns whether the string needs to be freed (i.e. if it was a temp remapped one)
985  * // 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
986  *
987  *      - remap: remapping table to use
988  *      - path: original path string (as stored in F-Curve data)
989  *      - dst: destination string to write data to
990  */
991 static short animsys_remap_path (AnimMapper *UNUSED(remap), char *path, char **dst)
992 {
993         /* is there a valid remapping table to use? */
994         //if (remap) {
995                 /* find a matching entry... to use to remap */
996                 // ...TODO...
997         //}
998         
999         /* nothing suitable found, so just set dst to look at path (i.e. no alloc/free needed) */
1000         *dst= path;
1001         return 0;
1002 }
1003
1004
1005 /* Write the given value to a setting using RNA, and return success */
1006 static short animsys_write_rna_setting (PointerRNA *ptr, char *path, int array_index, float value)
1007 {
1008         PropertyRNA *prop;
1009         PointerRNA new_ptr;
1010         
1011         //printf("%p %s %i %f\n", ptr, path, array_index, value);
1012         
1013         /* get property to write to */
1014         if (RNA_path_resolve(ptr, path, &new_ptr, &prop)) 
1015         {
1016                 /* set value - only for animatable numerical values */
1017                 if (RNA_property_animateable(&new_ptr, prop)) 
1018                 {
1019                         int array_len= RNA_property_array_length(&new_ptr, prop);
1020                         
1021                         if(array_len && array_index >= array_len)
1022                         {
1023                                 if (G.f & G_DEBUG) {
1024                                         printf("Animato: Invalid array index. ID = '%s',  '%s[%d]', array length is %d \n",
1025                                                 (ptr && ptr->id.data) ? (((ID *)ptr->id.data)->name+2) : "<No ID>",
1026                                                 path, array_index, array_len-1);
1027                                 }
1028                                 
1029                                 return 0;
1030                         }
1031                         
1032                         switch (RNA_property_type(prop)) 
1033                         {
1034                                 case PROP_BOOLEAN:
1035                                         if (array_len)
1036                                                 RNA_property_boolean_set_index(&new_ptr, prop, array_index, (int)value);
1037                                         else
1038                                                 RNA_property_boolean_set(&new_ptr, prop, (int)value);
1039                                         break;
1040                                 case PROP_INT:
1041                                         if (array_len)
1042                                                 RNA_property_int_set_index(&new_ptr, prop, array_index, (int)value);
1043                                         else
1044                                                 RNA_property_int_set(&new_ptr, prop, (int)value);
1045                                         break;
1046                                 case PROP_FLOAT:
1047                                         if (array_len)
1048                                                 RNA_property_float_set_index(&new_ptr, prop, array_index, value);
1049                                         else
1050                                                 RNA_property_float_set(&new_ptr, prop, value);
1051                                         break;
1052                                 case PROP_ENUM:
1053                                         RNA_property_enum_set(&new_ptr, prop, (int)value);
1054                                         break;
1055                                 default:
1056                                         /* nothing can be done here... so it is unsuccessful? */
1057                                         return 0;
1058                         }
1059                 }
1060                 
1061                 /* successful */
1062                 return 1;
1063         }
1064         else {
1065                 /* failed to get path */
1066                 // XXX don't tag as failed yet though, as there are some legit situations (Action Constraint) 
1067                 // where some channels will not exist, but shouldn't lock up Action
1068                 if (G.f & G_DEBUG) {
1069                         printf("Animato: Invalid path. ID = '%s',  '%s[%d]' \n",
1070                                 (ptr && ptr->id.data) ? (((ID *)ptr->id.data)->name+2) : "<No ID>", 
1071                                 path, array_index);
1072                 }
1073                 return 0;
1074         }
1075 }
1076
1077 /* Simple replacement based data-setting of the FCurve using RNA */
1078 static short animsys_execute_fcurve (PointerRNA *ptr, AnimMapper *remap, FCurve *fcu)
1079 {
1080         char *path = NULL;
1081         short free_path=0;
1082         short ok= 0;
1083         
1084         /* get path, remapped as appropriate to work in its new environment */
1085         free_path= animsys_remap_path(remap, fcu->rna_path, &path);
1086         
1087         /* write value to setting */
1088         if (path)
1089                 ok= animsys_write_rna_setting(ptr, path, fcu->array_index, fcu->curval);
1090         
1091         /* free temp path-info */
1092         if (free_path)
1093                 MEM_freeN(path);
1094                 
1095         /* return whether we were successful */
1096         return ok;
1097 }
1098
1099 /* Evaluate all the F-Curves in the given list 
1100  * This performs a set of standard checks. If extra checks are required, separate code should be used
1101  */
1102 static void animsys_evaluate_fcurves (PointerRNA *ptr, ListBase *list, AnimMapper *remap, float ctime)
1103 {
1104         FCurve *fcu;
1105         
1106         /* calculate then execute each curve */
1107         for (fcu= list->first; fcu; fcu= fcu->next) 
1108         {
1109                 /* check if this F-Curve doesn't belong to a muted group */
1110                 if ((fcu->grp == NULL) || (fcu->grp->flag & AGRP_MUTED)==0) {
1111                         /* check if this curve should be skipped */
1112                         if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
1113                         {
1114                                 calculate_fcurve(fcu, ctime);
1115                                 animsys_execute_fcurve(ptr, remap, fcu); 
1116                         }
1117                 }
1118         }
1119 }
1120
1121 /* ***************************************** */
1122 /* Driver Evaluation */
1123
1124 /* Evaluate Drivers */
1125 static void animsys_evaluate_drivers (PointerRNA *ptr, AnimData *adt, float ctime)
1126 {
1127         FCurve *fcu;
1128         
1129         /* drivers are stored as F-Curves, but we cannot use the standard code, as we need to check if
1130          * the depsgraph requested that this driver be evaluated...
1131          */
1132         for (fcu= adt->drivers.first; fcu; fcu= fcu->next) 
1133         {
1134                 ChannelDriver *driver= fcu->driver;
1135                 short ok= 0;
1136                 
1137                 /* check if this driver's curve should be skipped */
1138                 if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
1139                 {
1140                         /* check if driver itself is tagged for recalculation */
1141                         if ((driver) && !(driver->flag & DRIVER_FLAG_INVALID)/*&& (driver->flag & DRIVER_FLAG_RECALC)*/) {      // XXX driver recalc flag is not set yet by depsgraph!
1142                                 /* evaluate this using values set already in other places */
1143                                 // NOTE: for 'layering' option later on, we should check if we should remove old value before adding new to only be done when drivers only changed
1144                                 calculate_fcurve(fcu, ctime);
1145                                 ok= animsys_execute_fcurve(ptr, NULL, fcu);
1146                                 
1147                                 /* clear recalc flag */
1148                                 driver->flag &= ~DRIVER_FLAG_RECALC;
1149                                 
1150                                 /* set error-flag if evaluation failed */
1151                                 if (ok == 0)
1152                                         driver->flag |= DRIVER_FLAG_INVALID; 
1153                         }
1154                 }
1155         }
1156 }
1157
1158 /* ***************************************** */
1159 /* Actions Evaluation */
1160
1161 /* Evaluate Action Group */
1162 void animsys_evaluate_action_group (PointerRNA *ptr, bAction *act, bActionGroup *agrp, AnimMapper *remap, float ctime)
1163 {
1164         FCurve *fcu;
1165         
1166         /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
1167         if ELEM(NULL, act, agrp) return;
1168         if ((remap) && (remap->target != act)) remap= NULL;
1169         
1170         /* if group is muted, don't evaluated any of the F-Curve */
1171         if (agrp->flag & AGRP_MUTED)
1172                 return;
1173         
1174         /* calculate then execute each curve */
1175         for (fcu= agrp->channels.first; (fcu) && (fcu->grp == agrp); fcu= fcu->next) 
1176         {
1177                 /* check if this curve should be skipped */
1178                 if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
1179                 {
1180                         calculate_fcurve(fcu, ctime);
1181                         animsys_execute_fcurve(ptr, remap, fcu); 
1182                 }
1183         }
1184 }
1185
1186 /* Evaluate Action (F-Curve Bag) */
1187 void animsys_evaluate_action (PointerRNA *ptr, bAction *act, AnimMapper *remap, float ctime)
1188 {
1189         /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
1190         if (act == NULL) return;
1191         if ((remap) && (remap->target != act)) remap= NULL;
1192         
1193         /* calculate then execute each curve */
1194         animsys_evaluate_fcurves(ptr, &act->curves, remap, ctime);
1195 }
1196
1197 /* ***************************************** */
1198 /* NLA System - Evaluation */
1199
1200 /* calculate influence of strip based for given frame based on blendin/out values */
1201 static float nlastrip_get_influence (NlaStrip *strip, float cframe)
1202 {
1203         /* sanity checks - normalise the blendin/out values? */
1204         strip->blendin= (float)fabs(strip->blendin);
1205         strip->blendout= (float)fabs(strip->blendout);
1206         
1207         /* result depends on where frame is in respect to blendin/out values */
1208         if (IS_EQ(strip->blendin, 0)==0 && (cframe <= (strip->start + strip->blendin))) {
1209                 /* there is some blend-in */
1210                 return (float)fabs(cframe - strip->start) / (strip->blendin);
1211         }
1212         else if (IS_EQ(strip->blendout, 0)==0 && (cframe >= (strip->end - strip->blendout))) {
1213                 /* there is some blend-out */
1214                 return (float)fabs(strip->end - cframe) / (strip->blendout);
1215         }
1216         else {
1217                 /* in the middle of the strip, we should be full strength */
1218                 return 1.0f;
1219         }
1220 }
1221
1222 /* evaluate the evaluation time and influence for the strip, storing the results in the strip */
1223 static void nlastrip_evaluate_controls (NlaStrip *strip, float ctime)
1224 {
1225         /* firstly, analytically generate values for influence and time (if applicable) */
1226         if ((strip->flag & NLASTRIP_FLAG_USR_TIME) == 0)
1227                 strip->strip_time= nlastrip_get_frame(strip, ctime, NLATIME_CONVERT_EVAL);
1228         if ((strip->flag & NLASTRIP_FLAG_USR_INFLUENCE) == 0)
1229                 strip->influence= nlastrip_get_influence(strip, ctime);
1230         
1231         /* now strip's evaluate F-Curves for these settings (if applicable) */
1232         if (strip->fcurves.first) {
1233                 PointerRNA strip_ptr;
1234                 
1235                 /* create RNA-pointer needed to set values */
1236                 RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &strip_ptr);
1237                 
1238                 /* execute these settings as per normal */
1239                 animsys_evaluate_fcurves(&strip_ptr, &strip->fcurves, NULL, ctime);
1240         }
1241
1242         /* if user can control the evaluation time (using F-Curves), consider the option which allows this time to be clamped 
1243          * to lie within extents of the action-clip, so that a steady changing rate of progress through several cycles of the clip
1244          * can be achieved easily
1245          */
1246         // NOTE: if we add any more of these special cases, we better group them up nicely...
1247         if ((strip->flag & NLASTRIP_FLAG_USR_TIME) && (strip->flag & NLASTRIP_FLAG_USR_TIME_CYCLIC))
1248                 strip->strip_time= fmod(strip->strip_time - strip->actstart, strip->actend - strip->actstart);
1249 }
1250
1251 /* gets the strip active at the current time for a list of strips for evaluation purposes */
1252 NlaEvalStrip *nlastrips_ctime_get_strip (ListBase *list, ListBase *strips, short index, float ctime)
1253 {
1254         NlaStrip *strip, *estrip=NULL;
1255         NlaEvalStrip *nes;
1256         short side= 0;
1257         
1258         /* loop over strips, checking if they fall within the range */
1259         for (strip= strips->first; strip; strip= strip->next) {
1260                 /* check if current time occurs within this strip  */
1261                 if (IN_RANGE_INCL(ctime, strip->start, strip->end)) {
1262                         /* this strip is active, so try to use it */
1263                         estrip= strip;
1264                         side= NES_TIME_WITHIN;
1265                         break;
1266                 }
1267                 
1268                 /* if time occurred before current strip... */
1269                 if (ctime < strip->start) {
1270                         if (strip == strips->first) {
1271                                 /* before first strip - only try to use it if it extends backwards in time too */
1272                                 if (strip->extendmode == NLASTRIP_EXTEND_HOLD)
1273                                         estrip= strip;
1274                                         
1275                                 /* side is 'before' regardless of whether there's a useful strip */
1276                                 side= NES_TIME_BEFORE;
1277                         }
1278                         else {
1279                                 /* before next strip - previous strip has ended, but next hasn't begun, 
1280                                  * so blending mode depends on whether strip is being held or not...
1281                                  *      - only occurs when no transition strip added, otherwise the transition would have
1282                                  *        been picked up above...
1283                                  */
1284                                 strip= strip->prev;
1285                                 
1286                                 if (strip->extendmode != NLASTRIP_EXTEND_NOTHING)
1287                                         estrip= strip;
1288                                 side= NES_TIME_AFTER;
1289                         }
1290                         break;
1291                 }
1292                 
1293                 /* if time occurred after current strip... */
1294                 if (ctime > strip->end) {
1295                         /* only if this is the last strip should we do anything, and only if that is being held */
1296                         if (strip == strips->last) {
1297                                 if (strip->extendmode != NLASTRIP_EXTEND_NOTHING)
1298                                         estrip= strip;
1299                                         
1300                                 side= NES_TIME_AFTER;
1301                                 break;
1302                         }
1303                         
1304                         /* otherwise, skip... as the 'before' case will catch it more elegantly! */
1305                 }
1306         }
1307         
1308         /* check if a valid strip was found
1309          *      - must not be muted (i.e. will have contribution
1310          */
1311         if ((estrip == NULL) || (estrip->flag & NLASTRIP_FLAG_MUTED)) 
1312                 return NULL;
1313                 
1314         /* if ctime was not within the boundaries of the strip, clamp! */
1315         switch (side) {
1316                 case NES_TIME_BEFORE: /* extend first frame only */
1317                         ctime= estrip->start;
1318                         break;
1319                 case NES_TIME_AFTER: /* extend last frame only */
1320                         ctime= estrip->end;
1321                         break;
1322         }
1323         
1324         /* evaluate strip's evaluation controls  
1325          *      - skip if no influence (i.e. same effect as muting the strip)
1326          *      - negative influence is not supported yet... how would that be defined?
1327          */
1328         // TODO: this sounds a bit hacky having a few isolated F-Curves stuck on some data it operates on...
1329         nlastrip_evaluate_controls(estrip, ctime);
1330         if (estrip->influence <= 0.0f)
1331                 return NULL;
1332                 
1333         /* check if strip has valid data to evaluate,
1334          * and/or perform any additional type-specific actions
1335          */
1336         switch (estrip->type) {
1337                 case NLASTRIP_TYPE_CLIP: 
1338                         /* clip must have some action to evaluate */
1339                         if (estrip->act == NULL)
1340                                 return NULL;
1341                         break;
1342                 case NLASTRIP_TYPE_TRANSITION:
1343                         /* there must be strips to transition from and to (i.e. prev and next required) */
1344                         if (ELEM(NULL, estrip->prev, estrip->next))
1345                                 return NULL;
1346                                 
1347                         /* evaluate controls for the relevant extents of the bordering strips... */
1348                         nlastrip_evaluate_controls(estrip->prev, estrip->start);
1349                         nlastrip_evaluate_controls(estrip->next, estrip->end);
1350                         break;
1351         }
1352         
1353         /* add to list of strips we need to evaluate */
1354         nes= MEM_callocN(sizeof(NlaEvalStrip), "NlaEvalStrip");
1355         
1356         nes->strip= estrip;
1357         nes->strip_mode= side;
1358         nes->track_index= index;
1359         nes->strip_time= estrip->strip_time;
1360         
1361         if (list)
1362                 BLI_addtail(list, nes);
1363         
1364         return nes;
1365 }
1366
1367 /* ---------------------- */
1368
1369 /* find an NlaEvalChannel that matches the given criteria 
1370  *      - ptr and prop are the RNA data to find a match for
1371  */
1372 static NlaEvalChannel *nlaevalchan_find_match (ListBase *channels, PointerRNA *ptr, PropertyRNA *prop, int array_index)
1373 {
1374         NlaEvalChannel *nec;
1375         
1376         /* sanity check */
1377         if (channels == NULL)
1378                 return NULL;
1379         
1380         /* loop through existing channels, checking for a channel which affects the same property */
1381         for (nec= channels->first; nec; nec= nec->next) {
1382                 /* - comparing the PointerRNA's is done by comparing the pointers
1383                  *   to the actual struct the property resides in, since that all the
1384                  *   other data stored in PointerRNA cannot allow us to definitively 
1385                  *      identify the data 
1386                  */
1387                 if ((nec->ptr.data == ptr->data) && (nec->prop == prop) && (nec->index == array_index))
1388                         return nec;
1389         }
1390         
1391         /* not found */
1392         return NULL;
1393 }
1394
1395 /* verify that an appropriate NlaEvalChannel for this F-Curve exists */
1396 static NlaEvalChannel *nlaevalchan_verify (PointerRNA *ptr, ListBase *channels, NlaEvalStrip *nes, FCurve *fcu, short *newChan)
1397 {
1398         NlaEvalChannel *nec;
1399         NlaStrip *strip= nes->strip;
1400         PropertyRNA *prop;
1401         PointerRNA new_ptr;
1402         char *path = NULL;
1403         short free_path=0;
1404         
1405         /* sanity checks */
1406         if (channels == NULL)
1407                 return NULL;
1408         
1409         /* get RNA pointer+property info from F-Curve for more convenient handling */
1410                 /* get path, remapped as appropriate to work in its new environment */
1411         free_path= animsys_remap_path(strip->remap, fcu->rna_path, &path);
1412         
1413                 /* a valid property must be available, and it must be animateable */
1414         if (RNA_path_resolve(ptr, path, &new_ptr, &prop) == 0) {
1415                 if (G.f & G_DEBUG) printf("NLA Strip Eval: Cannot resolve path \n");
1416                 return NULL;
1417         }
1418                 /* only ok if animateable */
1419         else if (RNA_property_animateable(&new_ptr, prop) == 0) {
1420                 if (G.f & G_DEBUG) printf("NLA Strip Eval: Property not animateable \n");
1421                 return NULL;
1422         }
1423         
1424         /* try to find a match */
1425         nec= nlaevalchan_find_match(channels, &new_ptr, prop, fcu->array_index);
1426         
1427         /* allocate a new struct for this if none found */
1428         if (nec == NULL) {
1429                 nec= MEM_callocN(sizeof(NlaEvalChannel), "NlaEvalChannel");
1430                 *newChan= 1;
1431                 BLI_addtail(channels, nec);
1432                 
1433                 nec->ptr= new_ptr; 
1434                 nec->prop= prop;
1435                 nec->index= fcu->array_index;
1436         }
1437         else
1438                 *newChan= 0;
1439         
1440         /* we can now return */
1441         return nec;
1442 }
1443
1444 /* accumulate (i.e. blend) the given value on to the channel it affects */
1445 static void nlaevalchan_accumulate (NlaEvalChannel *nec, NlaEvalStrip *nes, short newChan, float value)
1446 {
1447         NlaStrip *strip= nes->strip;
1448         short blendmode= strip->blendmode;
1449         float inf= strip->influence;
1450         
1451         /* if channel is new, just store value regardless of blending factors, etc. */
1452         if (newChan) {
1453                 nec->value= value;
1454                 return;
1455         }
1456                 
1457         /* if this is being performed as part of transition evaluation, incorporate
1458          * an additional weighting factor for the influence
1459          */
1460         if (nes->strip_mode == NES_TIME_TRANSITION_END) 
1461                 inf *= nes->strip_time;
1462         
1463         /* premultiply the value by the weighting factor */
1464         if (IS_EQ(inf, 0)) return;
1465         value *= inf;
1466         
1467         /* perform blending */
1468         switch (blendmode) {
1469                 case NLASTRIP_MODE_ADD:
1470                         /* simply add the scaled value on to the stack */
1471                         nec->value += value;
1472                         break;
1473                         
1474                 case NLASTRIP_MODE_SUBTRACT:
1475                         /* simply subtract the scaled value from the stack */
1476                         nec->value -= value;
1477                         break;
1478                         
1479                 case NLASTRIP_MODE_MULTIPLY:
1480                         /* multiply the scaled value with the stack */
1481                         nec->value *= value;
1482                         break;
1483                 
1484                 case NLASTRIP_MODE_REPLACE:
1485                 default: // TODO: do we really want to blend by default? it seems more uses might prefer add...
1486                         /* do linear interpolation 
1487                          *      - the influence of the accumulated data (elsewhere, that is called dstweight) 
1488                          *        is 1 - influence, since the strip's influence is srcweight
1489                          */
1490                         nec->value= nec->value * (1.0f - inf)   +   value;
1491                         break;
1492         }
1493 }
1494
1495 /* accumulate the results of a temporary buffer with the results of the full-buffer */
1496 static void nlaevalchan_buffers_accumulate (ListBase *channels, ListBase *tmp_buffer, NlaEvalStrip *nes)
1497 {
1498         NlaEvalChannel *nec, *necn, *necd;
1499         
1500         /* optimise - abort if no channels */
1501         if (tmp_buffer->first == NULL)
1502                 return;
1503         
1504         /* accumulate results in tmp_channels buffer to the accumulation buffer */
1505         for (nec= tmp_buffer->first; nec; nec= necn) {
1506                 /* get pointer to next channel in case we remove the current channel from the temp-buffer */
1507                 necn= nec->next;
1508                 
1509                 /* try to find an existing matching channel for this setting in the accumulation buffer */
1510                 necd= nlaevalchan_find_match(channels, &nec->ptr, nec->prop, nec->index);
1511                 
1512                 /* if there was a matching channel already in the buffer, accumulate to it,
1513                  * otherwise, add the current channel to the buffer for efficiency
1514                  */
1515                 if (necd)
1516                         nlaevalchan_accumulate(necd, nes, 0, nec->value);
1517                 else {
1518                         BLI_remlink(tmp_buffer, nec);
1519                         BLI_addtail(channels, nec);
1520                 }
1521         }
1522         
1523         /* free temp-channels that haven't been assimilated into the buffer */
1524         BLI_freelistN(tmp_buffer);
1525 }
1526
1527 /* ---------------------- */
1528 /* F-Modifier stack joining/separation utilities - should we generalise these for BLI_listbase.h interface? */
1529
1530 /* Temporarily join two lists of modifiers together, storing the result in a third list */
1531 static void nlaeval_fmodifiers_join_stacks (ListBase *result, ListBase *list1, ListBase *list2)
1532 {
1533         FModifier *fcm1, *fcm2;
1534         
1535         /* if list1 is invalid...  */
1536         if ELEM(NULL, list1, list1->first) {
1537                 if (list2 && list2->first) {
1538                         result->first= list2->first;
1539                         result->last= list2->last;
1540                 }
1541         }
1542         /* if list 2 is invalid... */
1543         else if ELEM(NULL, list2, list2->first) {
1544                 result->first= list1->first;
1545                 result->last= list1->last;
1546         }
1547         else {
1548                 /* list1 should be added first, and list2 second, with the endpoints of these being the endpoints for result 
1549                  *      - the original lists must be left unchanged though, as we need that fact for restoring
1550                  */
1551                 result->first= list1->first;
1552                 result->last= list2->last;
1553                 
1554                 fcm1= list1->last;
1555                 fcm2= list2->first;
1556                 
1557                 fcm1->next= fcm2;
1558                 fcm2->prev= fcm1;
1559         }
1560 }
1561
1562 /* Split two temporary lists of modifiers */
1563 static void nlaeval_fmodifiers_split_stacks (ListBase *list1, ListBase *list2)
1564 {
1565         FModifier *fcm1, *fcm2;
1566         
1567         /* if list1/2 is invalid... just skip */
1568         if ELEM(NULL, list1, list2)
1569                 return;
1570         if ELEM(NULL, list1->first, list2->first)
1571                 return;
1572                 
1573         /* get endpoints */
1574         fcm1= list1->last;
1575         fcm2= list2->first;
1576         
1577         /* clear their links */
1578         fcm1->next= NULL;
1579         fcm2->prev= NULL;
1580 }
1581
1582 /* ---------------------- */
1583
1584 /* evaluate action-clip strip */
1585 static void nlastrip_evaluate_actionclip (PointerRNA *ptr, ListBase *channels, ListBase *modifiers, NlaEvalStrip *nes)
1586 {
1587         ListBase tmp_modifiers = {NULL, NULL};
1588         NlaStrip *strip= nes->strip;
1589         FCurve *fcu;
1590         float evaltime;
1591         
1592         /* join this strip's modifiers to the parent's modifiers (own modifiers first) */
1593         nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &strip->modifiers, modifiers);
1594         
1595         /* evaluate strip's modifiers which modify time to evaluate the base curves at */
1596         evaltime= evaluate_time_fmodifiers(&tmp_modifiers, NULL, 0.0f, strip->strip_time);
1597         
1598         /* evaluate all the F-Curves in the action, saving the relevant pointers to data that will need to be used */
1599         for (fcu= strip->act->curves.first; fcu; fcu= fcu->next) {
1600                 NlaEvalChannel *nec;
1601                 float value = 0.0f;
1602                 short newChan = -1;
1603                 
1604                 /* check if this curve should be skipped */
1605                 if (fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) 
1606                         continue;
1607                 if ((fcu->grp) && (fcu->grp->flag & AGRP_MUTED))
1608                         continue;
1609                         
1610                 /* evaluate the F-Curve's value for the time given in the strip 
1611                  * NOTE: we use the modified time here, since strip's F-Curve Modifiers are applied on top of this 
1612                  */
1613                 value= evaluate_fcurve(fcu, evaltime);
1614                 
1615                 /* apply strip's F-Curve Modifiers on this value 
1616                  * NOTE: we apply the strip's original evaluation time not the modified one (as per standard F-Curve eval)
1617                  */
1618                 evaluate_value_fmodifiers(&tmp_modifiers, fcu, &value, strip->strip_time);
1619                 
1620                 
1621                 /* get an NLA evaluation channel to work with, and accumulate the evaluated value with the value(s)
1622                  * stored in this channel if it has been used already
1623                  */
1624                 nec= nlaevalchan_verify(ptr, channels, nes, fcu, &newChan);
1625                 if (nec)
1626                         nlaevalchan_accumulate(nec, nes, newChan, value);
1627         }
1628         
1629         /* unlink this strip's modifiers from the parent's modifiers again */
1630         nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);
1631 }
1632
1633 /* evaluate transition strip */
1634 static void nlastrip_evaluate_transition (PointerRNA *ptr, ListBase *channels, ListBase *modifiers, NlaEvalStrip *nes)
1635 {
1636         ListBase tmp_channels = {NULL, NULL};
1637         ListBase tmp_modifiers = {NULL, NULL};
1638         NlaEvalStrip tmp_nes;
1639         NlaStrip *s1, *s2;
1640         
1641         /* join this strip's modifiers to the parent's modifiers (own modifiers first) */
1642         nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &nes->strip->modifiers, modifiers);
1643         
1644         /* get the two strips to operate on 
1645          *      - we use the endpoints of the strips directly flanking our strip
1646          *        using these as the endpoints of the transition (destination and source)
1647          *      - these should have already been determined to be valid...
1648          *      - if this strip is being played in reverse, we need to swap these endpoints
1649          *        otherwise they will be interpolated wrong
1650          */
1651         if (nes->strip->flag & NLASTRIP_FLAG_REVERSE) {
1652                 s1= nes->strip->next;
1653                 s2= nes->strip->prev;
1654         }
1655         else {
1656                 s1= nes->strip->prev;
1657                 s2= nes->strip->next;
1658         }
1659         
1660         /* prepare template for 'evaluation strip' 
1661          *      - based on the transition strip's evaluation strip data
1662          *      - strip_mode is NES_TIME_TRANSITION_* based on which endpoint
1663          *      - strip_time is the 'normalised' (i.e. in-strip) time for evaluation,
1664          *        which doubles up as an additional weighting factor for the strip influences
1665          *        which allows us to appear to be 'interpolating' between the two extremes
1666          */
1667         tmp_nes= *nes;
1668         
1669         /* evaluate these strips into a temp-buffer (tmp_channels) */
1670         // FIXME: modifier evalation here needs some work...
1671                 /* first strip */
1672         tmp_nes.strip_mode= NES_TIME_TRANSITION_START;
1673         tmp_nes.strip= s1;
1674         nlastrip_evaluate(ptr, &tmp_channels, &tmp_modifiers, &tmp_nes);
1675         
1676                 /* second strip */
1677         tmp_nes.strip_mode= NES_TIME_TRANSITION_END;
1678         tmp_nes.strip= s2;
1679         nlastrip_evaluate(ptr, &tmp_channels, &tmp_modifiers, &tmp_nes);
1680         
1681         
1682         /* assumulate temp-buffer and full-buffer, using the 'real' strip */
1683         nlaevalchan_buffers_accumulate(channels, &tmp_channels, nes);
1684         
1685         /* unlink this strip's modifiers from the parent's modifiers again */
1686         nlaeval_fmodifiers_split_stacks(&nes->strip->modifiers, modifiers);
1687 }
1688
1689 /* evaluate meta-strip */
1690 static void nlastrip_evaluate_meta (PointerRNA *ptr, ListBase *channels, ListBase *modifiers, NlaEvalStrip *nes)
1691 {
1692         ListBase tmp_channels = {NULL, NULL};
1693         ListBase tmp_modifiers = {NULL, NULL};
1694         NlaStrip *strip= nes->strip;
1695         NlaEvalStrip *tmp_nes;
1696         float evaltime;
1697         
1698         /* meta-strip was calculated normally to have some time to be evaluated at
1699          * and here we 'look inside' the meta strip, treating it as a decorated window to
1700          * it's child strips, which get evaluated as if they were some tracks on a strip 
1701          * (but with some extra modifiers to apply).
1702          *
1703          * NOTE: keep this in sync with animsys_evaluate_nla()
1704          */
1705          
1706         /* join this strip's modifiers to the parent's modifiers (own modifiers first) */
1707         nlaeval_fmodifiers_join_stacks(&tmp_modifiers, &strip->modifiers, modifiers); 
1708         
1709         /* find the child-strip to evaluate */
1710         evaltime= (nes->strip_time * (strip->end - strip->start)) + strip->start;
1711         tmp_nes= nlastrips_ctime_get_strip(NULL, &strip->strips, -1, evaltime);
1712         if (tmp_nes == NULL)
1713                 return;
1714                 
1715         /* evaluate child-strip into tmp_channels buffer before accumulating 
1716          * in the accumulation buffer
1717          */
1718         nlastrip_evaluate(ptr, &tmp_channels, &tmp_modifiers, tmp_nes);
1719         
1720         /* assumulate temp-buffer and full-buffer, using the 'real' strip */
1721         nlaevalchan_buffers_accumulate(channels, &tmp_channels, nes);
1722         
1723         /* free temp eval-strip */
1724         MEM_freeN(tmp_nes);
1725         
1726         /* unlink this strip's modifiers from the parent's modifiers again */
1727         nlaeval_fmodifiers_split_stacks(&strip->modifiers, modifiers);
1728 }
1729
1730 /* evaluates the given evaluation strip */
1731 void nlastrip_evaluate (PointerRNA *ptr, ListBase *channels, ListBase *modifiers, NlaEvalStrip *nes)
1732 {
1733         NlaStrip *strip= nes->strip;
1734         
1735         /* to prevent potential infinite recursion problems (i.e. transition strip, beside meta strip containing a transition
1736          * several levels deep inside it), we tag the current strip as being evaluated, and clear this when we leave
1737          */
1738         // TODO: be careful with this flag, since some edit tools may be running and have set this while animplayback was running
1739         if (strip->flag & NLASTRIP_FLAG_EDIT_TOUCHED)
1740                 return;
1741         strip->flag |= NLASTRIP_FLAG_EDIT_TOUCHED;
1742         
1743         /* actions to take depend on the type of strip */
1744         switch (strip->type) {
1745                 case NLASTRIP_TYPE_CLIP: /* action-clip */
1746                         nlastrip_evaluate_actionclip(ptr, channels, modifiers, nes);
1747                         break;
1748                 case NLASTRIP_TYPE_TRANSITION: /* transition */
1749                         nlastrip_evaluate_transition(ptr, channels, modifiers, nes);
1750                         break;
1751                 case NLASTRIP_TYPE_META: /* meta */
1752                         nlastrip_evaluate_meta(ptr, channels, modifiers, nes);
1753                         break;
1754         }
1755         
1756         /* clear temp recursion safe-check */
1757         strip->flag &= ~NLASTRIP_FLAG_EDIT_TOUCHED;
1758 }
1759
1760 /* write the accumulated settings to */
1761 void nladata_flush_channels (ListBase *channels)
1762 {
1763         NlaEvalChannel *nec;
1764         
1765         /* sanity checks */
1766         if (channels == NULL)
1767                 return;
1768         
1769         /* for each channel with accumulated values, write its value on the property it affects */
1770         for (nec= channels->first; nec; nec= nec->next) {
1771                 PointerRNA *ptr= &nec->ptr;
1772                 PropertyRNA *prop= nec->prop;
1773                 int array_index= nec->index;
1774                 float value= nec->value;
1775                 
1776                 /* write values - see animsys_write_rna_setting() to sync the code */
1777                 switch (RNA_property_type(prop)) 
1778                 {
1779                         case PROP_BOOLEAN:
1780                                 if (RNA_property_array_length(ptr, prop))
1781                                         RNA_property_boolean_set_index(ptr, prop, array_index, (int)value);
1782                                 else
1783                                         RNA_property_boolean_set(ptr, prop, (int)value);
1784                                 break;
1785                         case PROP_INT:
1786                                 if (RNA_property_array_length(ptr, prop))
1787                                         RNA_property_int_set_index(ptr, prop, array_index, (int)value);
1788                                 else
1789                                         RNA_property_int_set(ptr, prop, (int)value);
1790                                 break;
1791                         case PROP_FLOAT:
1792                                 if (RNA_property_array_length(ptr, prop))
1793                                         RNA_property_float_set_index(ptr, prop, array_index, value);
1794                                 else
1795                                         RNA_property_float_set(ptr, prop, value);
1796                                 break;
1797                         case PROP_ENUM:
1798                                 RNA_property_enum_set(ptr, prop, (int)value);
1799                                 break;
1800                         default:
1801                                 // can't do anything with other types of property....
1802                                 break;
1803                 }
1804         }
1805 }
1806
1807 /* ---------------------- */
1808
1809 /* NLA Evaluation function (mostly for use through do_animdata) 
1810  *      - All channels that will be affected are not cleared anymore. Instead, we just evaluate into 
1811  *              some temp channels, where values can be accumulated in one go.
1812  */
1813 static void animsys_evaluate_nla (PointerRNA *ptr, AnimData *adt, float ctime)
1814 {
1815         NlaTrack *nlt;
1816         short track_index=0;
1817         short has_strips = 0;
1818         
1819         ListBase estrips= {NULL, NULL};
1820         ListBase echannels= {NULL, NULL};
1821         NlaEvalStrip *nes;
1822         
1823         // TODO: need to zero out all channels used, otherwise we have problems with threadsafety
1824         // and also when the user jumps between different times instead of moving sequentially...
1825         
1826         /* 1. get the stack of strips to evaluate at current time (influence calculated here) */
1827         for (nlt=adt->nla_tracks.first; nlt; nlt=nlt->next, track_index++) { 
1828                 /* stop here if tweaking is on and this strip is the tweaking track (it will be the first one that's 'disabled')... */
1829                 if ((adt->flag & ADT_NLA_EDIT_ON) && (nlt->flag & NLATRACK_DISABLED))
1830                         break;
1831                         
1832                 /* skip if we're only considering a track tagged 'solo' */
1833                 if ((adt->flag & ADT_NLA_SOLO_TRACK) && (nlt->flag & NLATRACK_SOLO)==0)
1834                         continue;
1835                 /* skip if track is muted */
1836                 if (nlt->flag & NLATRACK_MUTED) 
1837                         continue;
1838                         
1839                 /* if this track has strips (but maybe they won't be suitable), set has_strips 
1840                  *      - used for mainly for still allowing normal action evaluation...
1841                  */
1842                 if (nlt->strips.first)
1843                         has_strips= 1;
1844                         
1845                 /* otherwise, get strip to evaluate for this channel */
1846                 nes= nlastrips_ctime_get_strip(&estrips, &nlt->strips, track_index, ctime);
1847                 if (nes) nes->track= nlt;
1848         }
1849         
1850         /* add 'active' Action (may be tweaking track) as last strip to evaluate in NLA stack
1851          *      - only do this if we're not exclusively evaluating the 'solo' NLA-track
1852          */
1853         if ((adt->action) && !(adt->flag & ADT_NLA_SOLO_TRACK)) {
1854                 /* if there are strips, evaluate action as per NLA rules */
1855                 if ((has_strips) || (adt->actstrip)) {
1856                         /* make dummy NLA strip, and add that to the stack */
1857                         NlaStrip dummy_strip= {0};
1858                         ListBase dummy_trackslist;
1859                         
1860                         dummy_trackslist.first= dummy_trackslist.last= &dummy_strip;
1861                         
1862                         if ((nlt) && !(adt->flag & ADT_NLA_EDIT_NOMAP)) {
1863                                 /* edit active action in-place according to its active strip, so copy the data  */
1864                                 memcpy(&dummy_strip, adt->actstrip, sizeof(NlaStrip));
1865                                 dummy_strip.next = dummy_strip.prev = NULL;
1866                         }
1867                         else {
1868                                 /* set settings of dummy NLA strip from AnimData settings */
1869                                 dummy_strip.act= adt->action;
1870                                 dummy_strip.remap= adt->remap;
1871                                 
1872                                 /* action range is calculated taking F-Modifiers into account (which making new strips doesn't do due to the troublesome nature of that) */
1873                                 calc_action_range(dummy_strip.act, &dummy_strip.actstart, &dummy_strip.actend, 1);
1874                                 dummy_strip.start = dummy_strip.actstart;
1875                                 dummy_strip.end = (IS_EQ(dummy_strip.actstart, dummy_strip.actend)) ?  (dummy_strip.actstart + 1.0f): (dummy_strip.actend);
1876                                 
1877                                 dummy_strip.blendmode= adt->act_blendmode;
1878                                 dummy_strip.extendmode= adt->act_extendmode;
1879                                 dummy_strip.influence= adt->act_influence;
1880                         }
1881                         
1882                         /* add this to our list of evaluation strips */
1883                         nlastrips_ctime_get_strip(&estrips, &dummy_trackslist, -1, ctime);
1884                 }
1885                 else {
1886                         /* special case - evaluate as if there isn't any NLA data */
1887                         // TODO: this is really just a stop-gap measure...
1888                         animsys_evaluate_action(ptr, adt->action, adt->remap, ctime);
1889                         return;
1890                 }
1891         }
1892         
1893         /* only continue if there are strips to evaluate */
1894         if (estrips.first == NULL)
1895                 return;
1896         
1897         
1898         /* 2. for each strip, evaluate then accumulate on top of existing channels, but don't set values yet */
1899         for (nes= estrips.first; nes; nes= nes->next) 
1900                 nlastrip_evaluate(ptr, &echannels, NULL, nes);
1901         
1902         /* 3. flush effects of accumulating channels in NLA to the actual data they affect */
1903         nladata_flush_channels(&echannels);
1904         
1905         /* 4. free temporary evaluation data */
1906         BLI_freelistN(&estrips);
1907         BLI_freelistN(&echannels);
1908 }
1909
1910 /* ***************************************** */ 
1911 /* Overrides System - Public API */
1912
1913 /* Clear all overides */
1914
1915 /* Add or get existing Override for given setting */
1916 AnimOverride *BKE_animsys_validate_override (PointerRNA *UNUSED(ptr), char *UNUSED(path), int UNUSED(array_index))
1917 {
1918         // FIXME: need to define how to get overrides
1919         return NULL;
1920
1921
1922 /* -------------------- */
1923
1924 /* Evaluate Overrides */
1925 static void animsys_evaluate_overrides (PointerRNA *ptr, AnimData *adt)
1926 {
1927         AnimOverride *aor;
1928         
1929         /* for each override, simply execute... */
1930         for (aor= adt->overrides.first; aor; aor= aor->next)
1931                 animsys_write_rna_setting(ptr, aor->rna_path, aor->array_index, aor->value);
1932 }
1933
1934 /* ***************************************** */
1935 /* Evaluation System - Public API */
1936
1937 /* Overview of how this system works:
1938  *      1) Depsgraph sorts data as necessary, so that data is in an order that means 
1939  *              that all dependences are resolved before dependants.
1940  *      2) All normal animation is evaluated, so that drivers have some basis values to
1941  *              work with
1942  *              a.      NLA stacks are done first, as the Active Actions act as 'tweaking' tracks
1943  *                      which modify the effects of the NLA-stacks
1944  *              b.      Active Action is evaluated as per normal, on top of the results of the NLA tracks
1945  *
1946  * --------------< often in a separate phase... >------------------ 
1947  *
1948  *      3) Drivers/expressions are evaluated on top of this, in an order where dependences are
1949  *              resolved nicely. 
1950  *         Note: it may be necessary to have some tools to handle the cases where some higher-level
1951  *              drivers are added and cause some problematic dependencies that didn't exist in the local levels...
1952  *
1953  * --------------< always executed >------------------ 
1954  *
1955  * Maintainance of editability of settings (XXX):
1956  *      In order to ensure that settings that are animated can still be manipulated in the UI without requiring
1957  *      that keyframes are added to prevent these values from being overwritten, we use 'overrides'. 
1958  *
1959  * Unresolved things:
1960  *      - Handling of multi-user settings (i.e. time-offset, group-instancing) -> big cache grids or nodal system? but stored where?
1961  *      - Multiple-block dependencies (i.e. drivers for settings are in both local and higher levels) -> split into separate lists? 
1962  *
1963  * Current Status:
1964  *      - Currently (as of September 2009), overrides we haven't needed to (fully) implement overrides. 
1965  *        However, the code fo this is relatively harmless, so is left in the code for now.
1966  */
1967
1968 /* Evaluation loop for evaluation animation data 
1969  *
1970  * This assumes that the animation-data provided belongs to the ID block in question,
1971  * and that the flags for which parts of the anim-data settings need to be recalculated 
1972  * have been set already by the depsgraph. Now, we use the recalc 
1973  */
1974 void BKE_animsys_evaluate_animdata (ID *id, AnimData *adt, float ctime, short recalc)
1975 {
1976         PointerRNA id_ptr;
1977         
1978         /* sanity checks */
1979         if ELEM(NULL, id, adt)
1980                 return;
1981         
1982         /* get pointer to ID-block for RNA to use */
1983         RNA_id_pointer_create(id, &id_ptr);
1984         
1985         /* recalculate keyframe data:
1986          *      - NLA before Active Action, as Active Action behaves as 'tweaking track'
1987          *        that overrides 'rough' work in NLA
1988          */
1989         // TODO: need to double check that this all works correctly
1990         if ((recalc & ADT_RECALC_ANIM) || (adt->recalc & ADT_RECALC_ANIM))
1991         {
1992                 /* evaluate NLA data */
1993                 if ((adt->nla_tracks.first) && !(adt->flag & ADT_NLA_EVAL_OFF))
1994                 {
1995                         /* evaluate NLA-stack 
1996                          *      - active action is evaluated as part of the NLA stack as the last item
1997                          */
1998                         animsys_evaluate_nla(&id_ptr, adt, ctime);
1999                 }
2000                 /* evaluate Active Action only */
2001                 else if (adt->action)
2002                         animsys_evaluate_action(&id_ptr, adt->action, adt->remap, ctime);
2003                 
2004                 /* reset tag */
2005                 adt->recalc &= ~ADT_RECALC_ANIM;
2006         }
2007         
2008         /* recalculate drivers 
2009          *      - Drivers need to be evaluated afterwards, as they can either override 
2010          *        or be layered on top of existing animation data.
2011          *      - Drivers should be in the appropriate order to be evaluated without problems...
2012          */
2013         if ((recalc & ADT_RECALC_DRIVERS) /*&& (adt->recalc & ADT_RECALC_DRIVERS)*/) // XXX for now, don't check yet, as depsgraph hasn't been updated
2014         {
2015                 animsys_evaluate_drivers(&id_ptr, adt, ctime);
2016         }
2017         
2018         /* always execute 'overrides' 
2019          *      - Overrides allow editing, by overwriting the value(s) set from animation-data, with the
2020          *        value last set by the user (and not keyframed yet). 
2021          *      - Overrides are cleared upon frame change and/or keyframing
2022          *      - It is best that we execute this everytime, so that no errors are likely to occur.
2023          */
2024         animsys_evaluate_overrides(&id_ptr, adt);
2025         
2026         /* clear recalc flag now */
2027         adt->recalc= 0;
2028 }
2029
2030 /* Evaluation of all ID-blocks with Animation Data blocks - Animation Data Only
2031  *
2032  * This will evaluate only the animation info available in the animation data-blocks
2033  * encountered. In order to enforce the system by which some settings controlled by a
2034  * 'local' (i.e. belonging in the nearest ID-block that setting is related to, not a
2035  * standard 'root') block are overridden by a larger 'user'
2036  */
2037 void BKE_animsys_evaluate_all_animation (Main *main, float ctime)
2038 {
2039         ID *id;
2040         
2041         if (G.f & G_DEBUG)
2042                 printf("Evaluate all animation - %f \n", ctime);
2043         
2044         /* macros for less typing 
2045          *      - only evaluate animation data for id if it has users (and not just fake ones)
2046          *      - whether animdata exists is checked for by the evaluation function, though taking 
2047          *        this outside of the function may make things slightly faster?
2048          */
2049 #define EVAL_ANIM_IDS(first, aflag) \
2050         for (id= first; id; id= id->next) { \
2051                 if (ID_REAL_USERS(id) > 0) { \
2052                         AnimData *adt= BKE_animdata_from_id(id); \
2053                         BKE_animsys_evaluate_animdata(id, adt, ctime, aflag); \
2054                 } \
2055         }
2056         /* another macro for the "embedded" nodetree cases 
2057          *      - this is like EVAL_ANIM_IDS, but this handles the case "embedded nodetrees" 
2058          *        (i.e. scene/material/texture->nodetree) which we need a special exception
2059          *        for, otherwise they'd get skipped
2060          *      - ntp = "node tree parent" = datablock where node tree stuff resides
2061          */
2062 #define EVAL_ANIM_NODETREE_IDS(first, NtId_Type, aflag) \
2063         for (id= first; id; id= id->next) { \
2064                 if (ID_REAL_USERS(id) > 0) { \
2065                         AnimData *adt= BKE_animdata_from_id(id); \
2066                         NtId_Type *ntp= (NtId_Type *)id; \
2067                         if (ntp->nodetree) { \
2068                                 AnimData *adt2= BKE_animdata_from_id((ID *)ntp->nodetree); \
2069                                 BKE_animsys_evaluate_animdata((ID *)ntp->nodetree, adt2, ctime, ADT_RECALC_ANIM); \
2070                         } \
2071                         BKE_animsys_evaluate_animdata(id, adt, ctime, aflag); \
2072                 } \
2073         }
2074         
2075         /* optimisation: 
2076          * when there are no actions, don't go over database and loop over heaps of datablocks, 
2077          * which should ultimately be empty, since it is not possible for now to have any animation 
2078          * without some actions, and drivers wouldn't get affected by any state changes
2079          *
2080          * however, if there are some curves, we will need to make sure that their 'ctime' property gets
2081          * set correctly, so this optimisation must be skipped in that case...
2082          */
2083         if ((main->action.first == NULL) && (main->curve.first == NULL)) {
2084                 if (G.f & G_DEBUG)
2085                         printf("\tNo Actions, so no animation needs to be evaluated...\n");
2086                         
2087                 return;
2088         }
2089         
2090         /* nodes */
2091         EVAL_ANIM_IDS(main->nodetree.first, ADT_RECALC_ANIM);
2092         
2093         /* textures */
2094         EVAL_ANIM_NODETREE_IDS(main->tex.first, Tex, ADT_RECALC_ANIM);
2095         
2096         /* lamps */
2097         EVAL_ANIM_IDS(main->lamp.first, ADT_RECALC_ANIM);
2098         
2099         /* materials */
2100         EVAL_ANIM_NODETREE_IDS(main->mat.first, Material, ADT_RECALC_ANIM);
2101         
2102         /* cameras */
2103         EVAL_ANIM_IDS(main->camera.first, ADT_RECALC_ANIM);
2104         
2105         /* shapekeys */
2106         EVAL_ANIM_IDS(main->key.first, ADT_RECALC_ANIM);
2107         
2108         /* metaballs */
2109         EVAL_ANIM_IDS(main->mball.first, ADT_RECALC_ANIM);
2110         
2111         /* curves */
2112         EVAL_ANIM_IDS(main->curve.first, ADT_RECALC_ANIM);
2113         
2114         /* armatures */
2115         EVAL_ANIM_IDS(main->armature.first, ADT_RECALC_ANIM);
2116         
2117         /* lattices */
2118         EVAL_ANIM_IDS(main->latt.first, ADT_RECALC_ANIM);
2119         
2120         /* meshes */
2121         EVAL_ANIM_IDS(main->mesh.first, ADT_RECALC_ANIM);
2122         
2123         /* particles */
2124         EVAL_ANIM_IDS(main->particle.first, ADT_RECALC_ANIM);
2125         
2126         /* objects */
2127                 /* ADT_RECALC_ANIM doesn't need to be supplied here, since object AnimData gets 
2128                  * this tagged by Depsgraph on framechange. This optimisation means that objects
2129                  * linked from other (not-visible) scenes will not need their data calculated.
2130                  */
2131         EVAL_ANIM_IDS(main->object.first, 0); 
2132         
2133         /* worlds */
2134         EVAL_ANIM_IDS(main->world.first, ADT_RECALC_ANIM);
2135         
2136         /* scenes */
2137         EVAL_ANIM_NODETREE_IDS(main->scene.first, Scene, ADT_RECALC_ANIM);
2138 }
2139
2140 /* ***************************************** */