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