== PyConstraints ==
[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 struct Text;
43 #ifndef __cplusplus
44 struct PyObject;
45 #endif
46
47 /* channels reside in Object or Action (ListBase) constraintChannels */
48 typedef struct bConstraintChannel{
49         struct bConstraintChannel *next, *prev;
50         Ipo                     *ipo;
51         short           flag;
52         char            name[30];
53 } bConstraintChannel;
54
55 typedef struct bConstraint{
56         struct bConstraint *next, *prev;
57         void            *data;          /*      Constraint data (a valid constraint type) */
58         short           type;           /*      Constraint type */
59         short           flag;           /*      Flag */
60         short           reserved1;      
61         char            name[30];       /*      Constraint name */
62
63         float           enforce;
64 } bConstraint;
65
66 /* Python Script Constraint */
67 typedef struct bPythonConstraint {
68         Object *tar;                    /* object to use as target (if required) */
69         char subtarget[32];     /* bone to use as subtarget (if required) */
70         
71         struct Text *text;              /* text-buffer (containing script) to execute */
72         IDProperty *prop;               /* 'id-properties' used to store custom properties for constraint */
73         
74         int flag;                               /* general settings/state indicators accessed by bitmapping */
75         int pad;
76 } bPythonConstraint;
77
78 /* Single-target subobject constraints */
79 typedef struct bKinematicConstraint{
80         Object          *tar;
81         short           iterations;             /* Maximum number of iterations to try */
82         short           flag;                   /* Like CONSTRAINT_IK_TIP */
83         int                     rootbone;       /* index to rootbone, if zero go all the way to mother bone */
84         char            subtarget[32];  /* String to specify sub-object target */
85
86         float           weight;                 /* Weight of goal in IK tree */
87         float           orientweight;   /* Amount of rotation a target applies on chain */
88         float           grabtarget[3];  /* for target-less IK */
89         int                     pad;
90 } bKinematicConstraint;
91
92 typedef struct bTrackToConstraint{
93         Object          *tar;
94         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*/
95         int                     reserved2;
96         int                     flags;
97         int                     pad;
98         char            subtarget[32];
99 } bTrackToConstraint;
100
101 typedef struct bRotateLikeConstraint{
102         Object          *tar;
103         int                     flag;
104         int                     reserved1;
105         char            subtarget[32];
106 } bRotateLikeConstraint;
107
108 typedef struct bLocateLikeConstraint{
109         Object          *tar;
110         int                     flag;
111         int                     reserved1;
112         char            subtarget[32];
113 } bLocateLikeConstraint;
114
115 typedef struct bMinMaxConstraint{
116         Object          *tar;
117         int                     minmaxflag;
118         float                   offset;
119         int                             flag;
120         short                   sticky, stuck, pad1, pad2; /* for backward compatability */
121         float                   cache[3];
122         char            subtarget[32];
123 } bMinMaxConstraint;
124
125 typedef struct bSizeLikeConstraint{
126         Object          *tar;
127         int                     flag;
128         int                     reserved1;
129         char            subtarget[32];
130 } bSizeLikeConstraint;
131
132 typedef struct bActionConstraint{
133         Object          *tar;
134         short           type;
135         short           local;
136         int             start;
137         int             end;
138         float           min;
139         float           max;
140         int             pad;
141         struct bAction  *act;
142         char            subtarget[32];
143 } bActionConstraint;
144
145 /* Locked Axis Tracking constraint */
146 typedef struct bLockTrackConstraint{
147         Object          *tar;
148         int                     trackflag;
149         int                     lockflag;
150         char            subtarget[32];
151 } bLockTrackConstraint;
152
153 /* Follow Path constraints */
154 typedef struct bFollowPathConstraint{
155         Object          *tar;   /* Must be path object */
156         float           offset; /* Offset in time on the path (in frame) */
157         int                     followflag;
158         int                     trackflag;
159         int                     upflag;
160 } bFollowPathConstraint;
161
162 /* Distance Limiting constraints */
163 typedef struct bDistanceLimitConstraint{
164         Object  *tar;
165         char            subtarget[32];
166         float           pad1;
167         float           pad2;
168         float           distance;
169         float           offset[3];
170 } bDistanceLimitConstraint;     
171
172
173 /* Zero-target constraints */
174 typedef struct bRotationConstraint{
175         float xmin, xmax;
176         float ymin, ymax;
177         float zmin, zmax;
178 } bRotationConstraint;
179
180 /* Stretch to constraint */
181 typedef struct bStretchToConstraint{
182         Object          *tar;
183         int                     volmode; 
184         int         plane;
185         float           orglength;
186         float           bulge;
187         char            subtarget[32];
188 } bStretchToConstraint;
189
190 /* transform limiting constraints - zero target */
191 typedef struct bLocLimitConstraint{
192         float           xmin, xmax;
193         float           ymin, ymax;
194         float           zmin, zmax;
195         short           flag;
196         short           flag2;
197 } bLocLimitConstraint;
198
199 typedef struct bRotLimitConstraint{
200         float           xmin, xmax;
201         float           ymin, ymax;
202         float           zmin, zmax;
203         short           flag;
204         short           pad1;
205 } bRotLimitConstraint;
206
207 typedef struct bSizeLimitConstraint{
208         float           xmin, xmax;
209         float           ymin, ymax;
210         float           zmin, zmax;
211         short           flag;
212         short           pad1;
213 } bSizeLimitConstraint;
214
215 /* Rigid Body constraint */
216 typedef struct bRigidBodyJointConstraint{
217         Object          *tar;
218         Object          *child;
219         int         type;
220         float       pivX;
221         float       pivY;
222         float       pivZ;
223         float       axX;
224         float       axY;
225         float       axZ;
226         float       minLimit[6];
227         float       maxLimit[6];
228         float       extraFz;
229         short           flag;
230         short           pad;
231         short           pad1;
232         short           pad2;
233 } bRigidBodyJointConstraint;
234
235 /* ClampTo Constraint */
236 typedef struct bClampToConstraint {
237         Object          *tar;                   /* 'target' must be a curve */
238         int                     flag;                   /* which axis/plane to compare owner's location on  */
239         int                     pad;
240 } bClampToConstraint;
241
242 /* bConstraint.type */
243 #define CONSTRAINT_TYPE_NULL            0
244 #define CONSTRAINT_TYPE_CHILDOF         1       /* Unimplemented */
245 #define CONSTRAINT_TYPE_TRACKTO         2       
246 #define CONSTRAINT_TYPE_KINEMATIC       3       
247 #define CONSTRAINT_TYPE_FOLLOWPATH      4
248 #define CONSTRAINT_TYPE_ROTLIMIT        5       /* Unimplemented no longer :) - Aligorith */
249 #define CONSTRAINT_TYPE_LOCLIMIT        6       /* Unimplemented no longer :) - Aligorith */
250 #define CONSTRAINT_TYPE_SIZELIMIT       7       /* Unimplemented no longer :) - Aligorith */
251 #define CONSTRAINT_TYPE_ROTLIKE         8       
252 #define CONSTRAINT_TYPE_LOCLIKE         9       
253 #define CONSTRAINT_TYPE_SIZELIKE        10
254 #define CONSTRAINT_TYPE_PYTHON          11      /* Unimplemented */
255 #define CONSTRAINT_TYPE_ACTION          12
256 #define CONSTRAINT_TYPE_LOCKTRACK       13      /* New Tracking constraint that locks an axis in place - theeth */
257 #define CONSTRAINT_TYPE_DISTANCELIMIT   14 
258 #define CONSTRAINT_TYPE_STRETCHTO       15  /* claiming this to be mine :) is in tuhopuu bjornmose */ 
259 #define CONSTRAINT_TYPE_MINMAX      16  /* floor constraint */
260 #define CONSTRAINT_TYPE_RIGIDBODYJOINT 17 /* rigidbody constraint */
261 #define CONSTRAINT_TYPE_CLAMPTO         18  /* clampto constraint */            
262
263 /* bConstraint.flag */
264                 /* expand for UI */
265 #define CONSTRAINT_EXPAND               0x01
266                 /* pre-check for illegal object name or bone name */
267 #define CONSTRAINT_DISABLE              0x04
268                 /* flags 0x2 and 0x8 were used in past, skip this */
269                 /* to indicate which Ipo should be shown, maybe for 3d access later too */
270 #define CONSTRAINT_ACTIVE               0x10
271                 /* only for Pose, evaluates constraints in posechannel local space */
272 #define CONSTRAINT_LOCAL                0x20
273
274
275 /* bConstraintChannel.flag */
276 #define CONSTRAINT_CHANNEL_SELECT               0x01
277 #define CONSTRAINT_CHANNEL_PROTECTED    0x02
278
279 /**
280  * The flags for ROTLIKE, LOCLIKE and SIZELIKE should be kept identical
281  * (that is, same effect, different name). It simplifies the Python API access a lot.
282  */
283
284 /* bRotateLikeConstraint.flag */
285 #define ROTLIKE_X               0x01
286 #define ROTLIKE_Y               0x02
287 #define ROTLIKE_Z               0x04
288 #define ROTLIKE_X_INVERT        0x10
289 #define ROTLIKE_Y_INVERT        0x20
290 #define ROTLIKE_Z_INVERT        0x40
291 #define ROTLIKE_OFFSET  0x80
292
293 /* bLocateLikeConstraint.flag */
294 #define LOCLIKE_X                       0x01
295 #define LOCLIKE_Y                       0x02
296 #define LOCLIKE_Z                       0x04
297 #define LOCLIKE_TIP                     0x08
298 #define LOCLIKE_X_INVERT        0x10
299 #define LOCLIKE_Y_INVERT        0x20
300 #define LOCLIKE_Z_INVERT        0x40
301 #define LOCLIKE_OFFSET          0x80
302  
303 /* bSizeLikeConstraint.flag */
304 #define SIZELIKE_X              0x01
305 #define SIZELIKE_Y              0x02
306 #define SIZELIKE_Z              0x04
307 #define SIZELIKE_OFFSET 0x80
308
309 /* Axis flags */
310 #define LOCK_X          0x00
311 #define LOCK_Y          0x01
312 #define LOCK_Z          0x02
313
314 #define UP_X            0x00
315 #define UP_Y            0x01
316 #define UP_Z            0x02
317
318 #define TRACK_X         0x00
319 #define TRACK_Y         0x01
320 #define TRACK_Z         0x02
321 #define TRACK_nX        0x03
322 #define TRACK_nY        0x04
323 #define TRACK_nZ        0x05
324
325 /* bTrackToConstraint->flags */
326 #define TARGET_Z_UP 0x01
327
328 #define VOLUME_XZ       0x00
329 #define VOLUME_X        0x01
330 #define VOLUME_Z        0x02
331 #define NO_VOLUME       0x03
332
333 #define PLANE_X         0x00
334 #define PLANE_Y         0x01
335 #define PLANE_Z         0x02
336
337 #define CLAMPTO_AUTO    0
338 #define CLAMPTO_X               1
339 #define CLAMPTO_Y               2
340 #define CLAMPTO_Z               3
341
342 /* bKinematicConstraint->flag */
343 #define CONSTRAINT_IK_TIP               1
344 #define CONSTRAINT_IK_ROT               2
345 #define CONSTRAINT_IK_AUTO              4
346 #define CONSTRAINT_IK_TEMP              8
347 #define CONSTRAINT_IK_STRETCH   16
348 #define CONSTRAINT_IK_POS               32
349
350 /* MinMax (floor) flags */
351 #define MINMAX_STICKY   0x01
352 #define MINMAX_STUCK    0x02
353 #define MINMAX_USEROT   0x04
354
355 /* transform limiting constraints -> flag  */
356 #define LIMIT_XMIN 0x01
357 #define LIMIT_XMAX 0x02
358 #define LIMIT_YMIN 0x04
359 #define LIMIT_YMAX 0x08
360 #define LIMIT_ZMIN 0x10
361 #define LIMIT_ZMAX 0x20
362
363 #define LIMIT_XROT 0x01
364 #define LIMIT_YROT 0x02
365 #define LIMIT_ZROT 0x04
366
367 #define LIMIT_NOPARENT 0x01
368
369 /* python constraint -> flag */
370 #define PYCON_USETARGETS        0x01
371 #define PYCON_SCRIPTERROR       0x02
372
373 #define CONSTRAINT_DRAW_PIVOT 0x40
374
375 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
376 #define CONSTRAINT_RB_BALL              1
377 #define CONSTRAINT_RB_HINGE             2
378 #define CONSTRAINT_RB_VEHICLE   11
379 #define CONSTRAINT_RB_GENERIC6DOF 12
380
381 #endif