2.5 Bugfixes:
[blender-staging.git] / source / blender / blenkernel / intern / anim_sys.c
1 /* Testing code for new animation system in 2.5 
2  * Copyright 2009, Joshua Leung
3  */
4
5 #include <stdio.h>
6 #include <string.h>
7 #include <stddef.h>
8
9 #include "MEM_guardedalloc.h"
10
11 #include "BLI_blenlib.h"
12 #include "BLI_arithb.h"
13 #include "BLI_dynstr.h"
14
15 #include "BKE_animsys.h"
16 #include "BKE_action.h"
17 #include "BKE_fcurve.h"
18 #include "BKE_global.h"
19 #include "BKE_main.h"
20 #include "BKE_utildefines.h"
21
22 #include "RNA_access.h"
23 #include "RNA_types.h"
24
25 #include "DNA_anim_types.h"
26
27 /* ***************************************** */
28 /* AnimData API */
29
30 /* Getter/Setter -------------------------------------------- */
31
32 /* Internal utility to check if ID can have AnimData */
33 static short id_has_animdata (ID *id)
34 {
35         /* sanity check */
36         if (id == NULL)
37                 return 0;
38                 
39         /* Only some ID-blocks have this info for now */
40         // TODO: finish adding this for the other blocktypes
41         switch (GS(id->name)) {
42                         /* has AnimData */
43                 case ID_OB:
44                 case ID_CU:
45                 case ID_KE:
46                 case ID_MA: case ID_TE: case ID_NT:
47                 case ID_LA: case ID_CA: case ID_WO:
48                 case ID_SCE:
49                 {
50                         return 1;
51                 }
52                 
53                         /* no AnimData */
54                 default:
55                         return 0;
56         }
57 }
58
59
60 /* Get AnimData from the given ID-block. In order for this to work, we assume that 
61  * the AnimData pointer is stored immediately after the given ID-block in the struct,
62  * as per IdAdtTemplate.
63  */
64 AnimData *BKE_animdata_from_id (ID *id)
65 {
66         /* only some ID-blocks have this info for now, so we cast the 
67          * types that do to be of type IdAdtTemplate, and extract the
68          * AnimData that way
69          */
70         if (id_has_animdata(id)) {
71                 IdAdtTemplate *iat= (IdAdtTemplate *)id;
72                 return iat->adt;
73         }
74         else
75                 return NULL;
76 }
77
78 /* Add AnimData to the given ID-block. In order for this to work, we assume that 
79  * the AnimData pointer is stored immediately after the given ID-block in the struct,
80  * as per IdAdtTemplate. Also note that 
81  */
82 AnimData *BKE_id_add_animdata (ID *id)
83 {
84         /* Only some ID-blocks have this info for now, so we cast the 
85          * types that do to be of type IdAdtTemplate, and add the AnimData
86          * to it using the template
87          */
88         if (id_has_animdata(id)) {
89                 IdAdtTemplate *iat= (IdAdtTemplate *)id;
90                 
91                 /* check if there's already AnimData, in which case, don't add */
92                 if (iat->adt == NULL)
93                         iat->adt= MEM_callocN(sizeof(AnimData), "AnimData");
94                 
95                 return iat->adt;
96         }
97         else 
98                 return NULL;
99 }
100
101 /* Freeing -------------------------------------------- */
102
103 /* Free AnimData used by the nominated ID-block, and clear ID-block's AnimData pointer */
104 void BKE_free_animdata (ID *id)
105 {
106         /* Only some ID-blocks have this info for now, so we cast the 
107          * types that do to be of type IdAdtTemplate
108          */
109         if (id_has_animdata(id)) {
110                 IdAdtTemplate *iat= (IdAdtTemplate *)id;
111                 AnimData *adt= iat->adt;
112                 
113                 /* check if there's any AnimData to start with */
114                 if (adt) {
115                         /* unlink action (don't free, as it's in its own list) */
116                         if (adt->action)
117                                 adt->action->id.us--;
118                                 
119                         /* free drivers - stored as a list of F-Curves */
120                         free_fcurves(&adt->drivers);
121                         
122                         /* free overrides */
123                         // TODO...
124                         
125                         /* free animdata now */
126                         MEM_freeN(adt);
127                         iat->adt= NULL;
128                 }
129         }
130 }
131
132 /* Freeing -------------------------------------------- */
133
134 /* Make a copy of the given AnimData - to be used when copying datablocks */
135 AnimData *BKE_copy_animdata (AnimData *adt)
136 {
137         AnimData *dadt;
138         
139         /* sanity check before duplicating struct */
140         if (adt == NULL)
141                 return NULL;
142         dadt= MEM_dupallocN(adt);
143         
144         /* make a copy of action - at worst, user has to delete copies... */
145         // XXX review this... it might not be optimal behaviour yet...
146         //id_us_plus((ID *)dadt->action);
147         dadt->action= copy_action(adt->action);
148         
149         /* duplicate NLA data */
150         // XXX todo...
151         
152         /* duplicate drivers (F-Curves) */
153         copy_fcurves(&dadt->drivers, &adt->drivers);
154         
155         /* don't copy overrides */
156         dadt->overrides.first= dadt->overrides.last= NULL;
157         
158         /* return */
159         return dadt;
160 }
161
162 /* *********************************** */ 
163 /* KeyingSet API */
164
165 /* NOTES:
166  * It is very likely that there will be two copies of the api - one for internal use,
167  * and one 'operator' based wrapper of the internal API, which should allow for access
168  * from Python/scripts so that riggers can automate the creation of KeyingSets for their rigs.
169  */
170
171 /* Finding Tools --------------------------- */
172
173 /* Find the first path that matches the given criteria */
174 // TODO: do we want some method to perform partial matches too?
175 KS_Path *BKE_keyingset_find_destination (KeyingSet *ks, ID *id, const char group_name[], const char rna_path[], int array_index, int group_mode)
176 {
177         KS_Path *ksp;
178         
179         /* sanity checks */
180         if ELEM(NULL, ks, rna_path)
181                 return NULL;
182         
183         /* ID is optional for relative KeyingSets, but is necessary for absolute KeyingSets */
184         if (id == NULL) {
185                 if (ks->flag & KEYINGSET_ABSOLUTE)
186                         return NULL;
187         }
188         
189         /* loop over paths in the current KeyingSet, finding the first one where all settings match 
190          * (i.e. the first one where none of the checks fail and equal 0)
191          */
192         for (ksp= ks->paths.first; ksp; ksp= ksp->next) {
193                 short eq_id=1, eq_path=1, eq_index=1, eq_group=1;
194                 
195                 /* id */
196                 if ((ks->flag & KEYINGSET_ABSOLUTE) && (id != ksp->id))
197                         eq_id= 0;
198                 
199                 /* path */
200                 if ((ksp->rna_path==0) || strcmp(rna_path, ksp->rna_path))
201                         eq_path= 0;
202                         
203                 /* index */
204                 if (ksp->array_index != array_index)
205                         eq_index= 0;
206                         
207                 /* group */
208                 if (group_name) {
209                         // FIXME: these checks need to be coded... for now, it's not too important though
210                 }
211                         
212                 /* if all aspects are ok, return */
213                 if (eq_id && eq_path && eq_index && eq_group)
214                         return ksp;
215         }
216         
217         /* none found */
218         return NULL;
219 }
220  
221 /* Defining Tools --------------------------- */
222
223 /* Used to create a new 'custom' KeyingSet for the user, that will be automatically added to the stack */
224 KeyingSet *BKE_keyingset_add (ListBase *list, const char name[], short flag, short keyingflag)
225 {
226         KeyingSet *ks;
227         
228         /* allocate new KeyingSet */
229         ks= MEM_callocN(sizeof(KeyingSet), "KeyingSet");
230         
231         if (name)
232                 BLI_snprintf(ks->name, 64, name);
233         else
234                 strcpy(ks->name, "Keying Set");
235         
236         ks->flag= flag;
237         ks->keyingflag= keyingflag;
238         
239         /* add KeyingSet to list */
240         BLI_addtail(list, ks);
241         
242         /* make sure KeyingSet has a unique name (this helps with identification) */
243         BLI_uniquename(list, ks, "Keying Set", ' ', offsetof(KeyingSet, name), 64);
244         
245         /* return new KeyingSet for further editing */
246         return ks;
247 }
248
249 /* Add a destination to a KeyingSet. Nothing is returned for now...
250  * Checks are performed to ensure that destination is appropriate for the KeyingSet in question
251  */
252 void BKE_keyingset_add_destination (KeyingSet *ks, ID *id, const char group_name[], const char rna_path[], int array_index, short flag, short groupmode)
253 {
254         KS_Path *ksp;
255         
256         /* sanity checks */
257         if ELEM(NULL, ks, rna_path)
258                 return;
259         
260         /* ID is optional for relative KeyingSets, but is necessary for absolute KeyingSets */
261         if (id == NULL) {
262                 if (ks->flag & KEYINGSET_ABSOLUTE)
263                         return;
264         }
265         
266         /* don't add if there is already a matching KS_Path in the KeyingSet */
267         if (BKE_keyingset_find_destination(ks, id, group_name, rna_path, array_index, groupmode))
268                 return;
269         
270         /* allocate a new KeyingSet Path */
271         ksp= MEM_callocN(sizeof(KS_Path), "KeyingSet Path");
272         
273         /* just store absolute info */
274         if (ks->flag & KEYINGSET_ABSOLUTE) {
275                 ksp->id= id;
276                 if (group_name)
277                         BLI_snprintf(ksp->group, 64, group_name);
278                 else
279                         strcpy(ksp->group, "");
280         }
281         
282         /* store additional info for relative paths (just in case user makes the set relative) */
283         if (id)
284                 ksp->idtype= GS(id->name);
285         
286         /* just copy path info */
287         // XXX no checks are performed for templates yet
288         // should array index be checked too?
289         ksp->rna_path= BLI_strdupn(rna_path, strlen(rna_path));
290         ksp->array_index= array_index;
291         
292         /* store flags */
293         ksp->flag= flag;
294         ksp->groupmode= groupmode;
295         
296         /* add KeyingSet path to KeyingSet */
297         BLI_addtail(&ks->paths, ksp);
298 }       
299
300
301 /* Freeing Tools --------------------------- */
302
303 /* Free data for KeyingSet but not set itself */
304 void BKE_keyingset_free (KeyingSet *ks)
305 {
306         KS_Path *ksp, *kspn;
307         
308         /* sanity check */
309         if (ks == NULL)
310                 return;
311         
312         /* free each path as we go to avoid looping twice */
313         for (ksp= ks->paths.first; ksp; ksp= kspn) {
314                 kspn= ksp->next;
315                 
316                 /* free RNA-path info */
317                 MEM_freeN(ksp->rna_path);
318                 
319                 /* free path itself */
320                 BLI_freelinkN(&ks->paths, ksp);
321         }
322 }
323
324 /* Free all the KeyingSets in the given list */
325 void BKE_keyingsets_free (ListBase *list)
326 {
327         KeyingSet *ks, *ksn;
328         
329         /* sanity check */
330         if (list == NULL)
331                 return;
332         
333         /* loop over KeyingSets freeing them 
334          *      - BKE_keyingset_free() doesn't free the set itself, but it frees its sub-data
335          */
336         for (ks= list->first; ks; ks= ksn) {
337                 ksn= ks->next;
338                 BKE_keyingset_free(ks);
339                 BLI_freelinkN(list, ks);
340         }
341 }
342
343 /* ***************************************** */
344 /* Evaluation Data-Setting Backend */
345
346 /* Retrieve string to act as RNA-path, adjusted using mapping-table if provided 
347  * It returns whether the string needs to be freed (i.e. if it was a temp remapped one)
348  * // 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
349  *
350  *      - remap: remapping table to use
351  *      - path: original path string (as stored in F-Curve data)
352  *      - dst: destination string to write data to
353  */
354 short animsys_remap_path (AnimMapper *remap, char *path, char **dst)
355 {
356         /* is there a valid remapping table to use? */
357         if (remap) {
358                 /* find a matching entry... to use to remap */
359                 // ...TODO...
360         }
361         
362         /* nothing suitable found, so just set dst to look at path (i.e. no alloc/free needed) */
363         *dst= path;
364         return 0;
365 }
366
367
368 /* Write the given value to a setting using RNA, and return success */
369 static short animsys_write_rna_setting (PointerRNA *ptr, char *path, int array_index, float value)
370 {
371         PropertyRNA *prop;
372         PointerRNA new_ptr;
373         
374         /* get property to write to */
375         if (RNA_path_resolve(ptr, path, &new_ptr, &prop)) 
376         {
377                 /* set value - only for animatable numerical values */
378                 if (RNA_property_animateable(&new_ptr, prop)) 
379                 {
380                         switch (RNA_property_type(prop)) 
381                         {
382                                 case PROP_BOOLEAN:
383                                         if (RNA_property_array_length(prop))
384                                                 RNA_property_boolean_set_index(&new_ptr, prop, array_index, (int)value);
385                                         else
386                                                 RNA_property_boolean_set(&new_ptr, prop, (int)value);
387                                         break;
388                                 case PROP_INT:
389                                         if (RNA_property_array_length(prop))
390                                                 RNA_property_int_set_index(&new_ptr, prop, array_index, (int)value);
391                                         else
392                                                 RNA_property_int_set(&new_ptr, prop, (int)value);
393                                         break;
394                                 case PROP_FLOAT:
395                                         if (RNA_property_array_length(prop))
396                                                 RNA_property_float_set_index(&new_ptr, prop, array_index, value);
397                                         else
398                                                 RNA_property_float_set(&new_ptr, prop, value);
399                                         break;
400                                 case PROP_ENUM:
401                                         RNA_property_enum_set(&new_ptr, prop, (int)value);
402                                         break;
403                                 default:
404                                         /* nothing can be done here... so it is unsuccessful? */
405                                         return 0;
406                         }
407                 }
408                 
409                 /* successful */
410                 return 1;
411         }
412         else {
413                 /* failed to get path */
414                 // XXX don't tag as failed yet though, as there are some legit situations (Action Constraint) 
415                 // where some channels will not exist, but shouldn't lock up Action
416                 if (G.f & G_DEBUG) {
417                         printf("Animato: Invalid path. ID = '%s',  '%s [%d]' \n", 
418                                 (ptr && ptr->id.data) ? (((ID *)ptr->id.data)->name+2) : "<No ID>", 
419                                 path, array_index);
420                 }
421                 return 0;
422         }
423 }
424
425 /* Simple replacement based data-setting of the FCurve using RNA */
426 static short animsys_execute_fcurve (PointerRNA *ptr, AnimMapper *remap, FCurve *fcu)
427 {
428         char *path = NULL;
429         short free_path=0;
430         short ok= 0;
431         
432         /* get path, remapped as appropriate to work in its new environment */
433         free_path= animsys_remap_path(remap, fcu->rna_path, &path);
434         
435         /* write value to setting */
436         if (path)
437                 ok= animsys_write_rna_setting(ptr, path, fcu->array_index, fcu->curval);
438         
439         /* free temp path-info */
440         if (free_path)
441                 MEM_freeN(path);
442                 
443         /* return whether we were successful */
444         return ok;
445 }
446
447 /* Evaluate all the F-Curves in the given list 
448  * This performs a set of standard checks. If extra checks are required, separate code should be used
449  */
450 static void animsys_evaluate_fcurves (PointerRNA *ptr, ListBase *list, AnimMapper *remap, float ctime)
451 {
452         FCurve *fcu;
453         
454         /* calculate then execute each curve */
455         for (fcu= list->first; fcu; fcu= fcu->next) 
456         {
457                 /* check if this curve should be skipped */
458                 if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
459                 {
460                         calculate_fcurve(fcu, ctime);
461                         animsys_execute_fcurve(ptr, remap, fcu); 
462                 }
463         }
464 }
465
466 /* ***************************************** */
467 /* Driver Evaluation */
468
469 /* Evaluate Drivers */
470 static void animsys_evaluate_drivers (PointerRNA *ptr, AnimData *adt, float ctime)
471 {
472         FCurve *fcu;
473         
474         /* drivers are stored as F-Curves, but we cannot use the standard code, as we need to check if
475          * the depsgraph requested that this driver be evaluated...
476          */
477         for (fcu= adt->drivers.first; fcu; fcu= fcu->next) 
478         {
479                 ChannelDriver *driver= fcu->driver;
480                 short ok= 0;
481                 
482                 /* check if this driver's curve should be skipped */
483                 // FIXME: maybe we shouldn't check for muted, though that would make things more confusing, as there's already too many ways to disable?
484                 if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
485                 {
486                         /* check if driver itself is tagged for recalculation */
487                         if ((driver) && !(driver->flag & DRIVER_FLAG_INVALID)/*&& (driver->flag & DRIVER_FLAG_RECALC)*/) {      // XXX driver recalc flag is not set yet by depsgraph!
488                                 /* evaluate this using values set already in other places */
489                                 // 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
490                                 calculate_fcurve(fcu, ctime);
491                                 ok= animsys_execute_fcurve(ptr, NULL, fcu);
492                                 
493                                 /* clear recalc flag */
494                                 driver->flag &= ~DRIVER_FLAG_RECALC;
495                                 
496                                 /* set error-flag if evaluation failed */
497                                 if (ok == 0)
498                                         driver->flag |= DRIVER_FLAG_INVALID; 
499                         }
500                 }
501         }
502 }
503
504 /* ***************************************** */
505 /* Actions Evaluation */
506
507 /* Evaluate Action Group */
508 void animsys_evaluate_action_group (PointerRNA *ptr, bAction *act, bActionGroup *agrp, AnimMapper *remap, float ctime)
509 {
510         FCurve *fcu;
511         
512         /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
513         if ELEM(NULL, act, agrp) return;
514         if ((remap) && (remap->target != act)) remap= NULL;
515         
516         /* calculate then execute each curve */
517         for (fcu= agrp->channels.first; (fcu) && (fcu->grp == agrp); fcu= fcu->next) 
518         {
519                 /* check if this curve should be skipped */
520                 if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
521                 {
522                         calculate_fcurve(fcu, ctime);
523                         animsys_execute_fcurve(ptr, remap, fcu); 
524                 }
525         }
526 }
527
528 /* Evaluate Action (F-Curve Bag) */
529 void animsys_evaluate_action (PointerRNA *ptr, bAction *act, AnimMapper *remap, float ctime)
530 {
531         /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
532         if (act == NULL) return;
533         if ((remap) && (remap->target != act)) remap= NULL;
534         
535         /* calculate then execute each curve */
536         animsys_evaluate_fcurves(ptr, &act->curves, remap, ctime);
537 }
538
539 /* ***************************************** */
540 /* NLA System - Evaluation */
541
542 /* used for list of strips to accumulate at current time */
543 typedef struct NlaEvalStrip {
544         struct NlaEvalStrip *next, *prev;
545         
546         NlaTrack *track;                        /* track that this strip belongs to */
547         NlaStrip *strip;                /* strip that's being used */
548         NlaStrip *sblend;               /* strip that's being blended towards (if applicable) */
549         
550         short track_index;                      /* the index of the track within the list */
551         short strip_mode;                       /* which end of the strip are we looking at */
552 } NlaEvalStrip;
553
554 /* bNlaEvalStrip->strip_mode */
555 enum {
556         NES_TIME_BEFORE = -1,
557         NES_TIME_WITHIN,
558         NES_TIME_AFTER,
559         NES_TIME_AFTER_BLEND
560 } eNlaEvalStrip_StripMode;
561
562
563 /* temp channel for accumulating data from NLA (avoids needing to clear all values first) */
564 // TODO: maybe this will be used as the 'cache' stuff needed for editable values too?
565 typedef struct NlaEvalChannel {
566         struct NlaEvalChannel *next, *prev;
567         
568         char *path;                             /* ready-to-use path (i.e. remapped already) */
569         int array_index;                /* if applicable... */
570         
571         float value;                    /* value of this channel */
572 } NlaEvalChannel;
573
574
575 /* ---------------------- */
576
577 /* evaluate the F-Curves controlling settings for the NLA-strips (currently, not relinkable) */
578 static void nlastrip_evaluate_fcurves (NlaStrip *strip, float ctime)
579 {
580         //PointerRNA actstrip_ptr;
581         //FCurve *fcu;
582         
583         /* create RNA-pointer needed to set values */
584         //RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &actstrip_ptr);
585         
586         /* execute these settings as per normal */
587         //animsys_evaluate_fcurves(&actstrip_ptr, &strip->fcurves, NULL, ctime);
588 }
589
590
591 /* gets the strip active at the current time for a track */
592 static void nlatrack_ctime_get_strip (ListBase *list, NlaTrack *nlt, short index, float ctime)
593 {
594         NlaStrip *strip, *astrip=NULL, *bstrip=NULL;
595         NlaEvalStrip *nes;
596         short side= 0;
597         
598         /* skip if track is muted */
599         if (nlt->flag & NLATRACK_MUTED) 
600                 return;
601         
602         /* loop over strips, checking if they fall within the range */
603         for (strip= nlt->strips.first; strip; strip= strip->next) {
604                 /* only consider if:
605                  *      - current time occurs within strip's extents
606                  *      - current time occurs before strip (if it is the first)
607                  *      - current time occurs after strip (if hold is on)
608                  *      - current time occurs between strips (1st of those isn't holding) - blend!
609                  */
610                 if (IN_RANGE(ctime, strip->start, strip->end)) {
611                         astrip= strip;
612                         side= NES_TIME_WITHIN;
613                         break;
614                 }
615                 else if (ctime < strip->start) {
616                         if (strip == nlt->strips.first) {
617                                 astrip= strip;
618                                 side= NES_TIME_BEFORE;
619                                 break;
620                         }
621                         else {
622                                 astrip= strip->prev;
623                                 
624                                 if (astrip->flag & NLASTRIP_HOLDLASTFRAME) {
625                                         side= NES_TIME_AFTER;
626                                         break;
627                                 }
628                                 else {
629                                         bstrip= strip;
630                                         side= NES_TIME_AFTER_BLEND;
631                                         break;
632                                 }
633                         }
634                 }
635         }
636         
637         /* check if strip has been found (and whether it has data worth considering) */
638         if (ELEM(NULL, astrip, astrip->act)) 
639                 return;
640         if (astrip->flag & NLASTRIP_MUTE) 
641                 return;
642         
643         /* check if blending between strips */
644         if (side == NES_TIME_AFTER_BLEND) {
645                 /* blending between strips... so calculate influence+act_time of both */
646                 nlastrip_evaluate_fcurves(astrip, ctime);
647                 nlastrip_evaluate_fcurves(bstrip, ctime);
648                 
649                 if ((astrip->influence <= 0.0f) && (bstrip->influence <= 0.0f))
650                         return;
651         }
652         else {
653                 /* calculate/set the influence+act_time of this strip - don't consider if 0 influence */
654                 nlastrip_evaluate_fcurves(astrip, ctime);
655                 
656                 if (astrip->influence <= 0.0f) 
657                         return;
658         }
659         
660         
661         /* allocate new eval-strip for this strip + add to stack */
662         nes= MEM_callocN(sizeof(NlaEvalStrip), "NlaEvalStrip");
663         
664         nes->track= nlt;
665         nes->strip= astrip;
666         nes->sblend= bstrip;
667         nes->track_index= index;
668         nes->strip_mode= side;
669         
670         BLI_addtail(list, nes);
671 }
672
673 /* ---------------------- */
674
675 /* evaluates the given evaluation strip */
676 // FIXME: will we need the evaluation cache table set up to blend stuff in?
677 // TODO: only evaluate here, but flush in one go using the accumulated channels at end...
678 static void nlastrip_ctime_evaluate (ListBase *channels, NlaEvalStrip *nes, float ctime)
679 {
680         // 1. (in old code) was to extract 'IPO-channels' from actions
681         // 2. blend between the 'accumulated' data, and the new data
682 }
683
684 /* write the accumulated settings to */
685 static void nladata_flush_channels (PointerRNA *ptr, ListBase *channels)
686 {
687         
688 }
689
690 /* ---------------------- */
691
692 /* NLA Evaluation function (mostly for use through do_animdata) 
693  *      - All channels that will be affected are not cleared anymore. Instead, we just evaluate into 
694  *              some temp channels, where values can be accumulated in one go.
695  */
696 static void animsys_evaluate_nla (PointerRNA *ptr, AnimData *adt, float ctime)
697 {
698         NlaTrack *nlt;
699         short track_index=0;
700         
701         ListBase estrips= {NULL, NULL};
702         ListBase echannels= {NULL, NULL};
703         NlaEvalStrip *nes;
704         
705         /* 1. get the stack of strips to evaluate at current time (influence calculated here) */
706         for (nlt=adt->nla_tracks.first; nlt; nlt=nlt->next, track_index++) 
707                 nlatrack_ctime_get_strip(&estrips, nlt, track_index, ctime);
708         
709         /* only continue if there are strips to evaluate */
710         if (estrips.first == NULL)
711                 return;
712         
713         
714         /* 2. for each strip, evaluate then accumulate on top of existing channels, but don't set values yet */
715         for (nes= estrips.first; nes; nes= nes->next) 
716                 nlastrip_ctime_evaluate(&echannels, nes, ctime);
717         
718         /* 3. flush effects of accumulating channels in NLA to the actual data they affect */
719         nladata_flush_channels(ptr, &echannels);
720         
721         /* 4. free temporary evaluation data */
722         BLI_freelistN(&estrips);
723         BLI_freelistN(&echannels);
724 }
725
726 /* ***************************************** */ 
727 /* Overrides System - Public API */
728
729 /* Clear all overides */
730
731 /* Add or get existing Override for given setting */
732 AnimOverride *BKE_animsys_validate_override (PointerRNA *ptr, char *path, int array_index)
733 {
734         // FIXME: need to define how to get overrides
735         return NULL;
736
737
738 /* -------------------- */
739
740 /* Evaluate Overrides */
741 static void animsys_evaluate_overrides (PointerRNA *ptr, AnimData *adt, float ctime)
742 {
743         AnimOverride *aor;
744         
745         /* for each override, simply execute... */
746         for (aor= adt->overrides.first; aor; aor= aor->next)
747                 animsys_write_rna_setting(ptr, aor->rna_path, aor->array_index, aor->value);
748 }
749
750 /* ***************************************** */
751 /* Evaluation System - Public API */
752
753 /* Overview of how this system works:
754  *      1) Depsgraph sorts data as necessary, so that data is in an order that means 
755  *              that all dependences are resolved before dependants.
756  *      2) All normal animation is evaluated, so that drivers have some basis values to
757  *              work with
758  *              a.      NLA stacks are done first, as the Active Actions act as 'tweaking' tracks
759  *                      which modify the effects of the NLA-stacks
760  *              b.      Active Action is evaluated as per normal, on top of the results of the NLA tracks
761  *
762  * --------------< often in a separate phase... >------------------ 
763  *
764  *      3) Drivers/expressions are evaluated on top of this, in an order where dependences are
765  *              resolved nicely. 
766  *         Note: it may be necessary to have some tools to handle the cases where some higher-level
767  *              drivers are added and cause some problematic dependencies that didn't exist in the local levels...
768  *
769  * --------------< always executed >------------------ 
770  *
771  * Maintainance of editability of settings (XXX):
772  *      In order to ensure that settings that are animated can still be manipulated in the UI without requiring
773  *      that keyframes are added to prevent these values from being overwritten, we use 'overrides'. 
774  *
775  * Unresolved things:
776  *      - Handling of multi-user settings (i.e. time-offset, group-instancing) -> big cache grids or nodal system? but stored where?
777  *      - Multiple-block dependencies (i.e. drivers for settings are in both local and higher levels) -> split into separate lists?  
778  */
779
780 /* Evaluation loop for evaluation animation data 
781  *
782  * This assumes that the animation-data provided belongs to the ID block in question,
783  * and that the flags for which parts of the anim-data settings need to be recalculated 
784  * have been set already by the depsgraph. Now, we use the recalc 
785  */
786 void BKE_animsys_evaluate_animdata (ID *id, AnimData *adt, float ctime, short recalc)
787 {
788         PointerRNA id_ptr;
789         
790         /* sanity checks */
791         if ELEM(NULL, id, adt)
792                 return;
793         
794         /* get pointer to ID-block for RNA to use */
795         RNA_id_pointer_create(id, &id_ptr);
796         
797         /* recalculate keyframe data:
798          *      - NLA before Active Action, as Active Action behaves as 'tweaking track'
799          *        that overrides 'rough' work in NLA
800          */
801         if ((recalc & ADT_RECALC_ANIM) || (adt->recalc & ADT_RECALC_ANIM))
802         {
803                 /* evaluate NLA data */
804                 if ((adt->nla_tracks.first) && !(adt->flag & ADT_NLA_EVAL_OFF))
805                 {
806                         animsys_evaluate_nla(&id_ptr, adt, ctime);
807                 }
808                 
809                 /* evaluate Action data */
810                 // FIXME: what if the solo track was not tweaking one, then nla-solo should be checked too?
811                 if (adt->action) 
812                         animsys_evaluate_action(&id_ptr, adt->action, adt->remap, ctime);
813                 
814                 /* reset tag */
815                 adt->recalc &= ~ADT_RECALC_ANIM;
816         }
817         
818         /* recalculate drivers 
819          *      - Drivers need to be evaluated afterwards, as they can either override 
820          *        or be layered on top of existing animation data.
821          *      - Drivers should be in the appropriate order to be evaluated without problems...
822          */
823         if ((recalc & ADT_RECALC_DRIVERS) /*&& (adt->recalc & ADT_RECALC_DRIVERS)*/) // XXX for now, don't check yet, as depsgraph hasn't been updated
824         {
825                 animsys_evaluate_drivers(&id_ptr, adt, ctime);
826         }
827         
828         /* always execute 'overrides' 
829          *      - Overrides allow editing, by overwriting the value(s) set from animation-data, with the
830          *        value last set by the user (and not keyframed yet). 
831          *      - Overrides are cleared upon frame change and/or keyframing
832          *      - It is best that we execute this everytime, so that no errors are likely to occur.
833          */
834         animsys_evaluate_overrides(&id_ptr, adt, ctime);
835         
836         /* clear recalc flag now */
837         adt->recalc= 0;
838 }
839
840 /* Evaluation of all ID-blocks with Animation Data blocks - Animation Data Only
841  *
842  * This will evaluate only the animation info available in the animation data-blocks
843  * encountered. In order to enforce the system by which some settings controlled by a
844  * 'local' (i.e. belonging in the nearest ID-block that setting is related to, not a
845  * standard 'root') block are overridden by a larger 'user'
846  */
847 // TODO: we currently go over entire 'main' database...
848 void BKE_animsys_evaluate_all_animation (Main *main, float ctime)
849 {
850         ID *id;
851         
852         if (G.f & G_DEBUG)
853                 printf("Evaluate all animation - %f \n", ctime);
854
855         /* macro for less typing */
856 #define EVAL_ANIM_IDS(first, flag) \
857         for (id= first; id; id= id->next) { \
858                 AnimData *adt= BKE_animdata_from_id(id); \
859                 BKE_animsys_evaluate_animdata(id, adt, ctime, flag); \
860         }
861         
862         /* nodes */
863         // TODO...
864         
865         /* textures */
866         EVAL_ANIM_IDS(main->tex.first, ADT_RECALC_ANIM);
867         
868         /* lamps */
869         EVAL_ANIM_IDS(main->lamp.first, ADT_RECALC_ANIM);
870         
871         /* materials */
872         EVAL_ANIM_IDS(main->mat.first, ADT_RECALC_ANIM);
873         
874         /* cameras */
875         EVAL_ANIM_IDS(main->camera.first, ADT_RECALC_ANIM);
876         
877         /* shapekeys */
878         EVAL_ANIM_IDS(main->key.first, ADT_RECALC_ANIM);
879         
880         /* curves */
881         // TODO...
882         
883         /* meshes */
884         // TODO...
885         
886         /* objects */
887                 /* ADT_RECALC_ANIM doesn't need to be supplied here, since object AnimData gets 
888                  * this tagged by Depsgraph on framechange 
889                  */
890         EVAL_ANIM_IDS(main->object.first, /*ADT_RECALC_ANIM*/0); 
891         
892         /* worlds */
893         EVAL_ANIM_IDS(main->world.first, ADT_RECALC_ANIM);
894         
895         /* scenes */
896         EVAL_ANIM_IDS(main->scene.first, ADT_RECALC_ANIM);
897 }
898
899 /* ***************************************** */