=== BPY ===
[blender-staging.git] / source / blender / makesdna / DNA_constraint_types.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  * Constraint DNA data
32  */
33
34 #ifndef DNA_CONSTRAINT_TYPES_H
35 #define DNA_CONSTRAINT_TYPES_H
36
37 #include "DNA_ID.h"
38 #include "DNA_ipo_types.h"
39 #include "DNA_object_types.h"
40
41 struct Action;
42
43 /* channels reside in Object or Action (ListBase) constraintChannels */
44 typedef struct bConstraintChannel{
45         struct bConstraintChannel *next, *prev;
46         Ipo                     *ipo;
47         short           flag;
48         char            name[30];
49 } bConstraintChannel;
50
51 typedef struct bConstraint{
52         struct bConstraint *next, *prev;
53         void            *data;          /*      Constraint data (a valid constraint type) */
54         short           type;           /*      Constraint type */
55         short           flag;           /*      Flag */
56         short           reserved1;      
57         char            name[30];       /*      Constraint name */
58
59         float           enforce;
60 } bConstraint;
61
62 /* Single-target subobject constraints */
63 typedef struct bKinematicConstraint{
64         Object          *tar;
65         short           iterations;             /* Maximum number of iterations to try */
66         short           flag;                   /* Like CONSTRAINT_IK_TIP */
67         int                     rootbone;       /* index to rootbone, if zero go all the way to mother bone */
68         char            subtarget[32];  /* String to specify sub-object target */
69
70         float           weight;                 /* Weight of goal in IK tree */
71         float           orientweight;   /* Amount of rotation a target applies on chain */
72         float           grabtarget[3];  /* for target-less IK */
73         int                     pad;
74 } bKinematicConstraint;
75
76 typedef struct bTrackToConstraint{
77         Object          *tar;
78         int                     reserved1; /* I'll be using reserved1 and reserved2 as Track and Up flags, not sure if that's what they were intented for anyway. Not sure either if it would create backward incompatibility if I were to rename them. - theeth*/
79         int                     reserved2;
80         int                     flags;
81         int                     pad;
82         char            subtarget[32];
83 } bTrackToConstraint;
84
85 typedef struct bRotateLikeConstraint{
86         Object          *tar;
87         int                     flag;
88         int                     reserved1;
89         char            subtarget[32];
90 } bRotateLikeConstraint;
91
92 typedef struct bLocateLikeConstraint{
93         Object          *tar;
94         int                     flag;
95         int                     reserved1;
96         char            subtarget[32];
97 } bLocateLikeConstraint;
98
99 typedef struct bMinMaxConstraint{
100         Object          *tar;
101         int                     minmaxflag;
102         float                   offset;
103         int                             flag;
104         short                   sticky, stuck, pad1, pad2; /* for backward compatability */
105         float                   cache[3];
106         char            subtarget[32];
107 } bMinMaxConstraint;
108
109 typedef struct bSizeLikeConstraint{
110         Object          *tar;
111         int                     flag;
112         int                     reserved1;
113         char            subtarget[32];
114 } bSizeLikeConstraint;
115
116 typedef struct bActionConstraint{
117         Object          *tar;
118         short           type;
119         short           local;
120         int             start;
121         int             end;
122         float           min;
123         float           max;
124         int             pad;
125         struct bAction  *act;
126         char            subtarget[32];
127 } bActionConstraint;
128
129 /* Locked Axis Tracking constraint */
130 typedef struct bLockTrackConstraint{
131         Object          *tar;
132         int                     trackflag;
133         int                     lockflag;
134         char            subtarget[32];
135 } bLockTrackConstraint;
136
137 /* Follow Path constraints */
138 typedef struct bFollowPathConstraint{
139         Object          *tar;   /* Must be path object */
140         float           offset; /* Offset in time on the path (in frame) */
141         int                     followflag;
142         int                     trackflag;
143         int                     upflag;
144 } bFollowPathConstraint;
145
146 /* Distance Limiting constraints */
147 typedef struct bDistanceLimitConstraint{
148         Object  *tar;
149         char            subtarget[32];
150         float           pad1;
151         float           pad2;
152         float           distance;
153         float           offset[3];
154 } bDistanceLimitConstraint;     
155
156
157 /* Zero-target constraints */
158 typedef struct bRotationConstraint{
159         float xmin, xmax;
160         float ymin, ymax;
161         float zmin, zmax;
162 } bRotationConstraint;
163
164 /* Stretch to constraint */
165 typedef struct bStretchToConstraint{
166         Object          *tar;
167         int                     volmode; 
168         int         plane;
169         float           orglength;
170         float           bulge;
171         char            subtarget[32];
172 } bStretchToConstraint;
173
174 /* transform limiting constraints - zero target */
175 typedef struct bLocLimitConstraint{
176         float           xmin, xmax;
177         float           ymin, ymax;
178         float           zmin, zmax;
179         short           flag;
180         short           flag2;
181 } bLocLimitConstraint;
182
183 typedef struct bRotLimitConstraint{
184         float           xmin, xmax;
185         float           ymin, ymax;
186         float           zmin, zmax;
187         short           flag;
188         short           pad1;
189 } bRotLimitConstraint;
190
191 typedef struct bSizeLimitConstraint{
192         float           xmin, xmax;
193         float           ymin, ymax;
194         float           zmin, zmax;
195         short           flag;
196         short           pad1;
197 } bSizeLimitConstraint;
198
199 /* Rigid Body constraint */
200 typedef struct bRigidBodyJointConstraint{
201         Object          *tar;
202         Object          *child;
203         int         type;
204         float       pivX;
205         float       pivY;
206         float       pivZ;
207         float       axX;
208         float       axY;
209         float       axZ;
210         float       minLimit[6];
211         float       maxLimit[6];
212         float       extraFz;
213         short           flag;
214         short           pad;
215         short           pad1;
216         short           pad2;
217 } bRigidBodyJointConstraint;
218
219 /* bConstraint.type */
220 #define CONSTRAINT_TYPE_NULL            0
221 #define CONSTRAINT_TYPE_CHILDOF         1       /* Unimplemented */
222 #define CONSTRAINT_TYPE_TRACKTO         2       
223 #define CONSTRAINT_TYPE_KINEMATIC       3       
224 #define CONSTRAINT_TYPE_FOLLOWPATH      4
225 #define CONSTRAINT_TYPE_ROTLIMIT        5       /* Unimplemented no longer :) - Aligorith */
226 #define CONSTRAINT_TYPE_LOCLIMIT        6       /* Unimplemented no longer :) - Aligorith */
227 #define CONSTRAINT_TYPE_SIZELIMIT       7       /* Unimplemented no longer :) - Aligorith */
228 #define CONSTRAINT_TYPE_ROTLIKE         8       
229 #define CONSTRAINT_TYPE_LOCLIKE         9       
230 #define CONSTRAINT_TYPE_SIZELIKE        10
231 #define CONSTRAINT_TYPE_PYTHON          11      /* Unimplemented */
232 #define CONSTRAINT_TYPE_ACTION          12
233 #define CONSTRAINT_TYPE_LOCKTRACK       13      /* New Tracking constraint that locks an axis in place - theeth */
234 #define CONSTRAINT_TYPE_DISTANCELIMIT   14 
235 #define CONSTRAINT_TYPE_STRETCHTO       15  /* claiming this to be mine :) is in tuhopuu bjornmose */ 
236 #define CONSTRAINT_TYPE_MINMAX      16  /* floor constraint */
237 #define CONSTRAINT_TYPE_RIGIDBODYJOINT 17 /* rigidbody constraint */
238
239 /* bConstraint.flag */
240                 /* expand for UI */
241 #define CONSTRAINT_EXPAND               0x01
242                 /* pre-check for illegal object name or bone name */
243 #define CONSTRAINT_DISABLE              0x04
244                 /* flags 0x2 and 0x8 were used in past, skip this */
245                 /* to indicate which Ipo should be shown, maybe for 3d access later too */
246 #define CONSTRAINT_ACTIVE               0x10
247                 /* only for Pose, evaluates constraints in posechannel local space */
248 #define CONSTRAINT_LOCAL                0x20
249
250
251 /* bConstraintChannel.flag */
252 #define CONSTRAINT_CHANNEL_SELECT               0x01
253 #define CONSTRAINT_CHANNEL_PROTECTED    0x02
254
255 /**
256  * The flags for ROTLIKE, LOCLIKE and SIZELIKE should be kept identical
257  * (that is, same effect, different name). It simplifies the Python API access a lot.
258  */
259
260 /* bRotateLikeConstraint.flag */
261 #define ROTLIKE_X               0x01
262 #define ROTLIKE_Y               0x02
263 #define ROTLIKE_Z               0x04
264 #define ROTLIKE_X_INVERT        0x10
265 #define ROTLIKE_Y_INVERT        0x20
266 #define ROTLIKE_Z_INVERT        0x40
267 #define ROTLIKE_OFFSET  0x80
268
269 /* bLocateLikeConstraint.flag */
270 #define LOCLIKE_X                       0x01
271 #define LOCLIKE_Y                       0x02
272 #define LOCLIKE_Z                       0x04
273 #define LOCLIKE_TIP                     0x08
274 #define LOCLIKE_X_INVERT        0x10
275 #define LOCLIKE_Y_INVERT        0x20
276 #define LOCLIKE_Z_INVERT        0x40
277 #define LOCLIKE_OFFSET          0x80
278  
279 /* bSizeLikeConstraint.flag */
280 #define SIZELIKE_X              0x01
281 #define SIZELIKE_Y              0x02
282 #define SIZELIKE_Z              0x04
283 #define SIZELIKE_OFFSET 0x80
284
285 /* Axis flags */
286 #define LOCK_X          0x00
287 #define LOCK_Y          0x01
288 #define LOCK_Z          0x02
289
290 #define UP_X            0x00
291 #define UP_Y            0x01
292 #define UP_Z            0x02
293
294 #define TRACK_X         0x00
295 #define TRACK_Y         0x01
296 #define TRACK_Z         0x02
297 #define TRACK_nX        0x03
298 #define TRACK_nY        0x04
299 #define TRACK_nZ        0x05
300
301 /* bTrackToConstraint->flags */
302 #define TARGET_Z_UP 0x01
303
304 #define VOLUME_XZ       0x00
305 #define VOLUME_X        0x01
306 #define VOLUME_Z        0x02
307 #define NO_VOLUME       0x03
308
309 #define PLANE_X         0x00
310 #define PLANE_Y         0x01
311 #define PLANE_Z         0x02
312
313 /* bKinematicConstraint->flag */
314 #define CONSTRAINT_IK_TIP               1
315 #define CONSTRAINT_IK_ROT               2
316 #define CONSTRAINT_IK_AUTO              4
317 #define CONSTRAINT_IK_TEMP              8
318 #define CONSTRAINT_IK_STRETCH   16
319 #define CONSTRAINT_IK_POS               32
320
321 /* MinMax (floor) flags */
322 #define MINMAX_STICKY   0x01
323 #define MINMAX_STUCK    0x02
324 #define MINMAX_USEROT   0x04
325
326 /* transform limiting constraints -> flag  */
327 #define LIMIT_XMIN 0x01
328 #define LIMIT_XMAX 0x02
329 #define LIMIT_YMIN 0x04
330 #define LIMIT_YMAX 0x08
331 #define LIMIT_ZMIN 0x10
332 #define LIMIT_ZMAX 0x20
333
334 #define LIMIT_XROT 0x01
335 #define LIMIT_YROT 0x02
336 #define LIMIT_ZROT 0x04
337
338 #define LIMIT_NOPARENT 0x01
339
340 #define CONSTRAINT_DRAW_PIVOT 0x40
341
342 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
343 #define CONSTRAINT_RB_BALL              1
344 #define CONSTRAINT_RB_HINGE             2
345 #define CONSTRAINT_RB_VEHICLE   11
346 #define CONSTRAINT_RB_GENERIC6DOF 12
347
348 #endif