NLA-SoC: Merge from 2.5 branch 19863:20113
[blender-staging.git] / source / blender / makesdna / DNA_anim_types.h
1 /* Testing code for new animation system in 2.5 
2  * Copyright 2009, Joshua Leung
3  */
4
5 #ifndef DNA_ANIM_TYPES_H
6 #define DNA_ANIM_TYPES_H
7
8 #ifdef __cplusplus
9 extern "C" {
10 #endif
11
12 #include "DNA_ID.h"
13 #include "DNA_listBase.h"
14 #include "DNA_action_types.h"
15 #include "DNA_curve_types.h"
16
17 /* ************************************************ */
18 /* F-Curve DataTypes */
19
20 /* Modifiers -------------------------------------- */
21
22 /* F-Curve Modifiers (fcm) 
23  *
24  * These alter the way F-Curves behave, by altering the value that is returned
25  * when evaluating the curve's data at some time (t). 
26  */
27 typedef struct FModifier {
28         struct FModifier *next, *prev;
29         
30         void *data;                     /* pointer to modifier data */
31         void *edata;            /* pointer to temporary data used during evaluation */
32         
33         char name[64];          /* user-defined description for the modifier */
34         short type;                     /* type of f-curve modifier */
35         short flag;                     /* settings for the modifier */
36         
37         float influence;        /* the amount that the modifier should influence the value */
38 } FModifier;
39
40 /* Types of F-Curve modifier 
41  * WARNING: order here is important!
42  */
43 enum {
44         FMODIFIER_TYPE_NULL = 0,
45         FMODIFIER_TYPE_GENERATOR,
46         FMODIFIER_TYPE_ENVELOPE,
47         FMODIFIER_TYPE_CYCLES,
48         FMODIFIER_TYPE_NOISE,           /* unimplemented - generate variations using some basic noise generator... */
49         FMODIFIER_TYPE_FILTER,          /* unimplemented - for applying: fft, high/low pass filters, etc. */
50         FMODIFIER_TYPE_PYTHON,  
51         FMODIFIER_TYPE_LIMITS,
52         
53         /* NOTE: all new modifiers must be added above this line */
54         FMODIFIER_NUM_TYPES
55 } eFModifier_Types;
56
57 /* F-Curve Modifier Settings */
58 enum {
59                 /* modifier is not able to be evaluated for some reason, and should be skipped (internal) */
60         FMODIFIER_FLAG_DISABLED         = (1<<0),
61                 /* modifier's data is expanded (in UI) */
62         FMODIFIER_FLAG_EXPANDED         = (1<<1),
63                 /* modifier is active one (in UI) for editing purposes */
64         FMODIFIER_FLAG_ACTIVE           = (1<<2),
65                 /* user wants modifier to be skipped */
66         FMODIFIER_FLAG_MUTED            = (1<<3),
67 } eFModifier_Flags; 
68
69 /* --- */
70
71 /* generator modifier data */
72 typedef struct FMod_Generator {
73                 /* generator based on PyExpression */
74         char expression[256];           /* python expression to use as generator */
75         
76                 /* general generator information */
77         float *coefficients;            /* coefficients array */
78         unsigned int arraysize;         /* size of the coefficients array */
79         
80         short poly_order;                       /* order of polynomial generated (i.e. 1 for linear, 2 for quadratic) */
81         short func_type;                        /* builtin math function eFMod_Generator_Functions */
82         
83         int pad;
84         
85                 /* settings */
86         short flag;                                     /* settings */
87         short mode;                                     /* which 'generator' to use eFMod_Generator_Modes */
88 } FMod_Generator;
89
90 /* generator modes */
91 enum {
92         FCM_GENERATOR_POLYNOMIAL        = 0,
93         FCM_GENERATOR_POLYNOMIAL_FACTORISED,
94         FCM_GENERATOR_FUNCTION,
95         FCM_GENERATOR_EXPRESSION,
96 } eFMod_Generator_Modes;
97
98 /* generator flags */
99 enum {
100                 /* generator works in conjunction with other modifiers (i.e. doesn't replace those before it) */
101         FCM_GENERATOR_ADDITIVE  = (1<<0),
102 } eFMod_Generator_Flags;
103
104 /* 'function' generator types */
105 enum {
106         FCM_GENERATOR_FN_SIN    = 0,
107         FCM_GENERATOR_FN_COS,
108         FCM_GENERATOR_FN_TAN,
109         FCM_GENERATOR_FN_SQRT,
110         FCM_GENERATOR_FN_LN,
111 } eFMod_Generator_Functions;
112
113
114 /* envelope modifier - envelope data */
115 typedef struct FCM_EnvelopeData {
116         float min, max;                         /* min/max values for envelope at this point (absolute values)  */
117         float time;                                     /* time for that this sample-point occurs */
118         
119         short f1;                                       /* settings for 'min' control point */
120         short f2;                                       /* settings for 'max' control point */
121 } FCM_EnvelopeData;
122
123 /* envelope-like adjustment to values (for fade in/out) */
124 typedef struct FMod_Envelope {
125         FCM_EnvelopeData *data;         /* data-points defining envelope to apply (array)  */
126         int totvert;                            /* number of envelope points */
127         
128         float midval;                           /* value that envelope's influence is centered around / based on */
129         float min, max;                         /* distances from 'middle-value' for 1:1 envelope influence */
130 } FMod_Envelope;
131
132
133 /* cycling/repetition modifier data */
134 // TODO: we can only do complete cycles...
135 typedef struct FMod_Cycles {
136         short   before_mode;            /* extrapolation mode to use before first keyframe */
137         short   after_mode;                     /* extrapolation mode to use after last keyframe */
138         short   before_cycles;          /* number of 'cycles' before first keyframe to do */
139         short   after_cycles;           /* number of 'cycles' after last keyframe to do */
140 } FMod_Cycles;
141
142 /* cycling modes */
143 enum {
144         FCM_EXTRAPOLATE_NONE = 0,                       /* don't do anything */
145         FCM_EXTRAPOLATE_CYCLIC,                         /* repeat keyframe range as-is */
146         FCM_EXTRAPOLATE_CYCLIC_OFFSET,          /* repeat keyframe range, but with offset based on gradient between values */
147         FCM_EXTRAPOLATE_MIRROR,                         /* alternate between forward and reverse playback of keyframe range */
148 } eFMod_Cycling_Modes;
149
150
151 /* Python-script modifier data */
152 typedef struct FMod_Python {
153         struct Text *script;            /* text buffer containing script to execute */
154         IDProperty *prop;                       /* ID-properties to provide 'custom' settings */
155 } FMod_Python;
156
157
158 /* limits modifier data */
159 typedef struct FMod_Limits {
160         rctf rect;                                      /* rect defining the min/max values */
161         int flag;                                       /* settings for limiting */
162         int pad;
163 } FMod_Limits;
164
165 /* limiting flags */
166 enum {
167         FCM_LIMIT_XMIN          = (1<<0),
168         FCM_LIMIT_XMAX          = (1<<1),
169         FCM_LIMIT_YMIN          = (1<<2),
170         FCM_LIMIT_YMAX          = (1<<3),
171 } eFMod_Limit_Flags;
172
173 /* noise modifier data */
174 typedef struct FMod_Noise {
175         float size;
176         float strength;
177         float phase;
178         float pad;
179
180         short depth;
181         short modification;
182
183 } FMod_Noise;
184         
185 /* modification modes */
186 enum {
187         FCM_NOISE_MODIF_REPLACE = 0,    /* Modify existing curve, matching it's shape */
188         FCM_NOISE_MODIF_ADD,                    /* Add noise to the curve */
189         FCM_NOISE_MODIF_SUBTRACT,               /* Subtract noise from the curve */
190         FCM_NOISE_MODIF_MULTIPLY,               /* Multiply the curve by noise */
191 } eFMod_Noise_Modifications;
192
193 /* Drivers -------------------------------------- */
194
195 /* Driver Target 
196  *
197  * A 'variable' for use as a target of the driver/expression.
198  * Defines a way of accessing some channel to use, that can be
199  * referred to in the expression as a variable, thus simplifying
200  * expressions and also Depsgraph building.
201  */
202 typedef struct DriverTarget {
203         struct DriverTarget *next, *prev;
204         
205         ID      *id;                    /* ID-block which owns the target */
206         char *rna_path;         /* target channel to use as driver value */
207         int array_index;        /* if applicable, the index of the RNA-array item to use as driver */
208         
209         int flags;                      /* flags for the validity of the target */
210         
211         char name[64];          /* name of the variable */
212 } DriverTarget;
213
214 /* Channel Driver (i.e. Drivers / Expressions) (driver)
215  *
216  * Channel Drivers are part of the dependency system, and are executed in addition to 
217  * normal user-defined animation. They take the animation result of some channel(s), and
218  * use that (optionally combined with its own F-Curve for modification of results) to define
219  * the value of some setting semi-procedurally.
220  *
221  * Drivers are stored as part of F-Curve data, so that the F-Curve's RNA-path settings (for storing
222  * what setting the driver will affect). The order in which they are stored defines the order that they're
223  * evaluated in. This order is set by the Depsgraph's sorting stuff. 
224  */
225 typedef struct ChannelDriver {
226         ListBase targets;       /* targets for this driver (i.e. list of DriverTarget) */
227         
228         /* python expression to execute (may call functions defined in an accessory file) 
229          * which relates the target 'variables' in some way to yield a single usable value
230          */
231         char expression[256]; 
232         
233         float curval;           /* result of previous evaluation, for subtraction from result under certain circumstances */
234         float influence;        /* influence of driver on result */ // XXX to be implemented... this is like the constraint influence setting
235         
236                 /* general settings */
237         int type;                       /* type of driver */
238         int flag;                       /* settings of driver */
239 } ChannelDriver;
240
241 /* driver type */
242 enum {
243                 /* target values are averaged together */
244         DRIVER_TYPE_AVERAGE     = 0,
245                 /* python expression/function relates targets */
246         DRIVER_TYPE_PYTHON,
247                 /* rotational difference (must use rotation channels only) */
248         DRIVER_TYPE_ROTDIFF,
249 } eDriver_Types;
250
251 /* driver flags */
252 enum {
253                 /* driver has invalid settings (internal flag)  */
254         DRIVER_FLAG_INVALID             = (1<<0),
255                 /* driver needs recalculation (set by depsgraph) */
256         DRIVER_FLAG_RECALC              = (1<<1),
257                 /* driver does replace value, but overrides (for layering of animation over driver) */
258                 // TODO: this needs to be implemented at some stage or left out...
259         DRIVER_FLAG_LAYERING    = (1<<2),
260 } eDriver_Flags;
261
262 /* F-Curves -------------------------------------- */
263
264 /* FPoint (fpt)
265  *
266  * This is the bare-minimum data required storing motion samples. Should be more efficient
267  * than using BPoints, which contain a lot of other unnecessary data...
268  */
269 typedef struct FPoint {
270         float vec[2];           /* time + value */
271         int flag;                       /* selection info */
272         int pad;
273 } FPoint;
274
275 /* 'Function-Curve' - defines values over time for a given setting (fcu) */
276 typedef struct FCurve {
277         struct FCurve *next, *prev;
278         
279                 /* group */
280         bActionGroup *grp;              /* group that F-Curve belongs to */
281         
282                 /* driver settings */
283         ChannelDriver *driver;  /* only valid for drivers (i.e. stored in AnimData not Actions) */
284                 /* evaluation settings */
285         ListBase modifiers;             /* FCurve Modifiers */
286                 
287                 /* motion data */
288         BezTriple *bezt;                /* user-editable keyframes (array) */
289         FPoint *fpt;                    /* 'baked/imported' motion samples (array) */
290         unsigned int totvert;   /* total number of points which define the curve (i.e. size of arrays in FPoints) */
291         
292                 /* value cache + settings */
293         float curval;                   /* value stored from last time curve was evaluated */
294         short flag;                             /* user-editable settings for this curve */
295         short extend;                   /* value-extending mode for this curve (does not cover  */
296         
297                 /* RNA - data link */
298         int array_index;                /* if applicable, the index of the RNA-array item to get */
299         char *rna_path;                 /* RNA-path to resolve data-access */
300         
301                 /* curve coloring (for editor) */
302         int color_mode;                 /* coloring method to use */
303         float color[3];                 /* the last-color this curve took */
304 } FCurve;
305
306
307 /* user-editable flags/settings */
308 enum {
309                 /* curve/keyframes are visible in editor */
310         FCURVE_VISIBLE          = (1<<0),
311                 /* curve is selected for editing  */
312         FCURVE_SELECTED         = (1<<1),
313                 /* curve is active one */
314         FCURVE_ACTIVE           = (1<<2),
315                 /* keyframes (beztriples) cannot be edited */
316         FCURVE_PROTECTED        = (1<<3),
317                 /* fcurve will not be evaluated for the next round */
318         FCURVE_MUTED            = (1<<4),
319                 /* fcurve uses 'auto-handles', which stay horizontal... */
320         FCURVE_AUTO_HANDLES     = (1<<5),
321         
322                 /* skip evaluation, as RNA-path cannot be resolved (similar to muting, but cannot be set by user) */
323         FCURVE_DISABLED                 = (1<<10),
324                 /* curve can only have whole-number values (int or boolean types) */
325         FCURVE_INT_VALUES               = (1<<11),
326 } eFCurve_Flags;
327
328 /* extrapolation modes (only simple value 'extending') */
329 enum {
330         FCURVE_EXTRAPOLATE_CONSTANT     = 0,    /* just extend min/max keyframe value  */
331         FCURVE_EXTRAPOLATE_LINEAR,                      /* just extend gradient of segment between first segment keyframes */
332 } eFCurve_Extend;
333
334 /* curve coloring modes */
335 enum {
336         FCURVE_COLOR_AUTO_RAINBOW = 0,          /* automatically determine color using rainbow (calculated at drawtime) */
337         FCURVE_COLOR_AUTO_RGB,                          /* automatically determine color using XYZ (array index) <-> RGB */
338         FCURVE_COLOR_CUSTOM,                            /* custom color */
339 } eFCurve_Coloring;
340
341 /* ************************************************ */
342 /* 'Action' Datatypes */
343
344 /* NOTE: Although these are part of the Animation System,
345  * they are not stored here... see DNA_action_types.h instead
346  */
347
348  
349 /* ************************************************ */
350 /* Animation Reuse - i.e. users of Actions */
351
352 /* Retargetting ----------------------------------- */
353
354 /* Retargetting Pair
355  *
356  * Defines what parts of the paths should be remapped from 'abc' to 'xyz'.
357  * TODO:
358  *      - Regrex (possibly provided through PY, though having our own module might be faster)
359  *        would be important to have at some point. Current replacements are just simple
360  *        string matches...
361  */
362 typedef struct AnimMapPair {
363         char from[128];         /* part of path to bed replaced */
364         char to[128];           /* part of path to replace with */
365 } AnimMapPair;
366
367 /* Retargetting Information for Actions 
368  *
369  * This should only be used if it is strictly necessary (i.e. user will need to explictly 
370  * add this when they find that some channels do not match, or motion is not going to right 
371  * places). When executing an action, this will be checked to see if it provides any useful
372  * remaps for the given paths.
373  *
374  * NOTE: we currently don't store this in the Action itself, as that causes too many problems.
375  */
376 // FIXME: will this be too clumsy or slow? If we're using RNA paths anyway, we'll have to accept
377 // such consequences...
378 typedef struct AnimMapper {
379         struct AnimMapper *next, *prev;
380         
381         bAction *target;                /* target action */
382         ListBase mappings;              /* remapping table (bAnimMapPair) */
383 } AnimMapper;
384
385 /* ************************************************ */
386 /* NLA - Non-Linear Animation */
387
388 /* NLA Strips ------------------------------------- */
389
390 /* NLA Strip (strip)
391  *
392  * A NLA Strip is a container for the reuse of Action data, defining parameters
393  * to control the remapping of the Action data to some destination. 
394  */
395 typedef struct NlaStrip {
396         struct NlaStrip *next, *prev;
397         
398         bAction *act;                           /* Action that is referenced by this strip */
399         AnimMapper *remap;                      /* Remapping info this strip (for tweaking correspondance of action with context) */
400         
401         ListBase fcurves;                       /* F-Curves for controlling this strip's influence and timing */        // TODO: move out?
402         ListBase modifiers;                     /* F-Curve modifiers to be applied to the entire strip's referenced F-Curves */
403         float influence;                        /* Influence of strip */
404         float strip_time;                       /* Current 'time' within action being used (automatically evaluated, but can be overridden) */
405         
406         float start, end;                       /* extents of the strip */
407         float actstart, actend;         /* range of the action to use */
408         
409         float repeat;                           /* The number of times to repeat the action range (only when no F-Curves) */
410         float scale;                            /* The amount the action range is scaled by (only when no F-Curves) */
411         
412         float blendin, blendout;        /* strip blending length (only used when there are no F-Curves) */      
413         short blendmode;                        /* strip blending mode (layer-based mixing) */
414         short extendmode;                       /* strip extrapolation mode (time-based mixing) */
415         
416         short flag;                                     /* settings */
417         short type;                                     /* type of NLA strip */
418 } NlaStrip;
419
420 /* NLA Strip Blending Mode */
421 enum {
422         NLASTRIP_MODE_BLEND = 0,
423         NLASTRIP_MODE_ADD,
424         NLASTRIP_MODE_SUBTRACT,
425         NLASTRIP_MODE_MULTIPLY,
426 } eNlaStrip_Blend_Mode;
427
428 /* NLA Strip Extrpolation Mode */
429 enum {
430                 /* extend before first frame if no previous strips in track, and always hold+extend last frame */
431         NLASTRIP_EXTEND_HOLD    = 0,            
432                 /* only hold+extend last frame */
433         NLASTRIP_EXTEND_HOLD_FORWARD,   
434                 /* don't contribute at all */
435         NLASTRIP_EXTEND_NOTHING,
436 } eNlaStrip_Extrapolate_Mode;
437
438 /* NLA Strip Settings */
439 enum {
440         /* UI selection flags */
441                 /* NLA strip is the active one in the track (also indicates if strip is being tweaked) */
442         NLASTRIP_FLAG_ACTIVE            = (1<<0),       
443                 /* NLA strip is selected for editing */
444         NLASTRIP_FLAG_SELECT            = (1<<1),
445 //      NLASTRIP_FLAG_SELECT_L          = (1<<2),       // left handle selected
446 //      NLASTRIP_FLAG_SELECT_R          = (1<<3),       // right handle selected
447         
448         /* controls driven by local F-Curves */
449                 /* strip influence is controlled by local F-Curve */
450         NLASTRIP_FLAG_USR_INFLUENCE     = (1<<5),
451         NLASTRIP_FLAG_USR_TIME          = (1<<6),
452         
453         /* playback flags (may be overriden by F-Curves) */
454                 /* NLA strip blendin/out values are set automatically based on overlaps */
455         NLASTRIP_FLAG_AUTO_BLENDS       = (1<<10),
456                 /* NLA strip is played back in reverse order */
457         NLASTRIP_FLAG_REVERSE           = (1<<11),
458                 /* NLA strip is muted (i.e. doesn't contribute in any way) */
459                 // TODO: this overlaps a lot with the functionality in track
460         NLASTRIP_FLAG_MUTED                     = (1<<12),
461 } eNlaStrip_Flag;
462
463 /* NLA Strip Type */
464 enum {  
465                 /* 'clip' - references an Action */
466         NLASTRIP_TYPE_CLIP      = 0,
467                 /* 'transition' - blends between the adjacent strips */
468         NLASTRIP_TYPE_TRANSITION,
469 } eNlaStrip_Type;
470
471 /* NLA Tracks ------------------------------------- */
472
473 /* NLA Track (nlt)
474  *
475  * A track groups a bunch of 'strips', which should form a continous set of 
476  * motion, on top of which other such groups can be layered. This should allow
477  * for animators to work in a non-destructive manner, layering tweaks, etc. over
478  * 'rough' blocks of their work.
479  */
480 typedef struct NlaTrack {
481         struct NlaTrack *next, *prev;
482         
483         ListBase strips;                /* bActionStrips in this track */
484         
485         int flag;                               /* settings for this track */
486         int index;                              /* index of the track in the stack (NOTE: not really useful, but we need a pad var anyways!) */
487         
488         char name[64];                  /* short user-description of this track */
489 } NlaTrack;
490
491 /* settings for track */
492 enum {
493                 /* track is the one that settings can be modified on, also indicates if track is being 'tweaked' */
494         NLATRACK_ACTIVE         = (1<<0),
495                 /* track is selected in UI for relevant editing operations */
496         NLATRACK_SELECTED       = (1<<1),
497                 /* track is not evaluated */
498         NLATRACK_MUTED          = (1<<2),
499                 /* track is the only one evaluated (must be used in conjunction with adt->flag) */
500         NLATRACK_SOLO           = (1<<3),
501                 /* track's settings (and strips) cannot be edited (to guard against unwanted changes) */
502         NLATRACK_PROTECTED      = (1<<4),
503 } eNlaTrack_Flag;
504
505
506 /* ************************************ */
507 /* KeyingSet Datatypes */
508
509 /* Path for use in KeyingSet definitions (ksp) 
510  *
511  * Paths may be either specific (specifying the exact sub-ID
512  * dynamic data-block - such as PoseChannels - to act upon, ala
513  * Maya's 'Character Sets' and XSI's 'Marking Sets'), or they may
514  * be generic (using various placeholder template tags that will be
515  * replaced with appropriate information from the context). 
516  */
517 typedef struct KS_Path {
518         struct KS_Path *next, *prev;
519         
520                 /* absolute paths only */
521         ID *id;                                 /* ID block that keyframes are for */
522         char group[64];                 /* name of the group to add to */
523         
524                 /* relative paths only */
525         int idtype;                             /* ID-type that path can be used on */
526         int templates;                  /* Templates that will be encountered in the path (as set of bitflags) */
527         
528                 /* all paths */
529         char *rna_path;                 /* dynamically (or statically in the case of predefined sets) path */
530         int array_index;                /* index that path affects */
531         
532         short flag;                             /* various settings, etc. */
533         short groupmode;                /* group naming (eKSP_Grouping) */
534 } KS_Path;
535
536 /* KS_Path->flag */
537 enum {
538                 /* entire array (not just the specified index) gets keyframed */
539         KSP_FLAG_WHOLE_ARRAY    = (1<<0),
540 } eKSP_Settings;
541
542 /* KS_Path->groupmode */
543 enum {
544                 /* path should be grouped using group name stored in path */
545         KSP_GROUP_NAMED = 0,
546                 /* path should not be grouped at all */
547         KSP_GROUP_NONE,
548                 /* path should be grouped using KeyingSet's name */
549         KSP_GROUP_KSNAME,
550                 /* path should be grouped using name of inner-most context item from templates 
551                  *      - this is most useful for relative KeyingSets only
552                  */
553         KSP_GROUP_TEMPLATE_ITEM,
554 } eKSP_Grouping;
555
556 /* KS_Path->templates  (Template Flags)
557  *
558  * Templates in paths are used to substitute information from the 
559  * active context into relavent places in the path strings. This
560  * enum here defines the flags which define which templates are
561  * required by a path before it can be used
562  */
563 enum {
564         KSP_TEMPLATE_OBJECT                     = (1<<0),       /* #obj - selected object */
565         KSP_TEMPLATE_PCHAN                      = (1<<1),       /* #pch - selected posechannel */
566         KSP_TEMPLATE_CONSTRAINT         = (1<<2),       /* #con - active only */
567         KSP_TEMPLATE_NODE                       = (1<<3),       /* #nod - selected node */
568 } eKSP_TemplateTypes;
569
570 /* ---------------- */
571  
572 /* KeyingSet definition (ks)
573  *
574  * A KeyingSet defines a group of properties that should
575  * be keyframed together, providing a convenient way for animators
576  * to insert keyframes without resorting to Auto-Keyframing.
577  *
578  * A few 'generic' (non-absolute and dependant on templates) KeyingSets 
579  * are defined 'built-in' to facilitate easy animating for the casual
580  * animator without the need to add extra steps to the rigging process.
581  */
582 typedef struct KeyingSet {
583         struct KeyingSet *next, *prev;
584         
585         ListBase paths;                 /* (KS_Path) paths to keyframe to */
586         
587         char name[64];                  /* user-viewable name for KeyingSet (for menus, etc.) */
588         
589         int flag;                               /* settings for KeyingSet */
590         int keyingflag;                 /* settings to supply insertkey() with */
591 } KeyingSet;
592
593 /* KeyingSet settings */
594 enum {
595                 /* keyingset cannot be removed (and doesn't need to be freed) */
596         KEYINGSET_BUILTIN               = (1<<0),
597                 /* keyingset does not depend on context info (i.e. paths are absolute) */
598         KEYINGSET_ABSOLUTE              = (1<<1),
599 } eKS_Settings;
600
601 /* Flags for use by keyframe creation/deletion calls */
602 enum {
603         INSERTKEY_NEEDED        = (1<<0),       /* only insert keyframes where they're needed */
604         INSERTKEY_MATRIX        = (1<<1),       /* insert 'visual' keyframes where possible/needed */
605         INSERTKEY_FAST          = (1<<2),       /* don't recalculate handles,etc. after adding key */
606         INSERTKEY_FASTR         = (1<<3),       /* don't realloc mem (or increase count, as array has already been set out) */
607         INSERTKEY_REPLACE       = (1<<4),       /* only replace an existing keyframe (this overrides INSERTKEY_NEEDED) */
608 } eInsertKeyFlags;
609
610 /* ************************************************ */
611 /* Animation Data */
612
613 /* AnimOverride ------------------------------------- */
614
615 /* Animation Override (aor) 
616  *
617  * This is used to as temporary storage of values which have been changed by the user, but not
618  * yet keyframed (thus, would get overwritten by the animation system before the user had a chance
619  * to see the changes that were made). 
620  *
621  * It is probably not needed for overriding keyframed values in most cases, as those will only get evaluated
622  * on frame-change now. That situation may change in future.
623  */
624 typedef struct AnimOverride {
625         struct AnimOverride *next, *prev;
626         
627         char *rna_path;                 /* RNA-path to use to resolve data-access */
628         int array_index;                /* if applicable, the index of the RNA-array item to get */
629         
630         float value;                    /* value to override setting with */
631 } AnimOverride;
632
633 /* AnimData ------------------------------------- */
634
635 /* Animation data for some ID block (adt)
636  * 
637  * This block of data is used to provide all of the necessary animation data for a datablock.
638  * Currently, this data will not be reusable, as there shouldn't be any need to do so.
639  * 
640  * This information should be made available for most if not all ID-blocks, which should 
641  * enable all of its settings to be animatable locally. Animation from 'higher-up' ID-AnimData
642  * blocks may override local settings.
643  *
644  * This datablock should be placed immediately after the ID block where it is used, so that
645  * the code which retrieves this data can do so in an easier manner. See blenkernel/internal/anim_sys.c for details.
646  */
647 typedef struct AnimData {       
648                 /* active action - acts as the 'tweaking track' for the NLA */
649         bAction         *action;                
650                 /* remapping-info for active action - should only be used if needed 
651                  * (for 'foreign' actions that aren't working correctly) 
652                  */
653         AnimMapper      *remap;                 
654         
655                 /* nla-tracks */
656         ListBase        nla_tracks;
657         
658         /* 'drivers' for this ID-block's settings - FCurves, but are completely 
659          * separate from those for animation data 
660          */
661         ListBase        drivers;        /* standard user-created Drivers/Expressions (used as part of a rig) */
662         ListBase        overrides;      /* temp storage (AnimOverride) of values for settings that are animated (but the value hasn't been keyframed) */
663         
664                 /* settings for animation evaluation */
665         int flag;                       /* user-defined settings */
666         int recalc;                     /* depsgraph recalculation flags */             
667 } AnimData;
668
669 /* Animation Data settings (mostly for NLA) */
670 enum {
671                 /* only evaluate a single track in the NLA */
672         ADT_NLA_SOLO_TRACK              = (1<<0),
673                 /* don't use NLA */
674         ADT_NLA_EVAL_OFF                = (1<<1),
675                 /* NLA is being 'tweaked' (i.e. in EditMode) */
676         ADT_NLA_EDIT_ON                 = (1<<2),
677         
678                 /* drivers expanded in UI */
679         ADT_DRIVERS_COLLAPSED   = (1<<10),
680                 /* don't execute drivers */
681         ADT_DRIVERS_DISABLED    = (1<<11),
682 } eAnimData_Flag;
683
684 /* Animation Data recalculation settings (to be set by depsgraph) */
685 enum {
686         ADT_RECALC_DRIVERS              = (1<<0),
687         ADT_RECALC_ANIM                 = (1<<1),
688         ADT_RECALC_ALL                  = (ADT_RECALC_DRIVERS|ADT_RECALC_ANIM),
689 } eAnimData_Recalc;
690
691 /* Base Struct for Anim ------------------------------------- */
692
693 /* Used for BKE_animdata_from_id() 
694  * All ID-datablocks which have their own 'local' AnimData
695  * should have the same arrangement in their structs.
696  */
697 typedef struct IdAdtTemplate {
698         ID id;
699         AnimData *adt;
700 } IdAdtTemplate;
701
702 /* ************************************************ */
703
704 #ifdef __cplusplus
705 };
706 #endif
707
708 #endif /* DNA_ANIM_TYPES_H */