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