Animato: Hiding all debug prints behind -d flag, as they were causing too many slowdo...
[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 /* ***************************************** */
163 /* Evaluation Data-Setting Backend */
164
165 /* Retrieve string to act as RNA-path, adjusted using mapping-table if provided 
166  * It returns whether the string needs to be freed (i.e. if it was a temp remapped one)
167  * // 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
168  *
169  *      - remap: remapping table to use
170  *      - path: original path string (as stored in F-Curve data)
171  *      - dst: destination string to write data to
172  */
173 short animsys_remap_path (AnimMapper *remap, char *path, char **dst)
174 {
175         /* is there a valid remapping table to use? */
176         if (remap) {
177                 /* find a matching entry... to use to remap */
178                 // ...TODO...
179         }
180         
181         /* nothing suitable found, so just set dst to look at path (i.e. no alloc/free needed) */
182         *dst= path;
183         return 0;
184 }
185
186
187 /* Write the given value to a setting using RNA, and return success */
188 static short animsys_write_rna_setting (PointerRNA *ptr, char *path, int array_index, float value)
189 {
190         PropertyRNA *prop;
191         PointerRNA new_ptr;
192         
193         /* get property to write to */
194         if (RNA_path_resolve(ptr, path, &new_ptr, &prop)) 
195         {
196                 /* set value - only for animatable numerical values */
197                 if (RNA_property_animateable(&new_ptr, prop)) 
198                 {
199                         switch (RNA_property_type(&new_ptr, prop)) 
200                         {
201                                 case PROP_BOOLEAN:
202                                         if (RNA_property_array_length(&new_ptr, prop))
203                                                 RNA_property_boolean_set_array(&new_ptr, prop, array_index, (int)value);
204                                         else
205                                                 RNA_property_boolean_set(&new_ptr, prop, (int)value);
206                                         break;
207                                 case PROP_INT:
208                                         if (RNA_property_array_length(&new_ptr, prop))
209                                                 RNA_property_int_set_array(&new_ptr, prop, array_index, (int)value);
210                                         else
211                                                 RNA_property_int_set(&new_ptr, prop, (int)value);
212                                         break;
213                                 case PROP_FLOAT:
214                                         if (RNA_property_array_length(&new_ptr, prop))
215                                                 RNA_property_float_set_array(&new_ptr, prop, array_index, value);
216                                         else
217                                                 RNA_property_float_set(&new_ptr, prop, value);
218                                         break;
219                                 case PROP_ENUM:
220                                         RNA_property_enum_set(&new_ptr, prop, (int)value);
221                                         break;
222                                 default:
223                                         break;
224                         }
225                 }
226                 
227                 /* successful */
228                 // XXX should the unhandled case also be successful?
229                 return 1;
230         }
231         else {
232                 /* failed to get path */
233                 // XXX don't tag as failed yet though, as there are some legit situations (Action Constraint) 
234                 // where some channels will not exist, but shouldn't lock up Action
235                 if (G.f & G_DEBUG) {
236                         printf("Animato: Invalid path. ID = '%s',  '%s [%d]' \n", 
237                                 (ptr && ptr->id.data) ? (((ID *)ptr->id.data)->name+2) : "<No ID>", 
238                                 path, array_index);
239                 }
240                 return 0;
241         }
242 }
243
244 /* Simple replacement based data-setting of the FCurve using RNA */
245 static void animsys_execute_fcurve (PointerRNA *ptr, AnimMapper *remap, FCurve *fcu)
246 {
247         char *path = NULL;
248         short free_path=0;
249         
250         /* get path, remapped as appropriate to work in its new environment */
251         free_path= animsys_remap_path(remap, fcu->rna_path, &path);
252         
253         /* write value to setting */
254         if (path)
255                 animsys_write_rna_setting(ptr, path, fcu->array_index, fcu->curval);
256         
257         /* free temp path-info */
258         if (free_path)
259                 MEM_freeN(path);
260 }
261
262 /* Evaluate all the F-Curves in the given list 
263  * This performs a set of standard checks. If extra checks are required, separate code should be used
264  */
265 static void animsys_evaluate_fcurves (PointerRNA *ptr, ListBase *list, AnimMapper *remap, float ctime)
266 {
267         FCurve *fcu;
268         
269         /* calculate then execute each curve */
270         for (fcu= list->first; fcu; fcu= fcu->next) 
271         {
272                 /* check if this curve should be skipped */
273                 if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
274                 {
275                         calculate_fcurve(fcu, ctime);
276                         animsys_execute_fcurve(ptr, remap, fcu); 
277                 }
278         }
279 }
280
281 /* ***************************************** */
282 /* Driver Evaluation */
283
284 /* Evaluate Drivers */
285 static void animsys_evaluate_drivers (PointerRNA *ptr, AnimData *adt, float ctime)
286 {
287         FCurve *fcu;
288         
289         /* drivers are stored as F-Curves, but we cannot use the standard code, as we need to check if
290          * the depsgraph requested that this driver be evaluated...
291          */
292         for (fcu= adt->drivers.first; fcu; fcu= fcu->next) 
293         {
294                 ChannelDriver *driver= fcu->driver;
295                 
296                 /* check if this driver's curve should be skipped */
297                 // FIXME: maybe we shouldn't check for muted, though that would make things more confusing, as there's already too many ways to disable?
298                 if ((fcu->flag & (FCURVE_MUTED|FCURVE_DISABLED)) == 0) 
299                 {
300                         /* check if driver itself is tagged for recalculation */
301                         if ((driver) /*&& (driver->flag & DRIVER_FLAG_RECALC)*/) {      // XXX driver recalc flag is not set yet by depsgraph!
302                                 /* evaluate this using values set already in other places */
303                                 // 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
304                                 calculate_fcurve(fcu, ctime);
305                                 animsys_execute_fcurve(ptr, NULL, fcu);
306                                 
307                                 /* clear recalc flag */
308                                 driver->flag &= ~DRIVER_FLAG_RECALC;
309                         }
310                 }
311         }
312 }
313
314 /* ***************************************** */
315 /* Actions Evaluation */
316
317 /* Evaluate Action (F-Curve Bag) */
318 static void animsys_evaluate_action (PointerRNA *ptr, bAction *act, AnimMapper *remap, float ctime)
319 {
320         /* check if mapper is appropriate for use here (we set to NULL if it's inappropriate) */
321         if (act == NULL) return;
322         if ((remap) && (remap->target != act)) remap= NULL;
323         
324         /* calculate then execute each curve */
325         animsys_evaluate_fcurves(ptr, &act->curves, remap, ctime);
326 }
327
328 /* ***************************************** */
329 /* NLA System - Evaluation */
330
331 /* used for list of strips to accumulate at current time */
332 typedef struct NlaEvalStrip {
333         struct NlaEvalStrip *next, *prev;
334         
335         NlaTrack *track;                        /* track that this strip belongs to */
336         NlaStrip *strip;                /* strip that's being used */
337         NlaStrip *sblend;               /* strip that's being blended towards (if applicable) */
338         
339         short track_index;                      /* the index of the track within the list */
340         short strip_mode;                       /* which end of the strip are we looking at */
341 } NlaEvalStrip;
342
343 /* bNlaEvalStrip->strip_mode */
344 enum {
345         NES_TIME_BEFORE = -1,
346         NES_TIME_WITHIN,
347         NES_TIME_AFTER,
348         NES_TIME_AFTER_BLEND
349 } eNlaEvalStrip_StripMode;
350
351
352 /* temp channel for accumulating data from NLA (avoids needing to clear all values first) */
353 // TODO: maybe this will be used as the 'cache' stuff needed for editable values too?
354 typedef struct NlaEvalChannel {
355         struct NlaEvalChannel *next, *prev;
356         
357         char *path;                             /* ready-to-use path (i.e. remapped already) */
358         int array_index;                /* if applicable... */
359         
360         float value;                    /* value of this channel */
361 } NlaEvalChannel;
362
363
364 /* ---------------------- */
365
366 /* evaluate the F-Curves controlling settings for the NLA-strips (currently, not relinkable) */
367 static void nlastrip_evaluate_fcurves (NlaStrip *strip, float ctime)
368 {
369         //PointerRNA actstrip_ptr;
370         //FCurve *fcu;
371         
372         /* create RNA-pointer needed to set values */
373         //RNA_pointer_create(NULL, &RNA_NlaStrip, strip, &actstrip_ptr);
374         
375         /* execute these settings as per normal */
376         //animsys_evaluate_fcurves(&actstrip_ptr, &strip->fcurves, NULL, ctime);
377 }
378
379
380 /* gets the strip active at the current time for a track */
381 static void nlatrack_ctime_get_strip (ListBase *list, NlaTrack *nlt, short index, float ctime)
382 {
383         NlaStrip *strip, *astrip=NULL, *bstrip=NULL;
384         NlaEvalStrip *nes;
385         short side= 0;
386         
387         /* skip if track is muted */
388         if (nlt->flag & NLATRACK_MUTED) 
389                 return;
390         
391         /* loop over strips, checking if they fall within the range */
392         for (strip= nlt->strips.first; strip; strip= strip->next) {
393                 /* only consider if:
394                  *      - current time occurs within strip's extents
395                  *      - current time occurs before strip (if it is the first)
396                  *      - current time occurs after strip (if hold is on)
397                  *      - current time occurs between strips (1st of those isn't holding) - blend!
398                  */
399                 if (IN_RANGE(ctime, strip->start, strip->end)) {
400                         astrip= strip;
401                         side= NES_TIME_WITHIN;
402                         break;
403                 }
404                 else if (ctime < strip->start) {
405                         if (strip == nlt->strips.first) {
406                                 astrip= strip;
407                                 side= NES_TIME_BEFORE;
408                                 break;
409                         }
410                         else {
411                                 astrip= strip->prev;
412                                 
413                                 if (astrip->flag & NLASTRIP_HOLDLASTFRAME) {
414                                         side= NES_TIME_AFTER;
415                                         break;
416                                 }
417                                 else {
418                                         bstrip= strip;
419                                         side= NES_TIME_AFTER_BLEND;
420                                         break;
421                                 }
422                         }
423                 }
424         }
425         
426         /* check if strip has been found (and whether it has data worth considering) */
427         if (ELEM(NULL, astrip, astrip->act)) 
428                 return;
429         if (astrip->flag & NLASTRIP_MUTE) 
430                 return;
431         
432         /* check if blending between strips */
433         if (side == NES_TIME_AFTER_BLEND) {
434                 /* blending between strips... so calculate influence+act_time of both */
435                 nlastrip_evaluate_fcurves(astrip, ctime);
436                 nlastrip_evaluate_fcurves(bstrip, ctime);
437                 
438                 if ((astrip->influence <= 0.0f) && (bstrip->influence <= 0.0f))
439                         return;
440         }
441         else {
442                 /* calculate/set the influence+act_time of this strip - don't consider if 0 influence */
443                 nlastrip_evaluate_fcurves(astrip, ctime);
444                 
445                 if (astrip->influence <= 0.0f) 
446                         return;
447         }
448         
449         
450         /* allocate new eval-strip for this strip + add to stack */
451         nes= MEM_callocN(sizeof(NlaEvalStrip), "bNlaEvalStrip");
452         
453         nes->track= nlt;
454         nes->strip= astrip;
455         nes->sblend= bstrip;
456         nes->track_index= index;
457         nes->strip_mode= side;
458         
459         BLI_addtail(list, nes);
460 }
461
462 /* ---------------------- */
463
464 /* evaluates the given evaluation strip */
465 // FIXME: will we need the evaluation cache table set up to blend stuff in?
466 // TODO: only evaluate here, but flush in one go using the accumulated channels at end...
467 static void nlastrip_ctime_evaluate (ListBase *channels, NlaEvalStrip *nes, float ctime)
468 {
469         // 1. (in old code) was to extract 'IPO-channels' from actions
470         // 2. blend between the 'accumulated' data, and the new data
471 }
472
473 /* write the accumulated settings to */
474 static void nladata_flush_channels (PointerRNA *ptr, ListBase *channels)
475 {
476
477 }
478
479 /* ---------------------- */
480
481 /* NLA Evaluation function (mostly for use through do_animdata) 
482  *      - All channels that will be affected are not cleared anymore. Instead, we just evaluate into 
483  *              some temp channels, where values can be accumulated in one go.
484  */
485 static void animsys_evaluate_nla (PointerRNA *ptr, AnimData *adt, float ctime)
486 {
487         NlaTrack *nlt;
488         short track_index=0;
489         
490         ListBase estrips= {NULL, NULL};
491         ListBase echannels= {NULL, NULL};
492         NlaEvalStrip *nes;
493         
494         /* 1. get the stack of strips to evaluate at current time (influence calculated here) */
495         for (nlt=adt->nla_tracks.first; nlt; nlt=nlt->next, track_index++) 
496                 nlatrack_ctime_get_strip(&estrips, nlt, track_index, ctime);
497         
498         /* only continue if there are strips to evaluate */
499         if (estrips.first == NULL)
500                 return;
501         
502         
503         /* 2. for each strip, evaluate then accumulate on top of existing channels, but don't set values yet */
504         for (nes= estrips.first; nes; nes= nes->next) 
505                 nlastrip_ctime_evaluate(&echannels, nes, ctime);
506         
507         /* 3. flush effects of accumulating channels in NLA to the actual data they affect */
508         nladata_flush_channels(ptr, &echannels);
509         
510         /* 4. free temporary evaluation data */
511         BLI_freelistN(&estrips);
512         BLI_freelistN(&echannels);
513 }
514
515 /* ***************************************** */ 
516 /* Overrides System - Public API */
517
518 /* Clear all overides */
519
520 /* Add or get existing Override for given setting */
521 AnimOverride *BKE_animsys_validate_override (PointerRNA *ptr, char *path, int array_index)
522 {
523         // FIXME: need to define how to get overrides
524         return NULL;
525
526
527 /* -------------------- */
528
529 /* Evaluate Overrides */
530 static void animsys_evaluate_overrides (PointerRNA *ptr, AnimData *adt, float ctime)
531 {
532         AnimOverride *aor;
533         
534         /* for each override, simply execute... */
535         for (aor= adt->overrides.first; aor; aor= aor->next)
536                 animsys_write_rna_setting(ptr, aor->rna_path, aor->array_index, aor->value);
537 }
538
539 /* ***************************************** */
540 /* Evaluation System - Public API */
541
542 /* Overview of how this system works:
543  *      1) Depsgraph sorts data as necessary, so that data is in an order that means 
544  *              that all dependences are resolved before dependants.
545  *      2) All normal animation is evaluated, so that drivers have some basis values to
546  *              work with
547  *              a.      NLA stacks are done first, as the Active Actions act as 'tweaking' tracks
548  *                      which modify the effects of the NLA-stacks
549  *              b.      Active Action is evaluated as per normal, on top of the results of the NLA tracks
550  *
551  * --------------< often in a separate phase... >------------------ 
552  *
553  *      3) Drivers/expressions are evaluated on top of this, in an order where dependences are
554  *              resolved nicely. 
555  *         Note: it may be necessary to have some tools to handle the cases where some higher-level
556  *              drivers are added and cause some problematic dependencies that didn't exist in the local levels...
557  *
558  * --------------< always executed >------------------ 
559  *
560  * Maintainance of editability of settings (XXX):
561  *      In order to ensure that settings that are animated can still be manipulated in the UI without requiring
562  *      that keyframes are added to prevent these values from being overwritten, we use 'overrides'. 
563  *
564  * Unresolved things:
565  *      - Handling of multi-user settings (i.e. time-offset, group-instancing) -> big cache grids or nodal system? but stored where?
566  *      - Multiple-block dependencies (i.e. drivers for settings are in both local and higher levels) -> split into separate lists?  
567  */
568
569 /* Evaluation loop for evaluation animation data 
570  *
571  * This assumes that the animation-data provided belongs to the ID block in question,
572  * and that the flags for which parts of the anim-data settings need to be recalculated 
573  * have been set already by the depsgraph. Now, we use the recalc 
574  */
575 void BKE_animsys_evaluate_animdata (ID *id, AnimData *adt, float ctime, short recalc)
576 {
577         PointerRNA id_ptr;
578         
579         /* sanity checks */
580         if ELEM(NULL, id, adt)
581                 return;
582         
583         /* get pointer to ID-block for RNA to use */
584         RNA_id_pointer_create(id, &id_ptr);
585         
586         /* recalculate keyframe data:
587          *      - NLA before Active Action, as Active Action behaves as 'tweaking track'
588          *        that overrides 'rough' work in NLA
589          */
590         if ((recalc & ADT_RECALC_ANIM) /*|| (adt->recalc & ADT_RECALC_ANIM)*/) // XXX for now,don't check yet, as depsgraph doesn't know this yet
591         {
592                 /* evaluate NLA data */
593                 if ((adt->nla_tracks.first) && !(adt->flag & ADT_NLA_EVAL_OFF))
594                 {
595                         animsys_evaluate_nla(&id_ptr, adt, ctime);
596                 }
597                 
598                 /* evaluate Action data */
599                 // FIXME: what if the solo track was not tweaking one, then nla-solo should be checked too?
600                 if (adt->action) 
601                         animsys_evaluate_action(&id_ptr, adt->action, adt->remap, ctime);
602         }
603         
604         /* recalculate drivers 
605          *      - Drivers need to be evaluated afterwards, as they can either override 
606          *        or be layered on top of existing animation data.
607          *      - Drivers should be in the appropriate order to be evaluated without problems...
608          */
609         if ((recalc & ADT_RECALC_DRIVERS) /*&& (adt->recalc & ADT_RECALC_DRIVERS)*/) // XXX for now, don't check yet, as depsgraph hasn't been updated
610         {
611                 animsys_evaluate_drivers(&id_ptr, adt, ctime);
612         }
613         
614         /* always execute 'overrides' 
615          *      - Overrides allow editing, by overwriting the value(s) set from animation-data, with the
616          *        value last set by the user (and not keyframed yet). 
617          *      - Overrides are cleared upon frame change and/or keyframing
618          *      - It is best that we execute this everytime, so that no errors are likely to occur.
619          */
620         animsys_evaluate_overrides(&id_ptr, adt, ctime);
621         
622         /* clear recalc flag now */
623         adt->recalc= 0;
624 }
625
626 /* Evaluation of all ID-blocks with Animation Data blocks - Animation Data Only
627  *
628  * This will evaluate only the animation info available in the animation data-blocks
629  * encountered. In order to enforce the system by which some settings controlled by a
630  * 'local' (i.e. belonging in the nearest ID-block that setting is related to, not a
631  * standard 'root') block are overridden by a larger 'user'
632  */
633 // TODO: we currently go over entire 'main' database...
634 void BKE_animsys_evaluate_all_animation (Main *main, float ctime)
635 {
636         ID *id;
637         
638         if (G.f & G_DEBUG)
639                 printf("Evaluate all animation - %f \n", ctime);
640
641         /* macro for less typing */
642 #define EVAL_ANIM_IDS(first) \
643         for (id= first; id; id= id->next) { \
644                 AnimData *adt= BKE_animdata_from_id(id); \
645                 BKE_animsys_evaluate_animdata(id, adt, ctime, ADT_RECALC_ANIM); \
646         }
647         
648         /* nodes */
649         // TODO...
650         
651         /* textures */
652         EVAL_ANIM_IDS(main->tex.first);
653         
654         /* lamps */
655         EVAL_ANIM_IDS(main->lamp.first);
656         
657         /* materials */
658         EVAL_ANIM_IDS(main->mat.first);
659         
660         /* cameras */
661         EVAL_ANIM_IDS(main->camera.first);
662         
663         /* shapekeys */
664         EVAL_ANIM_IDS(main->key.first);
665         
666         /* curves */
667         // TODO...
668         
669         /* meshes */
670         // TODO...
671         
672         /* objects */
673         EVAL_ANIM_IDS(main->object.first);
674         
675         /* worlds */
676         EVAL_ANIM_IDS(main->world.first);
677         
678         /* scenes */
679         EVAL_ANIM_IDS(main->scene.first);
680 }
681
682 /* ***************************************** */