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