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