svn merge ^/trunk/blender -r47023:HEAD
[blender.git] / source / blender / makesdna / DNA_action_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) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): Original design: Reevan McKay
22  * Contributor(s): Full recode, Ton Roosendaal, Crete 2005
23  * Contributor(s): Animation recode, Joshua Leung
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file DNA_action_types.h
29  *  \ingroup DNA
30  */
31
32 #ifndef __DNA_ACTION_TYPES_H__
33 #define __DNA_ACTION_TYPES_H__
34
35 #include "DNA_listBase.h"
36 #include "DNA_ID.h"
37 #include "DNA_view2d_types.h"
38 #include "DNA_userdef_types.h" /* ThemeWireColor */
39
40 struct SpaceLink;
41 struct Object;
42 struct Group;
43 struct GHash;
44
45 /* ************************************************ */
46 /* Visualisation */
47
48 /* Motion Paths ------------------------------------ */
49 /* (used for Pose Channels and Objects) */
50
51 /* Data point for motion path (mpv) */
52 typedef struct bMotionPathVert {
53         float co[3];                /* coordinates of point in 3D-space */
54         int flag;                   /* quick settings */
55 } bMotionPathVert;
56
57 /* bMotionPathVert->flag */
58 typedef enum eMotionPathVert_Flag {
59         /* vert is selected */
60         MOTIONPATH_VERT_SEL     = (1 << 0)
61 } eMotionPathVert_Flag;
62
63 /* ........ */
64
65 /* Motion Path data cache (mpath)
66  *  - for elements providing transforms (i.e. Objects or PoseChannels)
67  */
68 typedef struct bMotionPath {
69         bMotionPathVert *points;    /* path samples */
70         int length;                 /* the number of cached verts */
71         
72         int start_frame;            /* for drawing paths, the start frame number */
73         int end_frame;              /* for drawing paths, the end frame number */
74         
75         int flag;                   /* baking settings - eMotionPath_Flag */
76 } bMotionPath;
77
78 /* bMotionPath->flag */
79 typedef enum eMotionPath_Flag {
80         /* (for bones) path represents the head of the bone */
81         MOTIONPATH_FLAG_BHEAD       = (1 << 0),
82         /* motion path is being edited */
83         MOTIONPATH_FLAG_EDIT        = (1 << 1)
84 } eMotionPath_Flag;
85
86 /* Visualisation General --------------------------- */
87 /* for Objects or Poses (but NOT PoseChannels) */
88
89 /* Animation Visualisation Settings (avs) */
90 typedef struct bAnimVizSettings {
91         /* Onion-Skinning Settings ----------------- */
92         int ghost_sf, ghost_ef;         /* start and end frames of ghost-drawing range (only used for GHOST_TYPE_RANGE) */
93         int ghost_bc, ghost_ac;         /* number of frames before/after current frame to show */
94         
95         short ghost_type;               /* eOnionSkin_Types */
96         short ghost_step;               /* number of frames between each ghost shown (not for GHOST_TYPE_KEYS) */
97         
98         short ghost_flag;               /* eOnionSkin_Flag */
99         
100         /* General Settings ------------------------ */
101         short recalc;                   /* eAnimViz_RecalcFlags */
102         
103         /* Motion Path Settings ------------------- */
104         short path_type;                /* eMotionPath_Types */
105         short path_step;                /* number of frames between points indicated on the paths */
106         
107         short path_viewflag;            /* eMotionPaths_ViewFlag */
108         short path_bakeflag;            /* eMotionPaths_BakeFlag */
109         
110         int path_sf, path_ef;           /* start and end frames of path-calculation range */
111         int path_bc, path_ac;           /* number of frames before/after current frame to show */
112 } bAnimVizSettings;
113
114
115 /* bAnimVizSettings->recalc */
116 typedef enum eAnimViz_RecalcFlags {
117         /* motionpaths need recalculating */
118         ANIMVIZ_RECALC_PATHS    = (1 << 0)
119 } eAnimViz_RecalcFlags;
120
121
122 /* bAnimVizSettings->ghost_type */
123 typedef enum eOnionSkin_Types {
124         /* no ghosts at all */
125         GHOST_TYPE_NONE = 0,
126         /* around current frame */
127         GHOST_TYPE_ACFRA = 1,
128         /* show ghosts within the specified frame range */
129         GHOST_TYPE_RANGE = 2,
130         /* show ghosts on keyframes within the specified range only */
131         GHOST_TYPE_KEYS = 3
132 } eOnionSkin_Types;
133
134 /* bAnimVizSettings->ghost_flag */
135 typedef enum eOnionSkin_Flag {
136         /* only show selected bones in ghosts */
137         GHOST_FLAG_ONLYSEL  = (1 << 0)
138 } eOnionSkin_Flag;
139
140
141 /* bAnimVizSettings->path_type */
142 typedef enum eMotionPaths_Types {
143         /* show the paths along their entire ranges */
144         MOTIONPATH_TYPE_RANGE = 0,
145         /* only show the parts of the paths around the current frame */
146         MOTIONPATH_TYPE_ACFRA = 1,
147 } eMotionPath_Types;
148
149 /* bAnimVizSettings->path_viewflag */
150 typedef enum eMotionPaths_ViewFlag {
151         /* show frames on path */
152         MOTIONPATH_VIEW_FNUMS       = (1 << 0),
153         /* show keyframes on path */
154         MOTIONPATH_VIEW_KFRAS       = (1 << 1),
155         /* show keyframe/frame numbers */
156         MOTIONPATH_VIEW_KFNOS       = (1 << 2),
157         /* find keyframes in whole action (instead of just in matching group name) */
158         MOTIONPATH_VIEW_KFACT       = (1 << 3)
159 } eMotionPath_ViewFlag;
160
161 /* bAnimVizSettings->path_bakeflag */
162 typedef enum eMotionPaths_BakeFlag {
163         /* motion paths directly associated with this block of settings needs updating */
164         MOTIONPATH_BAKE_NEEDS_RECALC    = (1 << 0),
165         /* for bones - calculate head-points for curves instead of tips */
166         MOTIONPATH_BAKE_HEADS           = (1 << 1),
167         /* motion paths exist for AnimVizSettings instance - set when calc for first time, and unset when clearing */
168         MOTIONPATH_BAKE_HAS_PATHS       = (1 << 2)
169 } eMotionPath_BakeFlag;
170
171 /* ************************************************ */
172 /* Poses */
173
174 /* PoseChannel ------------------------------------ */
175
176 /* PoseChannel 
177  *
178  * A PoseChannel stores the results of Actions and transform information 
179  * with respect to the restposition of Armature bones 
180  */
181 typedef struct bPoseChannel {
182         struct bPoseChannel *next, *prev;
183         
184         IDProperty          *prop;      /* User-Defined Properties on this PoseChannel */
185         
186         ListBase constraints;           /* Constraints that act on this PoseChannel */
187         char name[64];                  /* need to match bone name length: MAXBONENAME */
188         
189         short flag;                     /* dynamic, for detecting transform changes */
190         short ikflag;                   /* settings for IK bones */
191         short protectflag;              /* protect channels from being transformed */
192         short agrp_index;               /* index of action-group this bone belongs to (0 = default/no group) */
193         char constflag;                 /* for quick detecting which constraints affect this channel */
194         char selectflag;                /* copy of bone flag, so you can work with library armatures, not for runtime use */
195         char pad0[6];
196
197         struct Bone         *bone;      /* set on read file or rebuild pose */
198         struct bPoseChannel *parent;    /* set on read file or rebuild pose */
199         struct bPoseChannel *child;     /* set on read file or rebuild pose, the 'ik' child, for b-bones */
200
201         struct ListBase iktree;         /* "IK trees" - only while evaluating pose */
202         struct ListBase siktree;        /* Spline-IK "trees" - only while evaluating pose */
203
204         bMotionPath *mpath;             /* motion path cache for this bone */
205         struct Object *custom;          /* draws custom object instead of default bone shape */
206         struct bPoseChannel *custom_tx; /* odd feature, display with another bones transform.
207                                          * needed in rare cases for advanced rigs,
208                                          * since the alternative is highly complicated - campbell */
209
210         /* transforms - written in by actions or transform */
211         float loc[3];
212         float size[3];
213
214         /* rotations - written in by actions or transform (but only one representation gets used at any time) */
215         float eul[3];                       /* euler rotation */
216         float quat[4];                      /* quaternion rotation */
217         float rotAxis[3], rotAngle;         /* axis-angle rotation */
218         short rotmode;                      /* eRotationModes - rotation representation to use */
219         short pad;
220         
221         float chan_mat[4][4];           /* matrix result of loc/quat/size , and where we put deform in, see next line */
222         float pose_mat[4][4];           /* constraints accumulate here. in the end, pose_mat = bone->arm_mat * chan_mat
223                                          * this matrix is object space */
224         float constinv[4][4];           /* inverse result of constraints.
225                                          * doesn't include effect of restposition, parent, and local transform*/
226         
227         float pose_head[3];             /* actually pose_mat[3] */
228         float pose_tail[3];             /* also used for drawing help lines... */
229         
230         float limitmin[3], limitmax[3]; /* DOF constraint, note! - these are stored in degrees, not radians */
231         float stiffness[3];             /* DOF stiffness */
232         float ikstretch;
233         float ikrotweight;              /* weight of joint rotation constraint */
234         float iklinweight;              /* weight of joint stretch constraint */
235
236         void        *temp;              /* use for outliner */
237 } bPoseChannel;
238
239
240 /* PoseChannel (transform) flags */
241 typedef enum ePchan_Flag {
242         /* has transforms */
243         POSE_LOC        =   (1 << 0),
244         POSE_ROT        =   (1 << 1),
245         POSE_SIZE       =   (1 << 2),
246         /* old IK/cache stuff... */
247         POSE_IK_MAT     =   (1 << 3),
248         POSE_UNUSED2    =   (1 << 4),
249         POSE_UNUSED3    =   (1 << 5),
250         POSE_UNUSED4    =   (1 << 6),
251         POSE_UNUSED5    =   (1 << 7),
252         /* has Standard IK */
253         POSE_HAS_IK     =   (1 << 8),
254         /* IK/Pose solving*/
255         POSE_CHAIN      =   (1 << 9),
256         POSE_DONE       =   (1 << 10),
257         /* visualisation */
258         POSE_KEY        =   (1 << 11),
259         POSE_STRIDE     =   (1 << 12),
260         /* standard IK solving */
261         POSE_IKTREE     =   (1 << 13),
262         /* has Spline IK */
263         POSE_HAS_IKS    =   (1 << 14),
264         /* spline IK solving */
265         POSE_IKSPLINE   =   (1 << 15)
266 } ePchan_Flag;
267
268 /* PoseChannel constflag (constraint detection) */
269 typedef enum ePchan_ConstFlag {
270         PCHAN_HAS_IK        = (1 << 0),
271         PCHAN_HAS_CONST     = (1 << 1),
272         /* only used for drawing Posemode, not stored in channel */
273         PCHAN_HAS_ACTION    = (1 << 2),
274         PCHAN_HAS_TARGET    = (1 << 3),
275         /* only for drawing Posemode too */
276         PCHAN_HAS_STRIDE    = (1 << 4),
277         /* spline IK */
278         PCHAN_HAS_SPLINEIK  = (1 << 5)
279 } ePchan_ConstFlag;
280
281 /* PoseChannel->ikflag */
282 typedef enum ePchan_IkFlag {
283         BONE_IK_NO_XDOF = (1 << 0),
284         BONE_IK_NO_YDOF = (1 << 1),
285         BONE_IK_NO_ZDOF = (1 << 2),
286
287         BONE_IK_XLIMIT  = (1 << 3),
288         BONE_IK_YLIMIT  = (1 << 4),
289         BONE_IK_ZLIMIT  = (1 << 5),
290
291         BONE_IK_ROTCTL  = (1 << 6),
292         BONE_IK_LINCTL  = (1 << 7),
293
294         BONE_IK_NO_XDOF_TEMP = (1 << 10),
295         BONE_IK_NO_YDOF_TEMP = (1 << 11),
296         BONE_IK_NO_ZDOF_TEMP = (1 << 12)
297 } ePchan_IkFlag;
298
299 /* PoseChannel->rotmode and Object->rotmode */
300 typedef enum eRotationModes {
301         /* quaternion rotations (default, and for older Blender versions) */
302         ROT_MODE_QUAT   = 0,
303         /* euler rotations - keep in sync with enum in BLI_math.h */
304         ROT_MODE_EUL = 1,       /* Blender 'default' (classic) - must be as 1 to sync with BLI_math_rotation.h defines */
305         ROT_MODE_XYZ = 1,
306         ROT_MODE_XZY = 2,
307         ROT_MODE_YXZ = 3,
308         ROT_MODE_YZX = 4,
309         ROT_MODE_ZXY = 5,
310         ROT_MODE_ZYX = 6,
311         /* NOTE: space is reserved here for 18 other possible 
312          * euler rotation orders not implemented 
313          */
314         /* axis angle rotations */
315         ROT_MODE_AXISANGLE = -1,
316
317         ROT_MODE_MIN = ROT_MODE_AXISANGLE,  /* sentinel for Py API */
318         ROT_MODE_MAX = ROT_MODE_ZYX
319 } eRotationModes;
320
321 /* Pose ------------------------------------ */
322
323 /* Pose-Object. 
324  *
325  * It is only found under ob->pose. It is not library data, even
326  * though there is a define for it (hack for the outliner).
327  */
328 typedef struct bPose {
329         ListBase chanbase;          /* list of pose channels, PoseBones in RNA */
330         struct GHash *chanhash;     /* ghash for quicker string lookups */
331         
332         short flag, pad;
333         unsigned int proxy_layer;   /* proxy layer: copy from armature, gets synced */
334         int pad1;
335         
336         float ctime;                /* local action time of this pose */
337         float stride_offset[3];     /* applied to object */
338         float cyclic_offset[3];     /* result of match and cycles, applied in BKE_pose_where_is() */
339         
340         
341         ListBase agroups;           /* list of bActionGroups */
342         
343         int active_group;           /* index of active group (starts from 1) */
344         int iksolver;               /* ik solver to use, see ePose_IKSolverType */
345         void *ikdata;               /* temporary IK data, depends on the IK solver. Not saved in file */
346         void *ikparam;              /* IK solver parameters, structure depends on iksolver */
347         
348         bAnimVizSettings avs;       /* settings for visualization of bone animation */
349         char proxy_act_bone[64];    /* proxy active bone name, MAXBONENAME */
350 } bPose;
351
352
353 /* Pose->flag */
354 typedef enum ePose_Flags {
355         /* results in BKE_pose_rebuild being called */
356         POSE_RECALC = (1 << 0),
357         /* prevents any channel from getting overridden by anim from IPO */
358         POSE_LOCKED = (1 << 1),
359         /* clears the POSE_LOCKED flag for the next time the pose is evaluated */
360         POSE_DO_UNLOCK  = (1 << 2),
361         /* pose has constraints which depend on time (used when depsgraph updates for a new frame) */
362         POSE_CONSTRAINTS_TIMEDEPEND = (1 << 3),
363         /* recalculate bone paths */
364         POSE_RECALCPATHS = (1 << 4),
365         /* set by BKE_pose_rebuild to give a chance to the IK solver to rebuild IK tree */
366         POSE_WAS_REBUILT = (1 << 5),
367         /* set by game_copy_pose to indicate that this pose is used in the game engine */
368         POSE_GAME_ENGINE = (1 << 6)
369 } ePose_Flags;
370
371 /* IK Solvers ------------------------------------ */
372
373 /* bPose->iksolver and bPose->ikparam->iksolver */
374 typedef enum ePose_IKSolverType {
375         IKSOLVER_LEGACY = 0,
376         IKSOLVER_ITASC = 1
377 } ePose_IKSolverType;
378
379 /* header for all bPose->ikparam structures */
380 typedef struct bIKParam {
381         int iksolver;
382 } bIKParam;
383
384 /* bPose->ikparam when bPose->iksolver=1 */
385 typedef struct bItasc {
386         int iksolver;
387         float precision;
388         short numiter;
389         short numstep;
390         float minstep;
391         float maxstep;
392         short solver;
393         short flag;
394         float feedback;
395         float maxvel;   /* max velocity to SDLS solver */
396         float dampmax;  /* maximum damping for DLS solver */
397         float dampeps;  /* threshold of singular value from which the damping start progressively */
398 } bItasc;
399
400 /* bItasc->flag */
401 typedef enum eItasc_Flags {
402         ITASC_AUTO_STEP           = (1 << 0),
403         ITASC_INITIAL_REITERATION = (1 << 1),
404         ITASC_REITERATION         = (1 << 2),
405         ITASC_SIMULATION          = (1 << 3)
406 } eItasc_Flags;
407
408 /* bItasc->solver */
409 typedef enum eItasc_Solver {
410         ITASC_SOLVER_SDLS = 0,  /* selective damped least square, suitable for CopyPose constraint */
411         ITASC_SOLVER_DLS  = 1,  /* damped least square with numerical filtering of damping */
412 } eItasc_Solver;
413
414 /* ************************************************ */
415 /* Action */
416
417 /* Groups -------------------------------------- */
418
419 /* Action-Channel Group (agrp)
420  *
421  * These are stored as a list per-Action, and are only used to 
422  * group that Action's channels in an Animation Editor. 
423  *
424  * Even though all FCurves live in a big list per Action, each group they are in also
425  * holds references to the achans within that list which belong to it. Care must be taken to
426  * ensure that action-groups never end up being the sole 'owner' of a channel.
427  * 
428  * This is also exploited for bone-groups. Bone-Groups are stored per bPose, and are used 
429  * primarily to color bones in the 3d-view. There are other benefits too, but those are mostly related
430  * to Action-Groups.
431  *
432  * Note that these two uses each have their own RNA 'ActionGroup' and 'BoneGroup'.
433  */
434 typedef struct bActionGroup {
435         struct bActionGroup *next, *prev;
436         
437         ListBase channels;          /* Note: this must not be touched by standard listbase functions which would clear links to other channels */
438         
439         int flag;                   /* settings for this action-group */
440         int customCol;              /* index of custom color set to use when used for bones (0=default - used for all old files, -1=custom set) */
441         char name[64];              /* name of the group */
442         
443         ThemeWireColor cs;          /* color set to use when customCol == -1 */
444 } bActionGroup;
445
446 /* Action Group flags */
447 typedef enum eActionGroup_Flag {
448         /* group is selected */
449         AGRP_SELECTED   = (1 << 0),
450         /* group is 'active' / last selected one */
451         AGRP_ACTIVE     = (1 << 1),
452         /* keyframes/channels belonging to it cannot be edited */
453         AGRP_PROTECTED  = (1 << 2),
454         /* for UI (DopeSheet), sub-channels are shown */
455         AGRP_EXPANDED   = (1 << 3),
456         /* sub-channels are not evaluated */
457         AGRP_MUTED      = (1 << 4),
458         /* sub-channels are not visible in Graph Editor */
459         AGRP_NOTVISIBLE = (1 << 5),
460         /* for UI (Graph Editor), sub-channels are shown */
461         AGRP_EXPANDED_G = (1 << 6),
462         
463         AGRP_TEMP       = (1 << 30),
464         AGRP_MOVED      = (1 << 31)
465 } eActionGroup_Flag;
466
467
468 /* Actions -------------------------------------- */
469
470 /* Action - reusable F-Curve 'bag'  (act) 
471  *
472  * This contains F-Curves that may affect settings from more than one ID blocktype and/or 
473  * datablock (i.e. sub-data linked/used directly to the ID block that the animation data is linked to), 
474  * but with the restriction that the other unrelated data (i.e. data that is not directly used or linked to
475  * by the source ID block).
476  *
477  * It serves as a 'unit' of reusable animation information (i.e. keyframes/motion data), that 
478  * affects a group of related settings (as defined by the user). 
479  */
480 typedef struct bAction {
481         ID id;              /* ID-serialisation for relinking */
482         
483         ListBase curves;    /* function-curves (FCurve) */
484         ListBase chanbase;  /* legacy data - Action Channels (bActionChannel) in pre-2.5 animation system */
485         ListBase groups;    /* groups of function-curves (bActionGroup) */
486         ListBase markers;   /* markers local to the Action (used to provide Pose-Libraries) */
487         
488         int flag;           /* settings for this action */
489         int active_marker;  /* index of the active marker */
490         
491         int idroot;         /* type of ID-blocks that action can be assigned to (if 0, will be set to whatever ID first evaluates it) */
492         int pad;
493 } bAction;
494
495
496 /* Flags for the action */
497 typedef enum eAction_Flags {
498         /* flags for displaying in UI */
499         ACT_COLLAPSED   = (1 << 0),
500         ACT_SELECTED    = (1 << 1),
501
502         /* flags for evaluation/editing */
503         ACT_MUTED       = (1 << 9),
504         ACT_PROTECTED   = (1 << 10),
505         ACT_DISABLED    = (1 << 11)
506 } eAction_Flags;
507
508
509 /* ************************************************ */
510 /* Action/Dopesheet Editor */
511
512 /* Storage for Dopesheet/Grease-Pencil Editor data */
513 typedef struct bDopeSheet {
514         ID      *source;            /* currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil) */
515         ListBase chanbase; /* cache for channels (only initialized when pinned) */           // XXX not used!
516         
517         struct Group *filter_grp;   /* object group for ADS_FILTER_ONLYOBGROUP filtering option */
518         char searchstr[64];         /* string to search for in displayed names of F-Curves for ADS_FILTER_BY_FCU_NAME filtering option */
519         
520         int filterflag;             /* flags to use for filtering data */
521         int flag;                   /* standard flags */
522         
523         int renameIndex;            /* index+1 of channel to rename - only gets set by renaming operator */
524         int pad;
525 } bDopeSheet;
526
527
528 /* DopeSheet filter-flag */
529 typedef enum eDopeSheet_FilterFlag {
530         /* general filtering */
531         ADS_FILTER_ONLYSEL          = (1 << 0),   /* only include channels relating to selected data */
532         
533         /* temporary filters */
534         ADS_FILTER_ONLYDRIVERS      = (1 << 1),   /* for 'Drivers' editor - only include Driver data from AnimData */
535         ADS_FILTER_ONLYNLA          = (1 << 2),   /* for 'NLA' editor - only include NLA data from AnimData */
536         ADS_FILTER_SELEDIT          = (1 << 3),   /* for Graph Editor - used to indicate whether to include a filtering flag or not */
537
538         /* general filtering 2 */
539         ADS_FILTER_SUMMARY          = (1 << 4),   /* for 'DopeSheet' Editors - include 'summary' line */
540         ADS_FILTER_ONLYOBGROUP      = (1 << 5),   /* only the objects in the specified object group get used */
541
542         /* datatype-based filtering */
543         ADS_FILTER_NOSHAPEKEYS      = (1 << 6),
544         ADS_FILTER_NOMESH           = (1 << 7),
545         ADS_FILTER_NOOBJ            = (1 << 8),   /* for animdata on object level, if we only want to concentrate on materials/etc. */
546         ADS_FILTER_NOLAT            = (1 << 9),
547         ADS_FILTER_NOCAM            = (1 << 10),
548         ADS_FILTER_NOMAT            = (1 << 11),
549         ADS_FILTER_NOLAM            = (1 << 12),
550         ADS_FILTER_NOCUR            = (1 << 13),
551         ADS_FILTER_NOWOR            = (1 << 14),
552         ADS_FILTER_NOSCE            = (1 << 15),
553         ADS_FILTER_NOPART           = (1 << 16),
554         ADS_FILTER_NOMBA            = (1 << 17),
555         ADS_FILTER_NOARM            = (1 << 18),
556         ADS_FILTER_NONTREE          = (1 << 19),
557         ADS_FILTER_NOTEX            = (1 << 20),
558         ADS_FILTER_NOSPK            = (1 << 21),
559
560         /* NLA-specific filters */
561         ADS_FILTER_NLA_NOACT        = (1 << 25),  /* if the AnimData block has no NLA data, don't include to just show Action-line */
562
563         /* general filtering 3 */
564         ADS_FILTER_INCL_HIDDEN      = (1 << 26),  /* include 'hidden' channels too (i.e. those from hidden Objects/Bones) */
565         ADS_FILTER_BY_FCU_NAME      = (1 << 27),  /* for F-Curves, filter by the displayed name (i.e. to isolate all Location curves only) */
566         
567         /* combination filters (some only used at runtime) */
568         ADS_FILTER_NOOBDATA = (ADS_FILTER_NOCAM | ADS_FILTER_NOMAT | ADS_FILTER_NOLAM | ADS_FILTER_NOCUR | ADS_FILTER_NOPART | ADS_FILTER_NOARM | ADS_FILTER_NOSPK)
569 } eDopeSheet_FilterFlag;        
570
571 /* DopeSheet general flags */
572 typedef enum eDopeSheet_Flag {
573         ADS_FLAG_SUMMARY_COLLAPSED  = (1 << 0),   /* when summary is shown, it is collapsed, so all other channels get hidden */
574         ADS_FLAG_SHOW_DBFILTERS     = (1 << 1)    /* show filters for datablocks */
575 } eDopeSheet_Flag;
576
577
578
579 /* Action Editor Space. This is defined here instead of in DNA_space_types.h */
580 typedef struct SpaceAction {
581         struct SpaceLink *next, *prev;
582         ListBase regionbase;        /* storage of regions for inactive spaces */
583         int spacetype;
584         float blockscale;
585
586         short blockhandler[8];
587
588         View2D v2d DNA_DEPRECATED;  /* copied to region */
589         
590         bAction     *action;        /* the currently active action */
591         bDopeSheet ads;             /* the currently active context (when not showing action) */
592         
593         char mode, autosnap;        /* mode: editing context; autosnap: automatic keyframe snapping mode   */
594         short flag;                 /* flag: bitmapped settings; */
595         float timeslide;            /* for Time-Slide transform mode drawing - current frame? */
596 } SpaceAction;
597
598 /* SpaceAction flag */
599 typedef enum eSAction_Flag {
600         /* during transform (only set for TimeSlide) */
601         SACTION_MOVING  = (1 << 0),
602         /* show sliders */
603         SACTION_SLIDERS = (1 << 1),
604         /* draw time in seconds instead of time in frames */
605         SACTION_DRAWTIME = (1 << 2),
606         /* don't filter action channels according to visibility */
607         //SACTION_NOHIDE = (1<<3), // XXX depreceated... old animation system
608         /* don't kill overlapping keyframes after transform */
609         SACTION_NOTRANSKEYCULL = (1 << 4),
610         /* don't include keyframes that are out of view */
611         //SACTION_HORIZOPTIMISEON = (1<<5), // XXX depreceated... old irrelevant trick
612         /* show pose-markers (local to action) in Action Editor mode  */
613         SACTION_POSEMARKERS_SHOW = (1 << 6),
614         /* don't draw action channels using group colors (where applicable) */
615         SACTION_NODRAWGCOLORS = (1 << 7),
616         /* don't draw current frame number beside frame indicator */
617         SACTION_NODRAWCFRANUM = (1 << 8),
618         /* temporary flag to force channel selections to be synced with main */
619         SACTION_TEMP_NEEDCHANSYNC = (1 << 9),
620         /* don't perform realtime updates */
621         SACTION_NOREALTIMEUPDATES = (1 << 10),
622         /* move markers as well as keyframes */
623         SACTION_MARKERS_MOVE = (1 << 11)
624 } eSAction_Flag;        
625
626 /* SpaceAction Mode Settings */
627 typedef enum eAnimEdit_Context {
628         /* action on the active object */
629         SACTCONT_ACTION = 0,
630         /* list of all shapekeys on the active object, linked with their F-Curves */
631         SACTCONT_SHAPEKEY = 1,
632         /* editing of gpencil data */
633         SACTCONT_GPENCIL = 2,
634         /* dopesheet (default) */
635         SACTCONT_DOPESHEET = 3,
636         /* mask */
637         SACTCONT_MASK = 4
638 } eAnimEdit_Context;
639
640 /* SpaceAction AutoSnap Settings (also used by other Animation Editors) */
641 typedef enum eAnimEdit_AutoSnap {
642         /* no auto-snap */
643         SACTSNAP_OFF = 0,
644         /* snap to 1.0 frame/second intervals */
645         SACTSNAP_STEP = 1,
646         /* snap to actual frames/seconds (nla-action time) */
647         SACTSNAP_FRAME = 2,
648         /* snap to nearest marker */
649         SACTSNAP_MARKER = 3
650 } eAnimEdit_AutoSnap;
651
652
653 /* ************************************************ */
654 /* Legacy Data */
655
656 /* WARNING: Action Channels are now depreceated... they were part of the old animation system!
657  *        (ONLY USED FOR DO_VERSIONS...)
658  * 
659  * Action Channels belong to Actions. They are linked with an IPO block, and can also own 
660  * Constraint Channels in certain situations. 
661  *
662  * Action-Channels can only belong to one group at a time, but they still live the Action's
663  * list of achans (to preserve backwards compatibility, and also minimize the code
664  * that would need to be recoded). Grouped achans are stored at the start of the list, according
665  * to the position of the group in the list, and their position within the group. 
666  */
667 typedef struct bActionChannel {
668         struct bActionChannel   *next, *prev;
669         bActionGroup            *grp;           /* Action Group this Action Channel belongs to */
670         
671         struct Ipo              *ipo;           /* IPO block this action channel references */
672         ListBase constraintChannels;            /* Constraint Channels (when Action Channel represents an Object or Bone) */
673         
674         int flag;               /* settings accessed via bitmapping */
675         char name[64];          /* channel name, MAX_NAME */
676         int temp;               /* temporary setting - may be used to indicate group that channel belongs to during syncing  */
677 } bActionChannel;
678
679 /* Action Channel flags (ONLY USED FOR DO_VERSIONS...) */
680 typedef enum ACHAN_FLAG {
681         ACHAN_SELECTED  = (1 << 0),
682         ACHAN_HILIGHTED = (1 << 1),
683         ACHAN_HIDDEN    = (1 << 2),
684         ACHAN_PROTECTED = (1 << 3),
685         ACHAN_EXPANDED  = (1 << 4),
686         ACHAN_SHOWIPO   = (1 << 5),
687         ACHAN_SHOWCONS  = (1 << 6),
688         ACHAN_MOVED     = (1 << 31)
689 } ACHAN_FLAG; 
690
691 #endif