Merge branch 'blender2.7'
[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 /**
48  * F-Curve Modifiers (fcm)
49  *
50  * These alter the way F-Curves behave, by altering the value that is returned
51  * when evaluating the curve's data at some time (t).
52  */
53 typedef struct FModifier {
54         struct FModifier *next, *prev;
55
56         /** Containing curve, only used for updates to CYCLES. */
57         struct FCurve *curve;
58         /** Pointer to modifier data. */
59         void *data;
60
61         /** User-defined description for the modifier - MAX_ID_NAME-2. */
62         char name[64];
63         /** Type of f-curve modifier. */
64         short type;
65         /** Settings for the modifier. */
66         short flag;
67
68         /** The amount that the modifier should influence the value. */
69         float influence;
70
71         /** Start frame of restricted frame-range. */
72         float sfra;
73         /** End frame of restricted frame-range. */
74         float efra;
75         /** Number of frames from sfra before modifier takes full influence. */
76         float blendin;
77         /** Number of frames from efra before modifier fades out. */
78         float blendout;
79 } FModifier;
80
81 /**
82  * Types of F-Curve modifier
83  * WARNING: order here is important!
84  */
85 typedef enum eFModifier_Types {
86         FMODIFIER_TYPE_NULL = 0,
87         FMODIFIER_TYPE_GENERATOR = 1,
88         FMODIFIER_TYPE_FN_GENERATOR = 2,
89         FMODIFIER_TYPE_ENVELOPE = 3,
90         FMODIFIER_TYPE_CYCLES = 4,
91         FMODIFIER_TYPE_NOISE = 5,
92         /** unimplemented - for applying: fft, high/low pass filters, etc. */
93         FMODIFIER_TYPE_FILTER = 6,
94         FMODIFIER_TYPE_PYTHON = 7,
95         FMODIFIER_TYPE_LIMITS = 8,
96         FMODIFIER_TYPE_STEPPED = 9,
97
98         /* NOTE: all new modifiers must be added above this line */
99         FMODIFIER_NUM_TYPES
100 } eFModifier_Types;
101
102 /* F-Curve Modifier Settings */
103 typedef enum eFModifier_Flags {
104                 /* modifier is not able to be evaluated for some reason, and should be skipped (internal) */
105         FMODIFIER_FLAG_DISABLED          = (1<<0),
106                 /* modifier's data is expanded (in UI) */
107         FMODIFIER_FLAG_EXPANDED          = (1<<1),
108                 /* modifier is active one (in UI) for editing purposes */
109         FMODIFIER_FLAG_ACTIVE            = (1<<2),
110                 /* user wants modifier to be skipped */
111         FMODIFIER_FLAG_MUTED             = (1<<3),
112                 /* restrict range that F-Modifier can be considered over */
113         FMODIFIER_FLAG_RANGERESTRICT = (1<<4),
114                 /* use influence control */
115         FMODIFIER_FLAG_USEINFLUENCE  = (1<<5),
116 } eFModifier_Flags;
117
118 /* --- */
119
120 /* Generator modifier data */
121 typedef struct FMod_Generator {
122                 /* general generator information */
123         /** Coefficients array. */
124         float *coefficients;
125         /** Size of the coefficients array. */
126         unsigned int arraysize;
127
128         /** Order of polynomial generated (i.e. 1 for linear, 2 for quadratic). */
129         int poly_order;
130         /** Which 'generator' to use eFMod_Generator_Modes. */
131         int mode;
132
133                 /* settings */
134         /** Settings. */
135         int flag;
136 } FMod_Generator;
137
138 /* generator modes */
139 typedef enum eFMod_Generator_Modes {
140         FCM_GENERATOR_POLYNOMIAL        = 0,
141         FCM_GENERATOR_POLYNOMIAL_FACTORISED = 1,
142 } eFMod_Generator_Modes;
143
144
145 /* generator flags
146  * - shared by Generator and Function Generator
147  */
148 typedef enum eFMod_Generator_Flags {
149         /* generator works in conjunction with other modifiers (i.e. doesn't replace those before it) */
150         FCM_GENERATOR_ADDITIVE  = (1<<0),
151 } eFMod_Generator_Flags;
152
153
154 /**
155  * 'Built-In Function' Generator modifier data
156  *
157  * This uses the general equation for equations:
158  * y = amplitude * fn(phase_multiplier*x + phase_offset) + y_offset
159  *
160  * where amplitude, phase_multiplier/offset, y_offset are user-defined coefficients,
161  * x is the evaluation 'time', and 'y' is the resultant value
162  */
163 typedef struct FMod_FunctionGenerator {
164         /** Coefficients for general equation (as above). */
165         float amplitude;
166         float phase_multiplier;
167         float phase_offset;
168         float value_offset;
169
170         /* flags */
171         /** #eFMod_Generator_Functions. */
172         int type;
173         /** #eFMod_Generator_flags. */
174         int flag;
175 } FMod_FunctionGenerator;
176
177 /* 'function' generator types */
178 typedef enum eFMod_Generator_Functions {
179         FCM_GENERATOR_FN_SIN    = 0,
180         FCM_GENERATOR_FN_COS    = 1,
181         FCM_GENERATOR_FN_TAN    = 2,
182         FCM_GENERATOR_FN_SQRT   = 3,
183         FCM_GENERATOR_FN_LN     = 4,
184         FCM_GENERATOR_FN_SINC   = 5,
185 } eFMod_Generator_Functions;
186
187
188 /* envelope modifier - envelope data */
189 typedef struct FCM_EnvelopeData {
190         /** Min/max values for envelope at this point (absolute values) . */
191         float min, max;
192         /** Time for that this sample-point occurs. */
193         float time;
194
195         /** Settings for 'min' control point. */
196         short f1;
197         /** Settings for 'max' control point. */
198         short f2;
199 } FCM_EnvelopeData;
200
201 /* envelope-like adjustment to values (for fade in/out) */
202 typedef struct FMod_Envelope {
203         /** Data-points defining envelope to apply (array) . */
204         FCM_EnvelopeData *data;
205         /** Number of envelope points. */
206         int totvert;
207
208         /** Value that envelope's influence is centered around / based on. */
209         float midval;
210         /** Distances from 'middle-value' for 1:1 envelope influence. */
211         float min, max;
212 } FMod_Envelope;
213
214
215 /* cycling/repetition modifier data */
216 // TODO: we can only do complete cycles...
217 typedef struct FMod_Cycles {
218         /** Extrapolation mode to use before first keyframe. */
219         short before_mode;
220         /** Extrapolation mode to use after last keyframe. */
221         short after_mode;
222         /** Number of 'cycles' before first keyframe to do. */
223         short before_cycles;
224         /** Number of 'cycles' after last keyframe to do. */
225         short after_cycles;
226 } FMod_Cycles;
227
228 /* cycling modes */
229 typedef enum eFMod_Cycling_Modes {
230         /** don't do anything */
231         FCM_EXTRAPOLATE_NONE = 0,
232         /** repeat keyframe range as-is */
233         FCM_EXTRAPOLATE_CYCLIC,
234         /** repeat keyframe range, but with offset based on gradient between values */
235         FCM_EXTRAPOLATE_CYCLIC_OFFSET,
236         /** alternate between forward and reverse playback of keyframe range */
237         FCM_EXTRAPOLATE_MIRROR
238 } eFMod_Cycling_Modes;
239
240
241 /* Python-script modifier data */
242 typedef struct FMod_Python {
243         /** Text buffer containing script to execute. */
244         struct Text *script;
245         /** ID-properties to provide 'custom' settings. */
246         IDProperty *prop;
247 } FMod_Python;
248
249
250 /* limits modifier data */
251 typedef struct FMod_Limits {
252         /** Rect defining the min/max values. */
253         rctf rect;
254         /** Settings for limiting. */
255         int flag;
256         int pad;
257 } FMod_Limits;
258
259 /* limiting flags */
260 typedef enum eFMod_Limit_Flags {
261         FCM_LIMIT_XMIN          = (1<<0),
262         FCM_LIMIT_XMAX          = (1<<1),
263         FCM_LIMIT_YMIN          = (1<<2),
264         FCM_LIMIT_YMAX          = (1<<3),
265 } eFMod_Limit_Flags;
266
267
268 /* noise modifier data */
269 typedef struct FMod_Noise {
270         float size;
271         float strength;
272         float phase;
273         float offset;
274
275         short depth;
276         short modification;
277 } FMod_Noise;
278
279 /* modification modes */
280 typedef enum eFMod_Noise_Modifications {
281         FCM_NOISE_MODIF_REPLACE = 0,    /* Modify existing curve, matching it's shape */
282         FCM_NOISE_MODIF_ADD,                    /* Add noise to the curve */
283         FCM_NOISE_MODIF_SUBTRACT,               /* Subtract noise from the curve */
284         FCM_NOISE_MODIF_MULTIPLY                /* Multiply the curve by noise */
285 } eFMod_Noise_Modifications;
286
287
288 /* stepped modifier data */
289 typedef struct FMod_Stepped {
290         /** Number of frames each interpolated value should be held. */
291         float step_size;
292         /** Reference frame number that stepping starts from. */
293         float offset;
294
295         /** Start frame of the frame range that modifier works in. */
296         float start_frame;
297         /** End frame of the frame range that modifier works in. */
298         float end_frame;
299
300         /** Various settings. */
301         int flag;
302 } FMod_Stepped;
303
304 /* stepped modifier range flags */
305 typedef enum eFMod_Stepped_Flags {
306         FCM_STEPPED_NO_BEFORE   = (1<<0),       /* don't affect frames before the start frame */
307         FCM_STEPPED_NO_AFTER    = (1<<1),       /* don't affect frames after the end frame */
308 } eFMod_Stepped_Flags;
309
310 /* Drivers -------------------------------------- */
311
312 /* Driver Target (dtar)
313  *
314  * Defines how to access a dependency needed for a driver variable.
315  */
316 typedef struct DriverTarget {
317         /** ID-block which owns the target, no user count. */
318         ID      *id;
319
320         /** RNA path defining the setting to use (for DVAR_TYPE_SINGLE_PROP). */
321         char *rna_path;
322
323         /**
324          * Name of the posebone to use
325          * (for vars where DTAR_FLAG_STRUCT_REF is used) - MAX_ID_NAME-2.
326          */
327         char pchan_name[64];
328         /** Transform channel index (for DVAR_TYPE_TRANSFORM_CHAN.)*/
329         short transChan;
330
331         /**
332          * Flags for the validity of the target
333          * (NOTE: these get reset every time the types change).
334          */
335         short flag;
336         /** Type of ID-block that this target can use. */
337         int idtype;
338 } DriverTarget;
339
340 /* Driver Target flags */
341 typedef enum eDriverTarget_Flag {
342                 /* used for targets that use the pchan_name instead of RNA path
343                  * (i.e. rotation difference)
344                  */
345         DTAR_FLAG_STRUCT_REF    = (1 << 0),
346                 /* idtype can only be 'Object' */
347         DTAR_FLAG_ID_OB_ONLY    = (1 << 1),
348
349         /* "localspace" flags */
350                 /* base flag - basically "pre parent+constraints" */
351         DTAR_FLAG_LOCALSPACE    = (1 << 2),
352                 /* include constraints transformed to space including parents */
353         DTAR_FLAG_LOCAL_CONSTS  = (1 << 3),
354
355         /* error flags */
356         DTAR_FLAG_INVALID               = (1 << 4),
357 } eDriverTarget_Flag;
358
359 /* Transform Channels for Driver Targets */
360 typedef enum eDriverTarget_TransformChannels {
361         DTAR_TRANSCHAN_LOCX = 0,
362         DTAR_TRANSCHAN_LOCY,
363         DTAR_TRANSCHAN_LOCZ,
364         DTAR_TRANSCHAN_ROTX,
365         DTAR_TRANSCHAN_ROTY,
366         DTAR_TRANSCHAN_ROTZ,
367         DTAR_TRANSCHAN_SCALEX,
368         DTAR_TRANSCHAN_SCALEY,
369         DTAR_TRANSCHAN_SCALEZ,
370
371         MAX_DTAR_TRANSCHAN_TYPES
372 } eDriverTarget_TransformChannels;
373
374 /* --- */
375
376 /* maximum number of driver targets per variable */
377 #define MAX_DRIVER_TARGETS      8
378
379
380 /* Driver Variable (dvar)
381  *
382  * A 'variable' for use as an input for the driver evaluation.
383  * Defines a way of accessing some channel to use, that can be
384  * referred to in the expression as a variable, thus simplifying
385  * expressions and also Depsgraph building.
386  */
387 typedef struct DriverVar {
388         struct DriverVar *next, *prev;
389
390         /**
391          * Name of the variable to use in py-expression
392          * (must be valid python identifier) - MAX_ID_NAME-2.
393          */
394         char name[64];
395
396         /** MAX_DRIVER_TARGETS, target slots. */
397         DriverTarget targets[8];
398
399         /** Number of targets actually used by this variable. */
400         char num_targets;
401         /** Type of driver variable (eDriverVar_Types). */
402         char type;
403
404         /** Validation tags, etc. (eDriverVar_Flags). */
405         short flag;
406         /** Result of previous evaluation. */
407         float curval;
408 } DriverVar;
409
410 /* Driver Variable Types */
411 typedef enum eDriverVar_Types {
412                 /* single RNA property */
413         DVAR_TYPE_SINGLE_PROP   = 0,
414                 /* rotation difference (between 2 bones) */
415         DVAR_TYPE_ROT_DIFF,
416                 /* distance between objects/bones */
417         DVAR_TYPE_LOC_DIFF,
418                 /* 'final' transform for object/bones */
419         DVAR_TYPE_TRANSFORM_CHAN,
420
421         /* maximum number of variable types
422          * NOTE: this must always be th last item in this list,
423          *       so add new types above this line.
424          */
425         MAX_DVAR_TYPES
426 } eDriverVar_Types;
427
428 /* Driver Variable Flags */
429 typedef enum eDriverVar_Flags {
430         /* variable is not set up correctly */
431         DVAR_FLAG_ERROR               = (1 << 0),
432
433         /* variable name doesn't pass the validation tests */
434         DVAR_FLAG_INVALID_NAME        = (1 << 1),
435         /* name starts with a number */
436         DVAR_FLAG_INVALID_START_NUM   = (1 << 2),
437         /* name starts with a special character (!, $, @, #, _, etc.) */
438         DVAR_FLAG_INVALID_START_CHAR  = (1 << 3),
439         /* name contains a space */
440         DVAR_FLAG_INVALID_HAS_SPACE   = (1 << 4),
441         /* name contains a dot */
442         DVAR_FLAG_INVALID_HAS_DOT     = (1 << 5),
443         /* name contains invalid chars */
444         DVAR_FLAG_INVALID_HAS_SPECIAL = (1 << 6),
445         /* name is a reserved keyword */
446         DVAR_FLAG_INVALID_PY_KEYWORD  = (1 << 7),
447         /* name is zero-length */
448         DVAR_FLAG_INVALID_EMPTY       = (1 << 8),
449 } eDriverVar_Flags;
450
451 /* All invalid dvar name flags */
452 #define DVAR_ALL_INVALID_FLAGS (   \
453         DVAR_FLAG_INVALID_NAME |       \
454         DVAR_FLAG_INVALID_START_NUM | \
455         DVAR_FLAG_INVALID_START_CHAR | \
456         DVAR_FLAG_INVALID_HAS_SPACE |  \
457         DVAR_FLAG_INVALID_HAS_DOT |    \
458         DVAR_FLAG_INVALID_HAS_SPECIAL |  \
459         DVAR_FLAG_INVALID_PY_KEYWORD  | \
460         DVAR_FLAG_INVALID_EMPTY  \
461 )
462
463 /* --- */
464
465 /* Channel Driver (i.e. Drivers / Expressions) (driver)
466  *
467  * Channel Drivers are part of the dependency system, and are executed in addition to
468  * normal user-defined animation. They take the animation result of some channel(s), and
469  * use that (optionally combined with its own F-Curve for modification of results) to define
470  * the value of some setting semi-procedurally.
471  *
472  * Drivers are stored as part of F-Curve data, so that the F-Curve's RNA-path settings (for storing
473  * what setting the driver will affect). The order in which they are stored defines the order that they're
474  * evaluated in. This order is set by the Depsgraph's sorting stuff.
475  */
476 typedef struct ChannelDriver {
477         /** Targets for this driver (i.e. list of DriverVar). */
478         ListBase variables;
479
480         /* python expression to execute (may call functions defined in an accessory file)
481          * which relates the target 'variables' in some way to yield a single usable value
482          */
483         /** Expression to compile for evaluation. */
484         char expression[256];
485         /** PyObject - compiled expression, don't save this. */
486         void *expr_comp;
487
488         /** Compiled simple arithmetic expression. */
489         struct ExprPyLike_Parsed *expr_simple;
490
491         /** Result of previous evaluation. */
492         float curval;
493         // XXX to be implemented... this is like the constraint influence setting
494         /** Influence of driver on result. */
495         float influence;
496
497         /* general settings */
498         /** Type of driver. */
499         int type;
500         /** Settings of driver. */
501         int flag;
502 } ChannelDriver;
503
504 /* driver type */
505 typedef enum eDriver_Types {
506                 /* target values are averaged together */
507         DRIVER_TYPE_AVERAGE     = 0,
508                 /* python expression/function relates targets */
509         DRIVER_TYPE_PYTHON,
510                 /* sum of all values */
511         DRIVER_TYPE_SUM,
512                 /* smallest value */
513         DRIVER_TYPE_MIN,
514                 /* largest value */
515         DRIVER_TYPE_MAX
516 } eDriver_Types;
517
518 /* driver flags */
519 /* note: (1<<5) is deprecated; was "DRIVER_FLAG_SHOWDEBUG" */
520 typedef enum eDriver_Flags {
521                 /* driver has invalid settings (internal flag)  */
522         DRIVER_FLAG_INVALID             = (1<<0),
523                 /* driver needs recalculation (set by depsgraph) */
524         DRIVER_FLAG_RECALC              = (1<<1),
525                 /* driver does replace value, but overrides (for layering of animation over driver) */
526                 // TODO: this needs to be implemented at some stage or left out...
527         //DRIVER_FLAG_LAYERING  = (1<<2),
528                 /* use when the expression needs to be recompiled */
529         DRIVER_FLAG_RECOMPILE   = (1<<3),
530                 /* the names are cached so they don't need have python unicode versions created each time */
531         DRIVER_FLAG_RENAMEVAR   = (1<<4),
532                 /* include 'self' in the drivers namespace. */
533         DRIVER_FLAG_USE_SELF    = (1<<6),
534 } eDriver_Flags;
535
536 /* F-Curves -------------------------------------- */
537
538 /* FPoint (fpt)
539  *
540  * This is the bare-minimum data required storing motion samples. Should be more efficient
541  * than using BPoints, which contain a lot of other unnecessary data...
542  */
543 typedef struct FPoint {
544         /** Time + value. */
545         float vec[2];
546         /** Selection info. */
547         int flag;
548         int pad;
549 } FPoint;
550
551 /* 'Function-Curve' - defines values over time for a given setting (fcu) */
552 typedef struct FCurve {
553         struct FCurve *next, *prev;
554
555                 /* group */
556         /** Group that F-Curve belongs to. */
557         bActionGroup *grp;
558
559                 /* driver settings */
560         /** Only valid for drivers (i.e. stored in AnimData not Actions). */
561         ChannelDriver *driver;
562                 /* evaluation settings */
563         /** FCurve Modifiers. */
564         ListBase modifiers;
565
566                 /* motion data */
567         /** User-editable keyframes (array). */
568         BezTriple *bezt;
569         /** 'baked/imported' motion samples (array). */
570         FPoint *fpt;
571         /** Total number of points which define the curve (i.e. size of arrays in FPoints). */
572         unsigned int totvert;
573
574                 /* value cache + settings */
575         /** Value stored from last time curve was evaluated (not threadsafe, debug display only!). */
576         float curval;
577         /* Value which comes from original DNA ddatablock at a time f-curve was evaluated. */
578         float orig_dna_val;
579         /** User-editable settings for this curve. */
580         short flag;
581         /** Value-extending mode for this curve (does not cover). */
582         short extend;
583         /** Auto-handle smoothing mode. */
584         char auto_smoothing;
585
586         char pad[3];
587
588                 /* RNA - data link */
589         /** If applicable, the index of the RNA-array item to get. */
590         int array_index;
591         /** RNA-path to resolve data-access. */
592         char *rna_path;
593
594                 /* curve coloring (for editor) */
595         /** Coloring method to use (eFCurve_Coloring). */
596         int color_mode;
597         /** The last-color this curve took. */
598         float color[3];
599
600         float prev_norm_factor, prev_offset;
601 } FCurve;
602
603
604 /* user-editable flags/settings */
605 typedef enum eFCurve_Flags {
606         /** curve/keyframes are visible in editor */
607         FCURVE_VISIBLE          = (1<<0),
608         /** curve is selected for editing  */
609         FCURVE_SELECTED         = (1<<1),
610         /** curve is active one */
611         FCURVE_ACTIVE           = (1<<2),
612         /** keyframes (beztriples) cannot be edited */
613         FCURVE_PROTECTED        = (1<<3),
614         /** fcurve will not be evaluated for the next round */
615         FCURVE_MUTED            = (1<<4),
616
617         /** fcurve uses 'auto-handles', which stay horizontal... */
618         // DEPRECATED
619         FCURVE_AUTO_HANDLES     = (1<<5),
620         FCURVE_MOD_OFF          = (1<<6),
621         /** skip evaluation, as RNA-path cannot be resolved
622          * (similar to muting, but cannot be set by user) */
623         FCURVE_DISABLED                 = (1<<10),
624         /** curve can only have whole-number values (integer types) */
625         FCURVE_INT_VALUES               = (1<<11),
626         /** curve can only have certain discrete-number values
627          * (no interpolation at all, for enums/booleans) */
628         FCURVE_DISCRETE_VALUES  = (1<<12),
629
630         /** temporary tag for editing */
631         FCURVE_TAGGED                   = (1<<15),
632 } eFCurve_Flags;
633
634 /* extrapolation modes (only simple value 'extending') */
635 typedef enum eFCurve_Extend {
636         /** just extend min/max keyframe value  */
637         FCURVE_EXTRAPOLATE_CONSTANT     = 0,
638         /** just extend gradient of segment between first segment keyframes */
639         FCURVE_EXTRAPOLATE_LINEAR
640 } eFCurve_Extend;
641
642 /* curve coloring modes */
643 typedef enum eFCurve_Coloring {
644         /** automatically determine color using rainbow (calculated at drawtime) */
645         FCURVE_COLOR_AUTO_RAINBOW = 0,
646         /** automatically determine color using XYZ (array index) <-> RGB */
647         FCURVE_COLOR_AUTO_RGB     = 1,
648         /** automatically determine color where XYZ <-> RGB, but index(X) != 0 */
649         FCURVE_COLOR_AUTO_YRGB    = 3,
650         /** custom color */
651         FCURVE_COLOR_CUSTOM       = 2,
652 } eFCurve_Coloring;
653
654 /* curve smoothing modes */
655 typedef enum eFCurve_Smoothing {
656         /** legacy mode: auto handles only consider adjacent points */
657         FCURVE_SMOOTH_NONE             = 0,
658         /** maintain continuity of the acceleration */
659         FCURVE_SMOOTH_CONT_ACCEL       = 1,
660 } eFCurve_Smoothing;
661
662 /* ************************************************ */
663 /* 'Action' Datatypes */
664
665 /* NOTE: Although these are part of the Animation System,
666  * they are not stored here... see DNA_action_types.h instead
667  */
668
669
670 /* ************************************************ */
671 /* NLA - Non-Linear Animation */
672
673 /* NLA Strips ------------------------------------- */
674
675 /* NLA Strip (strip)
676  *
677  * A NLA Strip is a container for the reuse of Action data, defining parameters
678  * to control the remapping of the Action data to some destination.
679  */
680 typedef struct NlaStrip {
681         struct NlaStrip *next, *prev;
682
683         /** 'Child' strips (used for 'meta' strips). */
684         ListBase strips;
685         /** Action that is referenced by this strip (strip is 'user' of the action). */
686         bAction *act;
687
688         /** F-Curves for controlling this strip's influence and timing */    // TODO: move o.ut?
689         ListBase fcurves;
690         /** F-Curve modifiers to be applied to the entire strip's referenced F-Curves. */
691         ListBase modifiers;
692
693         /** User-Visible Identifier for Strip - MAX_ID_NAME-2. */
694         char name[64];
695
696         /** Influence of strip. */
697         float influence;
698         /** Current 'time' within action being used (automatically evaluated, but can be overridden). */
699         float strip_time;
700
701         /** Extents of the strip. */
702         float start, end;
703         /** Range of the action to use. */
704         float actstart, actend;
705
706         /** The number of times to repeat the action range (only when no F-Curves). */
707         float repeat;
708         /** The amount the action range is scaled by (only when no F-Curves). */
709         float scale;
710
711         /** Strip blending length (only used when there are no F-Curves). */
712         float blendin, blendout;
713         /** Strip blending mode (layer-based mixing). */
714         short blendmode;
715
716         /** Strip extrapolation mode (time-based mixing). */
717         short extendmode;
718         short pad1;
719
720         /** Type of NLA strip. */
721         short type;
722
723         /** Handle for speaker objects. */
724         void *speaker_handle;
725
726         /** Settings. */
727         int flag;
728         int pad2;
729 } NlaStrip;
730
731 /* NLA Strip Blending Mode */
732 typedef enum eNlaStrip_Blend_Mode {
733         NLASTRIP_MODE_REPLACE = 0,
734         NLASTRIP_MODE_ADD,
735         NLASTRIP_MODE_SUBTRACT,
736         NLASTRIP_MODE_MULTIPLY,
737         NLASTRIP_MODE_COMBINE,
738 } eNlaStrip_Blend_Mode;
739
740 /* NLA Strip Extrpolation Mode */
741 typedef enum eNlaStrip_Extrapolate_Mode {
742         /* extend before first frame if no previous strips in track,
743          * and always hold+extend last frame */
744         NLASTRIP_EXTEND_HOLD = 0,
745         /* only hold+extend last frame */
746         NLASTRIP_EXTEND_HOLD_FORWARD = 1,
747         /* don't contribute at all */
748         NLASTRIP_EXTEND_NOTHING = 2,
749 } eNlaStrip_Extrapolate_Mode;
750
751 /* NLA Strip Settings */
752 typedef enum eNlaStrip_Flag {
753         /* UI selection flags */
754                 /* NLA strip is the active one in the track (also indicates if strip is being tweaked) */
755         NLASTRIP_FLAG_ACTIVE        = (1<<0),
756                 /* NLA strip is selected for editing */
757         NLASTRIP_FLAG_SELECT        = (1<<1),
758 //  NLASTRIP_FLAG_SELECT_L      = (1<<2),   // left handle selected
759 //  NLASTRIP_FLAG_SELECT_R      = (1<<3),   // right handle selected
760
761         /* NLA strip uses the same action that the action being tweaked uses
762          * (not set for the twaking one though) */
763         NLASTRIP_FLAG_TWEAKUSER     = (1<<4),
764
765         /* controls driven by local F-Curves */
766                 /* strip influence is controlled by local F-Curve */
767         NLASTRIP_FLAG_USR_INFLUENCE = (1<<5),
768         NLASTRIP_FLAG_USR_TIME      = (1<<6),
769         NLASTRIP_FLAG_USR_TIME_CYCLIC = (1<<7),
770
771                 /* NLA strip length is synced to the length of the referenced action */
772         NLASTRIP_FLAG_SYNC_LENGTH   = (1<<9),
773
774         /* playback flags (may be overridden by F-Curves) */
775                 /* NLA strip blendin/out values are set automatically based on overlaps */
776         NLASTRIP_FLAG_AUTO_BLENDS   = (1<<10),
777                 /* NLA strip is played back in reverse order */
778         NLASTRIP_FLAG_REVERSE       = (1<<11),
779                 /* NLA strip is muted (i.e. doesn't contribute in any way) */
780         NLASTRIP_FLAG_MUTED         = (1<<12),
781                 /* NLA Strip is played back in 'ping-pong' style */
782         NLASTRIP_FLAG_MIRROR        = (1<<13),
783
784         /* temporary editing flags */
785                 /* NLA strip should ignore frame range and hold settings, and evaluate at global time. */
786         NLASTRIP_FLAG_NO_TIME_MAP   = (1<<29),
787                 /* NLA-Strip is really just a temporary meta used to facilitate easier transform code */
788         NLASTRIP_FLAG_TEMP_META     = (1<<30),
789         NLASTRIP_FLAG_EDIT_TOUCHED  = (1u << 31),
790 } eNlaStrip_Flag;
791
792 /* NLA Strip Type */
793 typedef enum eNlaStrip_Type {
794                 /* 'clip' - references an Action */
795         NLASTRIP_TYPE_CLIP      = 0,
796                 /* 'transition' - blends between the adjacent strips */
797         NLASTRIP_TYPE_TRANSITION,
798                 /* 'meta' - a strip which acts as a container for a few others */
799         NLASTRIP_TYPE_META,
800
801                 /* 'emit sound' - a strip which is used for timing when speaker emits sounds */
802         NLASTRIP_TYPE_SOUND
803 } eNlaStrip_Type;
804
805 /* NLA Tracks ------------------------------------- */
806
807 /* NLA Track (nlt)
808  *
809  * A track groups a bunch of 'strips', which should form a continuous set of
810  * motion, on top of which other such groups can be layered. This should allow
811  * for animators to work in a non-destructive manner, layering tweaks, etc. over
812  * 'rough' blocks of their work.
813  */
814 typedef struct NlaTrack {
815         struct NlaTrack *next, *prev;
816
817         /** BActionStrips in this track. */
818         ListBase strips;
819
820         /** Settings for this track. */
821         int flag;
822         /** Index of the track in the stack
823          * \note not really useful, but we need a pad var anyways! */
824         int index;
825
826         /** Short user-description of this track - MAX_ID_NAME-2. */
827         char name[64];
828 } NlaTrack;
829
830 /* settings for track */
831 typedef enum eNlaTrack_Flag {
832         /** track is the one that settings can be modified on,
833          * also indicates if track is being 'tweaked' */
834         NLATRACK_ACTIVE         = (1<<0),
835         /** track is selected in UI for relevant editing operations */
836         NLATRACK_SELECTED       = (1<<1),
837         /** track is not evaluated */
838         NLATRACK_MUTED          = (1<<2),
839         /** track is the only one evaluated (must be used in conjunction with adt->flag) */
840         NLATRACK_SOLO           = (1<<3),
841         /** track's settings (and strips) cannot be edited (to guard against unwanted changes) */
842         NLATRACK_PROTECTED      = (1<<4),
843
844         /** track is not allowed to execute,
845          * usually as result of tweaking being enabled (internal flag) */
846         NLATRACK_DISABLED       = (1<<10),
847 } eNlaTrack_Flag;
848
849
850 /* ************************************ */
851 /* KeyingSet Datatypes */
852
853 /* Path for use in KeyingSet definitions (ksp)
854  *
855  * Paths may be either specific (specifying the exact sub-ID
856  * dynamic data-block - such as PoseChannels - to act upon, ala
857  * Maya's 'Character Sets' and XSI's 'Marking Sets'), or they may
858  * be generic (using various placeholder template tags that will be
859  * replaced with appropriate information from the context).
860  */
861 typedef struct KS_Path {
862         struct KS_Path *next, *prev;
863
864         /** ID block that keyframes are for. */
865         ID *id;
866         /** Name of the group to add to - MAX_ID_NAME-2. */
867         char group[64];
868
869         /** ID-type that path can be used on. */
870         int idtype;
871
872         /** Group naming (eKSP_Grouping). */
873         short groupmode;
874         /** Various settings, etc. */
875         short flag;
876
877         /** Dynamically (or statically in the case of predefined sets) path. */
878         char *rna_path;
879         /** Index that path affects. */
880         int array_index;
881
882         /** (eInsertKeyFlags) settings to supply insertkey() with. */
883         short keyingflag;
884         /** (eInsertKeyFlags) for each flag set, the relevant keyingflag bit overrides the default. */
885         short keyingoverride;
886 } KS_Path;
887
888 /* KS_Path->flag */
889 typedef enum eKSP_Settings {
890                 /* entire array (not just the specified index) gets keyframed */
891         KSP_FLAG_WHOLE_ARRAY    = (1<<0),
892 } eKSP_Settings;
893
894 /* KS_Path->groupmode */
895 typedef enum eKSP_Grouping {
896                 /* path should be grouped using group name stored in path */
897         KSP_GROUP_NAMED = 0,
898                 /* path should not be grouped at all */
899         KSP_GROUP_NONE,
900                 /* path should be grouped using KeyingSet's name */
901         KSP_GROUP_KSNAME,
902                 /* path should be grouped using name of inner-most context item from templates
903                  * - this is most useful for relative KeyingSets only
904                  */
905         KSP_GROUP_TEMPLATE_ITEM
906 } eKSP_Grouping;
907
908 /* ---------------- */
909
910 /* KeyingSet definition (ks)
911  *
912  * A KeyingSet defines a group of properties that should
913  * be keyframed together, providing a convenient way for animators
914  * to insert keyframes without resorting to Auto-Keyframing.
915  *
916  * A few 'generic' (non-absolute and dependent on templates) KeyingSets
917  * are defined 'built-in' to facilitate easy animating for the casual
918  * animator without the need to add extra steps to the rigging process.
919  */
920 typedef struct KeyingSet {
921         struct KeyingSet *next, *prev;
922
923         /** (KS_Path) paths to keyframe to. */
924         ListBase paths;
925
926         /** Unique name (for search, etc.) - MAX_ID_NAME-2 . */
927         char idname[64];
928         /** User-viewable name for KeyingSet (for menus, etc.) - MAX_ID_NAME-2. */
929         char name[64];
930         /** (RNA_DYN_DESCR_MAX) short help text. */
931         char description[240];
932         /** Name of the typeinfo data used for the relative paths - MAX_ID_NAME-2. */
933         char typeinfo[64];
934
935         /** Index of the active path. */
936         int active_path;
937
938         /** Settings for KeyingSet. */
939         short flag;
940
941         /** (eInsertKeyFlags) settings to supply insertkey() with. */
942         short keyingflag;
943         /** (eInsertKeyFlags) for each flag set, the relevant keyingflag bit overrides the default. */
944         short keyingoverride;
945
946         char pad[6];
947 } KeyingSet;
948
949 /* KeyingSet settings */
950 typedef enum eKS_Settings {
951                 /* keyingset cannot be removed (and doesn't need to be freed) */
952         KEYINGSET_BUILTIN               = (1<<0),
953                 /* keyingset does not depend on context info (i.e. paths are absolute) */
954         KEYINGSET_ABSOLUTE              = (1<<1),
955 } eKS_Settings;
956
957 /* Flags for use by keyframe creation/deletion calls */
958 typedef enum eInsertKeyFlags {
959         INSERTKEY_NOFLAGS       = 0,
960         /** only insert keyframes where they're needed */
961         INSERTKEY_NEEDED        = (1<<0),
962         /** insert 'visual' keyframes where possible/needed */
963         INSERTKEY_MATRIX        = (1<<1),
964         /** don't recalculate handles,etc. after adding key */
965         INSERTKEY_FAST          = (1<<2),
966         /** don't realloc mem (or increase count, as array has already been set out) */
967         INSERTKEY_FASTR         = (1<<3),
968         /** only replace an existing keyframe (this overrides INSERTKEY_NEEDED) */
969         INSERTKEY_REPLACE       = (1<<4),
970         /** transform F-Curves should have XYZ->RGB color mode */
971         INSERTKEY_XYZ2RGB       = (1<<5),
972         /** ignore user-prefs (needed for predictable API use) */
973         INSERTKEY_NO_USERPREF   = (1<<6),
974         /** Allow to make a full copy of new key into existing one, if any,
975          * instead of 'reusing' existing handles.
976          * Used by copy/paste code. */
977         INSERTKEY_OVERWRITE_FULL = (1<<7),
978         /** for driver FCurves, use driver's "input" value - for easier corrective driver setup */
979         INSERTKEY_DRIVER         = (1<<8),
980         /** for cyclic FCurves, adjust key timing to preserve the cycle period and flow */
981         INSERTKEY_CYCLE_AWARE    = (1<<9),
982 } eInsertKeyFlags;
983
984 /* ************************************************ */
985 /* Animation Data */
986
987 /* AnimOverride ------------------------------------- */
988
989 /* Animation Override (aor)
990  *
991  * This is used to as temporary storage of values which have been changed by the user, but not
992  * yet keyframed (thus, would get overwritten by the animation system before the user had a chance
993  * to see the changes that were made).
994  *
995  * It is probably not needed for overriding keyframed values in most cases, as those will only get
996  * evaluated on frame-change now. That situation may change in future.
997  */
998 typedef struct AnimOverride {
999         struct AnimOverride *next, *prev;
1000
1001         /** RNA-path to use to resolve data-access. */
1002         char *rna_path;
1003         /** If applicable, the index of the RNA-array item to get. */
1004         int array_index;
1005
1006         /** Value to override setting with. */
1007         float value;
1008 } AnimOverride;
1009
1010 /* AnimData ------------------------------------- */
1011
1012 /* Animation data for some ID block (adt)
1013  *
1014  * This block of data is used to provide all of the necessary animation data for a datablock.
1015  * Currently, this data will not be reusable, as there shouldn't be any need to do so.
1016  *
1017  * This information should be made available for most if not all ID-blocks, which should
1018  * enable all of its settings to be animatable locally. Animation from 'higher-up' ID-AnimData
1019  * blocks may override local settings.
1020  *
1021  * This datablock should be placed immediately after the ID block where it is used, so that
1022  * the code which retrieves this data can do so in an easier manner.
1023  * See blenkernel/intern/anim_sys.c for details.
1024  */
1025 typedef struct AnimData {
1026         /** active action - acts as the 'tweaking track' for the NLA */
1027         bAction     *action;
1028         /** temp-storage for the 'real' active action (i.e. the one used before the tweaking-action
1029          * took over to be edited in the Animation Editors)
1030          */
1031         bAction     *tmpact;
1032
1033                 /* nla-tracks */
1034         ListBase    nla_tracks;
1035         /**
1036          * Active NLA-track
1037          * (only set/used during tweaking, so no need to worry about dangling pointers).
1038          */
1039         NlaTrack        *act_track;
1040         /**
1041          * Active NLA-strip
1042          * (only set/used during tweaking, so no need to worry about dangling pointers).
1043          */
1044         NlaStrip    *actstrip;
1045
1046         /* 'drivers' for this ID-block's settings - FCurves, but are completely
1047          * separate from those for animation data
1048          */
1049         /** Standard user-created Drivers/Expressions (used as part of a rig). */
1050         ListBase    drivers;
1051         /** Temp storage (AnimOverride) of values for settings that are animated
1052          * (but the value hasn't been keyframed). */
1053         ListBase    overrides;
1054
1055         /** Runtime data, for depsgraph evaluation. */
1056         FCurve **driver_array;
1057
1058                 /* settings for animation evaluation */
1059         /** User-defined settings. */
1060         int flag;
1061         /** Depsgraph recalculation flags. */
1062         int recalc;
1063
1064                 /* settings for active action evaluation (based on NLA strip settings) */
1065         /** Accumulation mode for active action. */
1066         short act_blendmode;
1067         /** Extrapolation mode for active action. */
1068         short act_extendmode;
1069         /** Influence for active action. */
1070         float act_influence;
1071 } AnimData;
1072
1073 /* Animation Data settings (mostly for NLA) */
1074 typedef enum eAnimData_Flag {
1075                 /* only evaluate a single track in the NLA */
1076         ADT_NLA_SOLO_TRACK      = (1<<0),
1077                 /* don't use NLA */
1078         ADT_NLA_EVAL_OFF        = (1<<1),
1079                 /* NLA is being 'tweaked' (i.e. in EditMode) */
1080         ADT_NLA_EDIT_ON         = (1<<2),
1081                 /* active Action for 'tweaking' does not have mapping applied for editing */
1082         ADT_NLA_EDIT_NOMAP      = (1<<3),
1083                 /* NLA-Strip F-Curves are expanded in UI */
1084         ADT_NLA_SKEYS_COLLAPSED = (1<<4),
1085
1086                 /* drivers expanded in UI */
1087         ADT_DRIVERS_COLLAPSED   = (1<<10),
1088                 /* don't execute drivers */
1089         ADT_DRIVERS_DISABLED    = (1<<11),
1090
1091                 /* AnimData block is selected in UI */
1092         ADT_UI_SELECTED         = (1<<14),
1093                 /* AnimData block is active in UI */
1094         ADT_UI_ACTIVE           = (1<<15),
1095
1096                 /* F-Curves from this AnimData block are not visible in the Graph Editor */
1097         ADT_CURVES_NOT_VISIBLE  = (1<<16),
1098
1099                 /* F-Curves from this AnimData block are always visible */
1100         ADT_CURVES_ALWAYS_VISIBLE = (1<<17),
1101 } eAnimData_Flag;
1102
1103 /* Animation Data recalculation settings (to be set by depsgraph) */
1104 typedef enum eAnimData_Recalc {
1105         ADT_RECALC_DRIVERS      = (1 << 0),
1106         ADT_RECALC_ANIM         = (1 << 1),
1107         ADT_RECALC_ALL          = (ADT_RECALC_DRIVERS | ADT_RECALC_ANIM),
1108 } eAnimData_Recalc;
1109
1110 /* Base Struct for Anim ------------------------------------- */
1111
1112 /* Used for BKE_animdata_from_id()
1113  * All ID-datablocks which have their own 'local' AnimData
1114  * should have the same arrangement in their structs.
1115  */
1116 typedef struct IdAdtTemplate {
1117         ID id;
1118         AnimData *adt;
1119 } IdAdtTemplate;
1120
1121 /* ************************************************ */
1122
1123 #ifdef __cplusplus
1124 };
1125 #endif
1126
1127 #endif /* __DNA_ANIM_TYPES_H__ */