2.5
[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 /* -------------- Poses ----------------- */
44
45 /* PoseChannel stores the results of Actions (ipos) and transform information 
46    with respect to the restposition of Armature bones */
47 typedef struct bPoseChannel {
48         struct bPoseChannel     *next, *prev;
49         ListBase                        constraints;/* Constraints that act on this PoseChannel */
50         char                            name[32];       /* Channels need longer names than normal blender objects */
51         
52         short                           flag;           /* dynamic, for detecting transform changes */
53         short                           constflag;  /* for quick detecting which constraints affect this channel */
54         short                           ikflag;         /* settings for IK bones */
55         short               selectflag; /* copy of bone flag, so you can work with library armatures */
56         short                           protectflag; /* protect channels from being transformed */
57         short                           agrp_index; /* index of action-group this bone belongs to (0 = default/no group) */
58         
59         int                                 pathlen;    /* for drawing paths, the amount of frames */
60         int                             pathsf;         /* for drawing paths, the start frame number */
61         int                                     pathef;         /* for drawing paths, the end frame number */
62         
63         struct Bone                     *bone;          /* set on read file or rebuild pose */
64         struct bPoseChannel *parent;    /* set on read file or rebuild pose */
65         struct bPoseChannel *child;             /* set on read file or rebuild pose, the 'ik' child, for b-bones */
66         struct ListBase          iktree;                /* only while evaluating pose */
67         
68         /* only while deform, stores precalculated b_bone deform mats,
69            dual quaternions */
70         void                            *b_bone_mats;   
71         void                            *dual_quat;
72         void                            *b_bone_dual_quats;
73         
74         float           loc[3];                         /* transforms - written in by actions or transform */
75         float           size[3];
76         
77         float           eul[3];                         /* rotations - written in by actions or transform (but only euler/quat in use at any one time!) */
78         float           quat[4];
79         short           rotmode;                        /* for now either quat (0), or xyz-euler (1) */
80         short           pad;
81         
82         float           chan_mat[4][4];         /* matrix result of loc/quat/size , and where we put deform in, see next line */
83         float           pose_mat[4][4];         /* constraints accumulate here. in the end, pose_mat = bone->arm_mat * chan_mat */
84         float           constinv[4][4];         /* inverse result of constraints. doesn't include effect of restposition, parent, and local transform*/
85         
86         float           pose_head[3];           /* actually pose_mat[3] */
87         float           pose_tail[3];           /* also used for drawing help lines... */
88         
89         float           limitmin[3], limitmax[3];       /* DOF constraint */
90         float           stiffness[3];                           /* DOF stiffness */
91         float           ikstretch;
92         
93         float           *path;                          /* totpath x 3 x float */
94         struct Object *custom;                  /* draws custom object instead of this channel */
95 } bPoseChannel;
96
97 /* Pose-Object. It is only found under ob->pose. It is not library data, even
98  * though there is a define for it (hack for the outliner).
99  */
100 typedef struct bPose {
101         ListBase chanbase;                      /* list of pose channels */
102         
103         short flag, proxy_layer;        /* proxy layer: copy from armature, gets synced */
104         
105         float ctime;                            /* local action time of this pose */
106         float stride_offset[3];         /* applied to object */
107         float cyclic_offset[3];         /* result of match and cycles, applied in where_is_pose() */
108         
109         
110         ListBase agroups;                       /* list of bActionGroups */
111         
112         int active_group;                       /* index of active group (starts from 1) */
113         int pad;
114 } bPose;
115
116
117 /* ------------- Action  ---------------- */
118
119 /* Action-Channel Group. These are stored as a list per-Action, and are only used to 
120  * group that Action's Action-Channels when displayed in the Action Editor. 
121  *
122  * Even though all Action-Channels live in a big list per Action, each group they are in also
123  * holds references to the achans within that list which belong to it. Care must be taken to
124  * ensure that action-groups never end up being the sole 'owner' of a channel.
125  *
126  * 
127  * This is also exploited for bone-groups. Bone-Groups are stored per bPose, and are used 
128  * primarily to colour bones in the 3d-view. There are other benefits too, but those are mostly related
129  * to Action-Groups.
130  */
131 typedef struct bActionGroup {
132         struct bActionGroup *next, *prev;
133         
134         ListBase channels;                      /* Note: this must not be touched by standard listbase functions */
135         
136         int flag;                                       /* settings for this action-group */
137         int customCol;                          /* index of custom color set to use when used for bones (0=default - used for all old files, -1=custom set) */                          
138         char name[32];                          /* name of the group */
139         
140         ThemeWireColor cs;                      /* color set to use when customCol == -1 */
141 } bActionGroup;
142
143 /* Action Channels belong to Actions. They are linked with an IPO block, and can also own 
144  * Constraint Channels in certain situations. 
145  *
146  * Action-Channels can only belong to one group at a time, but they still live the Action's
147  * list of achans (to preserve backwards compatability, and also minimise the code
148  * that would need to be recoded). Grouped achans are stored at the start of the list, according
149  * to the position of the group in the list, and their position within the group. 
150  */
151 typedef struct bActionChannel {
152         struct bActionChannel   *next, *prev;
153         bActionGroup                    *grp;                                   /* Action Group this Action Channel belongs to */
154         
155         struct Ipo                              *ipo;                                   /* IPO block this action channel references */
156         ListBase                                constraintChannels;             /* Constraint Channels (when Action Channel represents an Object or Bone) */
157         
158         int             flag;                   /* settings accessed via bitmapping */
159         char    name[32];               /* channel name */
160         int             reserved1;
161 } bActionChannel;
162
163 /* Action. A recyclable block that contains a series of Action Channels (ipo), which define 
164  * a clip of reusable animation for use in the NLA.
165  */
166 typedef struct bAction {
167         ID                              id;
168         
169         ListBase                chanbase;       /* Action Channels in this Action */
170         ListBase                groups;         /* Action Groups in the Action */
171         ListBase                markers;        /* TimeMarkers local to this Action for labelling 'poses' */
172         
173         int active_marker;                      /* Index of active-marker (first marker = 1) */
174         int flag;                                       /* flags for this action */
175 } bAction;
176
177
178 /* ------------- Action Editor --------------------- */
179
180 /* Storage for Dopesheet/Grease-Pencil Editor data */
181 typedef struct bDopeSheet {
182         ID              *source;                /* currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil) */
183         ListBase chanbase;              /* cache for channels (only initialised when pinned) */  // XXX not used!
184         
185         int filterflag;                 /* flags to use for filtering data */
186         int flag;                               /* standard flags */
187 } bDopeSheet;
188
189 /* Action Editor Space. This is defined here instead of in DNA_space_types.h */
190 typedef struct SpaceAction {
191         struct SpaceLink *next, *prev;
192         ListBase regionbase;            /* storage of regions for inactive spaces */
193         int spacetype;
194         float blockscale;
195
196         short blockhandler[8];
197
198         View2D v2d;                                     /* depricated, copied to region */
199         
200         bAction         *action;                /* the currently active action */
201         bDopeSheet      ads;                    /* the currently active context (when not showing action) */
202         
203         char  mode, autosnap;           /* mode: editing context; autosnap: automatic keyframe snapping mode   */
204         short flag, actnr;                      /* flag: bitmapped settings; */
205         short pin, lock;                        /* pin: keep showing current action; actnr: used for finding chosen action from menu; lock: lock time to other windows */
206         short actwidth;                         /* width of the left-hand side name panel (in pixels?) */  // XXX depreceated!
207         float timeslide;                        /* for Time-Slide transform mode drawing - current frame? */
208 } SpaceAction;
209
210
211 /* -------------- Action Flags -------------- */
212
213 /* Action Channel flags */
214 typedef enum ACHAN_FLAG {
215         ACHAN_SELECTED  = (1<<0),
216         ACHAN_HILIGHTED = (1<<1),
217         ACHAN_HIDDEN    = (1<<2),
218         ACHAN_PROTECTED = (1<<3),
219         ACHAN_EXPANDED  = (1<<4),
220         ACHAN_SHOWIPO   = (1<<5),
221         ACHAN_SHOWCONS  = (1<<6),
222         ACHAN_MOVED     = (1<<31),
223 } ACHAN_FLAG; 
224
225
226 /* Action Group flags */
227 typedef enum AGRP_FLAG {
228         AGRP_SELECTED   = (1<<0),
229         AGRP_ACTIVE     = (1<<1),
230         AGRP_PROTECTED  = (1<<2),
231         AGRP_EXPANDED   = (1<<3),
232         
233         AGRP_TEMP               = (1<<30),
234         AGRP_MOVED              = (1<<31)
235 } AGRP_FLAG;
236
237
238 /* 'Action' Channel flags */
239 typedef enum ACT_FLAG {
240         ACTC_SELECTED   = (1<<0),
241         ACTC_EXPANDED   = (1<<1),
242 } ACT_FLAG;
243
244 /* ------------ DopeSheet Flags ------------------ */
245
246 /* DopeSheet filter-flag */
247 typedef enum DOPESHEET_FILTERFLAG {
248                 /* general filtering */
249         ADS_FILTER_ONLYSEL                      = (1<<0),
250         
251                 /* datatype-based filtering */
252         ADS_FILTER_NOOBJ                        = (1<<4),
253         ADS_FILTER_NOARM                        = (1<<5),
254         ADS_FILTER_NOSHAPEKEYS          = (1<<6),
255         ADS_FILTER_NOIPOS                       = (1<<7),
256         ADS_FILTER_NOACTS                       = (1<<8),
257         ADS_FILTER_NOCONSTRAINTS        = (1<<9),
258         ADS_FILTER_NOCAM                        = (1<<10),
259         ADS_FILTER_NOMAT                        = (1<<11),
260         ADS_FILTER_NOLAM                        = (1<<12),
261         ADS_FILTER_NOCUR                        = (1<<13),
262         
263                 /* combination filters (some only used at runtime) */
264         ADS_FILTER_NOOBDATA = (ADS_FILTER_NOCAM|ADS_FILTER_NOMAT|ADS_FILTER_NOLAM|ADS_FILTER_NOCUR),
265         ADS_FILTER_NLADUMMY = (ADS_FILTER_NOACTS|ADS_FILTER_NOSHAPEKEYS|ADS_FILTER_NOOBDATA),
266 } DOPESHEET_FILTERFLAG; 
267
268 /* DopeSheet general flags */
269 //typedef enum DOPESHEET_FLAG {
270         
271 //} DOPESHEET_FLAG;
272
273 /* ------------ Action Editor Flags -------------- */
274
275 /* SpaceAction flag */
276 typedef enum SACTION_FLAG {
277                 /* during transform (only set for TimeSlide) */
278         SACTION_MOVING  = (1<<0),       
279                 /* show sliders (if relevant) */
280         SACTION_SLIDERS = (1<<1),       
281                 /* draw time in seconds instead of time in frames */
282         SACTION_DRAWTIME = (1<<2),
283                 /* don't filter action channels according to visibility */
284         SACTION_NOHIDE = (1<<3),
285                 /* don't kill overlapping keyframes after transform */
286         SACTION_NOTRANSKEYCULL = (1<<4),
287                 /* don't include keyframes that are out of view */
288         SACTION_HORIZOPTIMISEON = (1<<5),
289                 /* hack for moving pose-markers (temp flag)  */
290         SACTION_POSEMARKERS_MOVE = (1<<6),
291                 /* don't draw action channels using group colours (where applicable) */
292         SACTION_NODRAWGCOLORS = (1<<7),
293                 /* don't draw current frame number beside frame indicator */
294         SACTION_NODRAWCFRANUM = (1<<8),
295 } SACTION_FLAG; 
296
297 /* SpaceAction Mode Settings */
298 typedef enum SACTCONT_MODES {
299                 /* action (default) */
300         SACTCONT_ACTION = 0,
301                 /* editing of shapekey's IPO block */
302         SACTCONT_SHAPEKEY,
303                 /* editing of gpencil data */
304         SACTCONT_GPENCIL,
305                 /* dopesheet */
306         SACTCONT_DOPESHEET
307 } SACTCONTEXT_MODES;
308
309 /* SpaceAction AutoSnap Settings (also used by SpaceNLA) */
310 typedef enum SACTSNAP_MODES {
311                 /* no auto-snap */
312         SACTSNAP_OFF = 0,       
313                 /* snap to 1.0 frame/second intervals */
314         SACTSNAP_STEP,
315                 /* snap to actual frames/seconds (nla-action time) */
316         SACTSNAP_FRAME,
317                 /* snap to nearest marker */
318         SACTSNAP_MARKER,
319 } SACTSNAP_MODES;       
320  
321  
322 /* --------- Pose Flags --------------- */
323
324 /* Pose->flag */
325 typedef enum POSE_FLAG {
326                 /* results in armature_rebuild_pose being called */
327         POSE_RECALC = (1<<0),
328                 /* prevents any channel from getting overridden by anim from IPO */
329         POSE_LOCKED     = (1<<1),
330                 /* clears the POSE_LOCKED flag for the next time the pose is evaluated */
331         POSE_DO_UNLOCK  = (1<<2),
332                 /* pose has constraints which depend on time (used when depsgraph updates for a new frame) */
333         POSE_CONSTRAINTS_TIMEDEPEND = (1<<3),
334                 /* recalculate bone paths */
335         POSE_RECALCPATHS = (1<<4),
336 } POSE_FLAG;
337
338 /* PoseChannel (transform) flags */
339 enum    {
340         POSE_LOC                =       0x0001,
341         POSE_ROT                =       0x0002,
342         POSE_SIZE               =       0x0004,
343         POSE_IK_MAT             =       0x0008,
344         POSE_UNUSED2    =       0x0010,
345         POSE_UNUSED3    =       0x0020,
346         POSE_UNUSED4    =       0x0040,
347         POSE_UNUSED5    =       0x0080,
348         POSE_HAS_IK             =       0x0100,
349         POSE_CHAIN              =       0x0200,
350         POSE_DONE               =   0x0400,
351         POSE_KEY                =       0x1000,
352         POSE_STRIDE             =       0x2000
353 };
354
355 /* PoseChannel constflag (constraint detection) */
356 typedef enum PCHAN_CONSTFLAG {
357         PCHAN_HAS_IK            = (1<<0),
358         PCHAN_HAS_CONST         = (1<<1),
359                 /* only used for drawing Posemode, not stored in channel */
360         PCHAN_HAS_ACTION        = (1<<2),
361         PCHAN_HAS_TARGET        = (1<<3),
362                 /* only for drawing Posemode too */
363         PCHAN_HAS_STRIDE        = (1<<4)
364 } PCHAN_CONSTFLAG;
365
366 /* PoseChannel->ikflag */
367 typedef enum PCHAN_IKFLAG {
368         BONE_IK_NO_XDOF = (1<<0),
369         BONE_IK_NO_YDOF = (1<<1),
370         BONE_IK_NO_ZDOF = (1<<2),
371
372         BONE_IK_XLIMIT  = (1<<3),
373         BONE_IK_YLIMIT  = (1<<4),
374         BONE_IK_ZLIMIT  = (1<<5),
375         
376         BONE_IK_NO_XDOF_TEMP = (1<<10),
377         BONE_IK_NO_YDOF_TEMP = (1<<11),
378         BONE_IK_NO_ZDOF_TEMP = (1<<12)
379 } PCHAN_IKFLAG;
380
381 /* PoseChannel->rotmode */
382 typedef enum PCHAN_ROTMODE {
383                 /* quaternion rotations (default, and for older Blender versions) */
384         PCHAN_ROT_QUAT  = 0,
385                 /* euler rotations (xyz only) */
386         PCHAN_ROT_EUL,
387 } PCHAN_ROTMODE;
388
389 #endif
390