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