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