Undo revision 23130 which was a merge with 2.5, a messy one because I did something...
[blender.git] / source / blender / makesdna / DNA_action_types.h
1 /*  
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Original design: Reevan McKay
24  * Contributor(s): Full recode, Ton Roosendaal, Crete 2005
25  * Contributor(s): Animation recode, Joshua Leung
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30
31 #ifndef DNA_ACTION_TYPES_H
32 #define DNA_ACTION_TYPES_H
33
34 #include "DNA_listBase.h"
35 #include "DNA_ID.h"
36 #include "DNA_gpencil_types.h"
37 #include "DNA_view2d_types.h"
38 #include "DNA_userdef_types.h"
39
40 struct SpaceLink;
41 struct Object;
42
43 /* ************************************************ */
44 /* Poses */
45
46 /* PoseChannel ------------------------------------ */
47
48 /* PoseChannel 
49  *
50  * A PoseChannel stores the results of Actions and transform information 
51  * with respect to the restposition of Armature bones 
52  */
53 typedef struct bPoseChannel {
54         struct bPoseChannel     *next, *prev;
55         
56         IDProperty                      *prop;          /* User-Defined Properties on this PoseChannel */                       
57         
58         ListBase                        constraints;/* Constraints that act on this PoseChannel */
59         char                            name[32];       /* Channels need longer names than normal blender objects */
60         
61         short                           flag;           /* dynamic, for detecting transform changes */
62         short                           constflag;  /* for quick detecting which constraints affect this channel */
63         short                           ikflag;         /* settings for IK bones */
64         short               selectflag; /* copy of bone flag, so you can work with library armatures */
65         short                           protectflag; /* protect channels from being transformed */
66         short                           agrp_index; /* index of action-group this bone belongs to (0 = default/no group) */
67         
68         int                                 pathlen;    /* for drawing paths, the amount of frames */
69         int                             pathsf;         /* for drawing paths, the start frame number */
70         int                                     pathef;         /* for drawing paths, the end frame number */
71         
72         struct Bone                     *bone;          /* set on read file or rebuild pose */
73         struct bPoseChannel *parent;    /* set on read file or rebuild pose */
74         struct bPoseChannel *child;             /* set on read file or rebuild pose, the 'ik' child, for b-bones */
75         struct ListBase          iktree;                /* only while evaluating pose */
76         
77         /* only while deform, stores precalculated b_bone deform mats,
78            dual quaternions */
79         void                            *b_bone_mats;   
80         void                            *dual_quat;
81         void                            *b_bone_dual_quats;
82         
83         float           loc[3];                         /* transforms - written in by actions or transform */
84         float           size[3];
85         
86         float           eul[3];                         /* rotations - written in by actions or transform (but only euler/quat in use at any one time!) */
87         float           quat[4];
88         short           rotmode;                        /* for now either quat (0), or xyz-euler (1) */
89         short           pad;
90         
91         float           chan_mat[4][4];         /* matrix result of loc/quat/size , and where we put deform in, see next line */
92         float           pose_mat[4][4];         /* constraints accumulate here. in the end, pose_mat = bone->arm_mat * chan_mat */
93         float           constinv[4][4];         /* inverse result of constraints. doesn't include effect of restposition, parent, and local transform*/
94         
95         float           pose_head[3];           /* actually pose_mat[3] */
96         float           pose_tail[3];           /* also used for drawing help lines... */
97         
98         float           limitmin[3], limitmax[3];       /* DOF constraint */
99         float           stiffness[3];                           /* DOF stiffness */
100         float           ikstretch;
101         
102         float           *path;                          /* totpath x 3 x float */
103         struct Object *custom;                  /* draws custom object instead of this channel */
104 } bPoseChannel;
105
106
107 /* PoseChannel (transform) flags */
108 typedef enum ePchan_Flag {
109         POSE_LOC                =       0x0001,
110         POSE_ROT                =       0x0002,
111         POSE_SIZE               =       0x0004,
112         POSE_IK_MAT             =       0x0008,
113         POSE_UNUSED2    =       0x0010,
114         POSE_UNUSED3    =       0x0020,
115         POSE_UNUSED4    =       0x0040,
116         POSE_UNUSED5    =       0x0080,
117         POSE_HAS_IK             =       0x0100,
118         POSE_CHAIN              =       0x0200,
119         POSE_DONE               =   0x0400,
120         POSE_KEY                =       0x1000,
121         POSE_STRIDE             =       0x2000
122 } ePchan_Flag;
123
124 /* PoseChannel constflag (constraint detection) */
125 typedef enum ePchan_ConstFlag {
126         PCHAN_HAS_IK            = (1<<0),
127         PCHAN_HAS_CONST         = (1<<1),
128                 /* only used for drawing Posemode, not stored in channel */
129         PCHAN_HAS_ACTION        = (1<<2),
130         PCHAN_HAS_TARGET        = (1<<3),
131                 /* only for drawing Posemode too */
132         PCHAN_HAS_STRIDE        = (1<<4)
133 } ePchan_ConstFlag;
134
135 /* PoseChannel->ikflag */
136 typedef enum ePchan_IkFlag {
137         BONE_IK_NO_XDOF = (1<<0),
138         BONE_IK_NO_YDOF = (1<<1),
139         BONE_IK_NO_ZDOF = (1<<2),
140
141         BONE_IK_XLIMIT  = (1<<3),
142         BONE_IK_YLIMIT  = (1<<4),
143         BONE_IK_ZLIMIT  = (1<<5),
144         
145         BONE_IK_NO_XDOF_TEMP = (1<<10),
146         BONE_IK_NO_YDOF_TEMP = (1<<11),
147         BONE_IK_NO_ZDOF_TEMP = (1<<12)
148 } ePchan_IkFlag;
149
150 /* PoseChannel->rotmode */
151 typedef enum ePchan_RotMode {
152                 /* quaternion rotations (default, and for older Blender versions) */
153         PCHAN_ROT_QUAT  = 0,
154                 /* euler rotations (xyz only) */
155         PCHAN_ROT_EUL,
156 } ePchan_RotMode;
157
158 /* Pose ------------------------------------ */
159
160 /* Pose-Object. 
161  *
162  * It is only found under ob->pose. It is not library data, even
163  * though there is a define for it (hack for the outliner).
164  */
165 typedef struct bPose {
166         ListBase chanbase;                      /* list of pose channels */
167         
168         short flag, proxy_layer;        /* proxy layer: copy from armature, gets synced */
169         
170         float ctime;                            /* local action time of this pose */
171         float stride_offset[3];         /* applied to object */
172         float cyclic_offset[3];         /* result of match and cycles, applied in where_is_pose() */
173         
174         
175         ListBase agroups;                       /* list of bActionGroups */
176         
177         int active_group;                       /* index of active group (starts from 1) */
178         int pad;
179 } bPose;
180
181
182 /* Pose->flag */
183 typedef enum ePose_Flags {
184                 /* results in armature_rebuild_pose being called */
185         POSE_RECALC = (1<<0),
186                 /* prevents any channel from getting overridden by anim from IPO */
187         POSE_LOCKED     = (1<<1),
188                 /* clears the POSE_LOCKED flag for the next time the pose is evaluated */
189         POSE_DO_UNLOCK  = (1<<2),
190                 /* pose has constraints which depend on time (used when depsgraph updates for a new frame) */
191         POSE_CONSTRAINTS_TIMEDEPEND = (1<<3),
192                 /* recalculate bone paths */
193         POSE_RECALCPATHS = (1<<4),
194 } ePose_Flags;
195
196 /* ************************************************ */
197 /* Action */
198
199 /* Groups -------------------------------------- */
200
201 /* Action-Channel Group (agrp)
202
203  * These are stored as a list per-Action, and are only used to 
204  * group that Action's channels in an Animation Editor. 
205  *
206  * Even though all FCurves live in a big list per Action, each group they are in also
207  * holds references to the achans within that list which belong to it. Care must be taken to
208  * ensure that action-groups never end up being the sole 'owner' of a channel.
209  * 
210  * This is also exploited for bone-groups. Bone-Groups are stored per bPose, and are used 
211  * primarily to colour bones in the 3d-view. There are other benefits too, but those are mostly related
212  * to Action-Groups.
213  */
214 typedef struct bActionGroup {
215         struct bActionGroup *next, *prev;
216         
217         ListBase channels;                      /* Note: this must not be touched by standard listbase functions which would clear links to other channels */
218         
219         int flag;                                       /* settings for this action-group */
220         int customCol;                          /* index of custom color set to use when used for bones (0=default - used for all old files, -1=custom set) */                          
221         char name[64];                          /* name of the group */
222         
223         ThemeWireColor cs;                      /* color set to use when customCol == -1 */
224 } bActionGroup;
225
226 /* Action Group flags */
227 typedef enum eActionGroup_Flag {
228                 /* group is selected */
229         AGRP_SELECTED   = (1<<0),
230                 /* group is 'active' / last selected one */
231         AGRP_ACTIVE     = (1<<1),
232                 /* keyframes/channels belonging to it cannot be edited */
233         AGRP_PROTECTED  = (1<<2),
234                 /* for UI, sub-channels are shown */
235         AGRP_EXPANDED   = (1<<3),
236                 /* sub-channels are not evaluated */
237         AGRP_MUTED              = (1<<4),
238                 /* sub-channels are not visible in Graph Editor */
239         AGRP_NOTVISIBLE = (1<<5),
240         
241         AGRP_TEMP               = (1<<30),
242         AGRP_MOVED              = (1<<31)
243 } eActionGroup_Flag;
244
245
246 /* Actions -------------------------------------- */
247
248 /* Action - reusable F-Curve 'bag'  (act) 
249  *
250  * This contains F-Curves that may affect settings from more than one ID blocktype and/or 
251  * datablock (i.e. sub-data linked/used directly to the ID block that the animation data is linked to), 
252  * but with the restriction that the other unrelated data (i.e. data that is not directly used or linked to
253  * by the source ID block).
254  *
255  * It serves as a 'unit' of reusable animation information (i.e. keyframes/motion data), that 
256  * affects a group of related settings (as defined by the user). 
257  */
258 typedef struct bAction {
259         ID      id;                             /* ID-serialisation for relinking */
260         
261         ListBase curves;        /* function-curves (FCurve) */
262         ListBase chanbase;      /* legacy data - Action Channels (bActionChannel) in pre-2.5 animation system */
263         ListBase groups;        /* groups of function-curves (bActionGroup) */
264         ListBase markers;       /* markers local to the Action (used to provide Pose-Libraries) */
265         
266         int flag;                       /* settings for this action */
267         int active_marker;      /* index of the active marker */
268 } bAction;
269
270
271 /* Flags for the action */
272 typedef enum eAction_Flags {
273                 /* flags for displaying in UI */
274         ACT_COLLAPSED   = (1<<0),
275         ACT_SELECTED    = (1<<1),
276         
277                 /* flags for evaluation/editing */
278         ACT_MUTED               = (1<<9),
279         ACT_PROTECTED   = (1<<10),
280         ACT_DISABLED    = (1<<11),
281 } eAction_Flags;
282
283
284 /* ************************************************ */
285 /* Action/Dopesheet Editor */
286
287 /* Storage for Dopesheet/Grease-Pencil Editor data */
288 typedef struct bDopeSheet {
289         ID              *source;                /* currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil) */
290         ListBase chanbase;              /* cache for channels (only initialised when pinned) */  // XXX not used!
291         
292         int filterflag;                 /* flags to use for filtering data */
293         int flag;                               /* standard flags */
294 } bDopeSheet;
295
296
297 /* DopeSheet filter-flag */
298 typedef enum DOPESHEET_FILTERFLAG {
299                 /* general filtering */
300         ADS_FILTER_ONLYSEL                      = (1<<0),       /* only include channels relating to selected data */
301         
302                 /* temporary (runtime flags) */
303         ADS_FILTER_ONLYDRIVERS          = (1<<1),       /* for 'Drivers' editor - only include Driver data from AnimData */
304         ADS_FILTER_ONLYNLA                      = (1<<2),       /* for 'NLA' editor - only include NLA data from AnimData */
305         ADS_FILTER_SELEDIT                      = (1<<3),       /* for Graph Editor - used to indicate whether to include a filtering flag or not */
306         
307                 /* datatype-based filtering */
308         ADS_FILTER_NOSHAPEKEYS          = (1<<6),
309         ADS_FILTER_NOCAM                        = (1<<10),
310         ADS_FILTER_NOMAT                        = (1<<11),
311         ADS_FILTER_NOLAM                        = (1<<12),
312         ADS_FILTER_NOCUR                        = (1<<13),
313         ADS_FILTER_NOWOR                        = (1<<14),
314         ADS_FILTER_NOSCE                        = (1<<15),
315         ADS_FILTER_NOPART                       = (1<<16),
316         ADS_FILTER_NOMBA                        = (1<<17),
317         
318                 /* NLA-specific filters */
319         ADS_FILTER_NLA_NOACT            = (1<<20),      /* if the AnimData block has no NLA data, don't include to just show Action-line */
320         
321                 /* combination filters (some only used at runtime) */
322         ADS_FILTER_NOOBDATA = (ADS_FILTER_NOCAM|ADS_FILTER_NOMAT|ADS_FILTER_NOLAM|ADS_FILTER_NOCUR|ADS_FILTER_NOPART),
323 } DOPESHEET_FILTERFLAG; 
324
325 /* DopeSheet general flags */
326 //typedef enum DOPESHEET_FLAG {
327         
328 //} DOPESHEET_FLAG;
329
330
331
332 /* Action Editor Space. This is defined here instead of in DNA_space_types.h */
333 typedef struct SpaceAction {
334         struct SpaceLink *next, *prev;
335         ListBase regionbase;            /* storage of regions for inactive spaces */
336         int spacetype;
337         float blockscale;
338
339         short blockhandler[8];
340
341         View2D v2d;                                     /* depricated, copied to region */
342         
343         bAction         *action;                /* the currently active action */
344         bDopeSheet      ads;                    /* the currently active context (when not showing action) */
345         
346         char  mode, autosnap;           /* mode: editing context; autosnap: automatic keyframe snapping mode   */
347         short flag, actnr;                      /* flag: bitmapped settings; */
348         short pin, lock;                        /* pin: keep showing current action; actnr: used for finding chosen action from menu; lock: lock time to other windows */
349         short actwidth;                         /* width of the left-hand side name panel (in pixels?) */  // XXX depreceated!
350         float timeslide;                        /* for Time-Slide transform mode drawing - current frame? */
351 } SpaceAction;
352
353 /* SpaceAction flag */
354 typedef enum eSAction_Flag {
355                 /* during transform (only set for TimeSlide) */
356         SACTION_MOVING  = (1<<0),       
357                 /* show sliders (if relevant) */
358         SACTION_SLIDERS = (1<<1),       
359                 /* draw time in seconds instead of time in frames */
360         SACTION_DRAWTIME = (1<<2),
361                 /* don't filter action channels according to visibility */
362         SACTION_NOHIDE = (1<<3),
363                 /* don't kill overlapping keyframes after transform */
364         SACTION_NOTRANSKEYCULL = (1<<4),
365                 /* don't include keyframes that are out of view */
366         SACTION_HORIZOPTIMISEON = (1<<5),
367                 /* hack for moving pose-markers (temp flag)  */
368         SACTION_POSEMARKERS_MOVE = (1<<6),
369                 /* don't draw action channels using group colours (where applicable) */
370         SACTION_NODRAWGCOLORS = (1<<7),
371                 /* don't draw current frame number beside frame indicator */
372         SACTION_NODRAWCFRANUM = (1<<8),
373 } eSAction_Flag;        
374
375 /* SpaceAction Mode Settings */
376 // XXX should this be used by other editors too?
377 typedef enum eAnimEdit_Context {
378                 /* action (default) */
379         SACTCONT_ACTION = 0,
380                 /* editing of shapekey's IPO block */
381         SACTCONT_SHAPEKEY,
382                 /* editing of gpencil data */
383         SACTCONT_GPENCIL,
384                 /* dopesheet */
385         SACTCONT_DOPESHEET,
386 } eAnimEdit_Context;
387
388 /* SpaceAction AutoSnap Settings (also used by other Animation Editors) */
389 typedef enum eAnimEdit_AutoSnap {
390                 /* no auto-snap */
391         SACTSNAP_OFF = 0,       
392                 /* snap to 1.0 frame/second intervals */
393         SACTSNAP_STEP,
394                 /* snap to actual frames/seconds (nla-action time) */
395         SACTSNAP_FRAME,
396                 /* snap to nearest marker */
397         SACTSNAP_MARKER,
398 } eAnimEdit_AutoSnap;
399
400
401 /* ************************************************ */
402 /* Legacy Data */
403
404 /* WARNING: Action Channels are now depreceated... they were part of the old animation system!
405  *                (ONLY USED FOR DO_VERSIONS...)
406  * 
407  * Action Channels belong to Actions. They are linked with an IPO block, and can also own 
408  * Constraint Channels in certain situations. 
409  *
410  * Action-Channels can only belong to one group at a time, but they still live the Action's
411  * list of achans (to preserve backwards compatability, and also minimise the code
412  * that would need to be recoded). Grouped achans are stored at the start of the list, according
413  * to the position of the group in the list, and their position within the group. 
414  */
415 typedef struct bActionChannel {
416         struct bActionChannel   *next, *prev;
417         bActionGroup                    *grp;                                   /* Action Group this Action Channel belongs to */
418         
419         struct Ipo                              *ipo;                                   /* IPO block this action channel references */
420         ListBase                                constraintChannels;             /* Constraint Channels (when Action Channel represents an Object or Bone) */
421         
422         int             flag;                   /* settings accessed via bitmapping */
423         char    name[32];               /* channel name */
424         int             temp;                   /* temporary setting - may be used to indicate group that channel belongs to during syncing  */
425 } bActionChannel;
426
427 /* Action Channel flags (ONLY USED FOR DO_VERSIONS...) */
428 typedef enum ACHAN_FLAG {
429         ACHAN_SELECTED  = (1<<0),
430         ACHAN_HILIGHTED = (1<<1),
431         ACHAN_HIDDEN    = (1<<2),
432         ACHAN_PROTECTED = (1<<3),
433         ACHAN_EXPANDED  = (1<<4),
434         ACHAN_SHOWIPO   = (1<<5),
435         ACHAN_SHOWCONS  = (1<<6),
436         ACHAN_MOVED     = (1<<31),
437 } ACHAN_FLAG; 
438
439
440 #endif
441
442