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