== Transformation Constraint ==
[blender.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): 2007, Joshua Leung, major recode
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 /* A Constraint */
56 typedef struct bConstraint {
57         struct bConstraint *next, *prev;
58         void            *data;          /*      Constraint data (a valid constraint type) */
59         short           type;           /*      Constraint type */
60         short           flag;           /*      Flag - General Settings */
61         
62         char            ownspace;       /*      Space that owner should be evaluated in         */
63         char            tarspace;       /*      Space that target should be evaluated in        */
64         
65         char            name[30];       /*      Constraint name */
66         
67         float           enforce;        /*      Amount of influence exherted by constraint (0.0-1.0) */
68 } bConstraint;
69
70
71 /* Python Script Constraint */
72 typedef struct bPythonConstraint {
73         Object *tar;                    /* object to use as target (if required) */
74         char subtarget[32];     /* bone to use as subtarget (if required) */
75         
76         struct Text *text;              /* text-buffer (containing script) to execute */
77         IDProperty *prop;               /* 'id-properties' used to store custom properties for constraint */
78         
79         int flag;                               /* general settings/state indicators accessed by bitmapping */
80         int pad;
81 } bPythonConstraint;
82
83 /* Single-target subobject constraints ---------------------  */
84 /* Inverse-Kinematics (IK) constraint */
85 typedef struct bKinematicConstraint {
86         Object          *tar;
87         short           iterations;             /* Maximum number of iterations to try */
88         short           flag;                   /* Like CONSTRAINT_IK_TIP */
89         int                     rootbone;       /* index to rootbone, if zero go all the way to mother bone */
90         char            subtarget[32];  /* String to specify sub-object target */
91
92         float           weight;                 /* Weight of goal in IK tree */
93         float           orientweight;   /* Amount of rotation a target applies on chain */
94         float           grabtarget[3];  /* for target-less IK */
95         int                     pad;
96 } bKinematicConstraint;
97
98 /* Track To Constraint */
99 typedef struct bTrackToConstraint {
100         Object          *tar;
101         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*/
102         int                     reserved2;
103         int                     flags;
104         int                     pad;
105         char            subtarget[32];
106 } bTrackToConstraint;
107
108 /* Copy Rotation Constraint */
109 typedef struct bRotateLikeConstraint {
110         Object          *tar;
111         int                     flag;
112         int                     reserved1;
113         char            subtarget[32];
114 } bRotateLikeConstraint;
115
116 /* Copy Location Constraint */
117 typedef struct bLocateLikeConstraint {
118         Object          *tar;
119         int                     flag;
120         int                     reserved1;
121         char            subtarget[32];
122 } bLocateLikeConstraint;
123
124 /* Floor Constraint */
125 typedef struct bMinMaxConstraint {
126         Object          *tar;
127         int                     minmaxflag;
128         float                   offset;
129         int                             flag;
130         short                   sticky, stuck, pad1, pad2; /* for backward compatability */
131         float                   cache[3];
132         char            subtarget[32];
133 } bMinMaxConstraint;
134
135 /* Copy Scale Constraint */
136 typedef struct bSizeLikeConstraint {
137         Object          *tar;
138         int                     flag;
139         int                     reserved1;
140         char            subtarget[32];
141 } bSizeLikeConstraint;
142
143 /* Action Constraint */
144 typedef struct bActionConstraint {
145         Object          *tar;
146         short           type;
147         short           local;  /* was used in versions prior to the Constraints recode */
148         int             start;
149         int             end;
150         float           min;
151         float           max;
152         int             pad;
153         struct bAction  *act;
154         char            subtarget[32];
155 } bActionConstraint;
156
157 /* Locked Axis Tracking constraint */
158 typedef struct bLockTrackConstraint {
159         Object          *tar;
160         int                     trackflag;
161         int                     lockflag;
162         char            subtarget[32];
163 } bLockTrackConstraint;
164
165 /* Follow Path constraints */
166 typedef struct bFollowPathConstraint {
167         Object          *tar;   /* Must be path object */
168         float           offset; /* Offset in time on the path (in frame) */
169         int                     followflag;
170         int                     trackflag;
171         int                     upflag;
172 } bFollowPathConstraint;
173
174 /* Stretch to constraint */
175 typedef struct bStretchToConstraint {
176         Object          *tar;
177         int                     volmode; 
178         int         plane;
179         float           orglength;
180         float           bulge;
181         char            subtarget[32];
182 } bStretchToConstraint;
183
184 /* Rigid Body constraint */
185 typedef struct bRigidBodyJointConstraint {
186         Object          *tar;
187         Object          *child;
188         int         type;
189         float       pivX;
190         float       pivY;
191         float       pivZ;
192         float       axX;
193         float       axY;
194         float       axZ;
195         float       minLimit[6];
196         float       maxLimit[6];
197         float       extraFz;
198         short           flag;
199         short           pad;
200         short           pad1;
201         short           pad2;
202 } bRigidBodyJointConstraint;
203
204 /* Clamp-To Constraint */
205 typedef struct bClampToConstraint {
206         Object          *tar;                   /* 'target' must be a curve */
207         int                     flag;                   /* which axis/plane to compare owner's location on  */
208         int                     pad;
209 } bClampToConstraint;
210
211 /* Child Of Constraint */
212 typedef struct bChildOfConstraint {
213         Object          *tar;                   /* object which will act as parent (or target comes from) */
214         int             flag;                   /* settings */
215         int                     pad;
216         float           invmat[4][4];   /* parent-inverse matrix to use */
217         char            subtarget[32];  /* string to specify a subobject target */
218 } bChildOfConstraint;
219
220 /* Generic Transform->Transform Constraint */
221 typedef struct bTransformConstraint {
222         Object          *tar;                   /* target (i.e. 'driver' object/bone) */
223         char            subtarget[32];  
224         
225         short           from, to;               /* can be loc(0) , rot(1),  or size(2) */
226         char            map[3];                 /* defines which target-axis deform is copied by each owner-axis */
227         char            expo;                   /* extrapolate motion? if 0, confine to ranges */
228         
229         float           from_min[3];    /* from_min/max defines range of target transform       */
230         float           from_max[3];    /*      to map on to to_min/max range.                  */
231         
232         float           to_min[3];              /* range of motion on owner caused by target  */
233         float           to_max[3];      
234 } bTransformConstraint;
235
236 /* transform limiting constraints - zero target ----------------------------  */
237 /* Limit Location Constraint */
238 typedef struct bLocLimitConstraint {
239         float           xmin, xmax;
240         float           ymin, ymax;
241         float           zmin, zmax;
242         short           flag;
243         short           flag2;
244 } bLocLimitConstraint;
245
246 /* Limit Rotation Constraint */
247 typedef struct bRotLimitConstraint {
248         float           xmin, xmax;
249         float           ymin, ymax;
250         float           zmin, zmax;
251         short           flag;
252         short           pad1;
253 } bRotLimitConstraint;
254
255 /* Limit Scaling Constraint */
256 typedef struct bSizeLimitConstraint {
257         float           xmin, xmax;
258         float           ymin, ymax;
259         float           zmin, zmax;
260         short           flag;
261         short           pad1;
262 } bSizeLimitConstraint;
263
264 /* bConstraint.type */
265 #define CONSTRAINT_TYPE_NULL            0
266 #define CONSTRAINT_TYPE_CHILDOF         1               /* Unimplemented non longer :) - during constraints recode, Aligorith */
267 #define CONSTRAINT_TYPE_TRACKTO         2       
268 #define CONSTRAINT_TYPE_KINEMATIC       3       
269 #define CONSTRAINT_TYPE_FOLLOWPATH      4
270 #define CONSTRAINT_TYPE_ROTLIMIT        5               /* Unimplemented no longer :) - Aligorith */
271 #define CONSTRAINT_TYPE_LOCLIMIT        6               /* Unimplemented no longer :) - Aligorith */
272 #define CONSTRAINT_TYPE_SIZELIMIT       7               /* Unimplemented no longer :) - Aligorith */
273 #define CONSTRAINT_TYPE_ROTLIKE         8       
274 #define CONSTRAINT_TYPE_LOCLIKE         9       
275 #define CONSTRAINT_TYPE_SIZELIKE        10
276 #define CONSTRAINT_TYPE_PYTHON          11              /* Unimplemented no longer :) - Aligorith. Scripts */
277 #define CONSTRAINT_TYPE_ACTION          12
278 #define CONSTRAINT_TYPE_LOCKTRACK       13              /* New Tracking constraint that locks an axis in place - theeth */
279 #define CONSTRAINT_TYPE_DISTANCELIMIT 14        /* was never properly coded - removed! */
280 #define CONSTRAINT_TYPE_STRETCHTO       15      /* claiming this to be mine :) is in tuhopuu bjornmose */ 
281 #define CONSTRAINT_TYPE_MINMAX      16          /* floor constraint */
282 #define CONSTRAINT_TYPE_RIGIDBODYJOINT 17       /* rigidbody constraint */
283 #define CONSTRAINT_TYPE_CLAMPTO         18      /* clampto constraint */        
284 #define CONSTRAINT_TYPE_TRANSFORM       19              /* transformation constraint */ 
285
286 /* bConstraint->flag */
287                 /* expand for UI */
288 #define CONSTRAINT_EXPAND               0x01
289                 /* pre-check for illegal object name or bone name */
290 #define CONSTRAINT_DISABLE              0x04
291                 /* flags 0x2 and 0x8 were used in past, skip this */
292                 /* to indicate which Ipo should be shown, maybe for 3d access later too */
293 #define CONSTRAINT_ACTIVE               0x10
294                 /* flag 0x20 was used to indicate that a constraint was evaluated using a 'local' hack for posebones only  */
295                 /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
296 #define CONSTRAINT_SPACEONCE    0x40
297
298 /* bConstraint->ownspace/tarspace */
299         /* default for all - worldspace */
300 #define CONSTRAINT_SPACE_WORLD                  0
301         /* for objects (relative to parent/without parent influence), for bones (along normals of bone, without parent/restposi) */
302 #define CONSTRAINT_SPACE_LOCAL                  1
303         /* for posechannels - pose space  */
304 #define CONSTRAINT_SPACE_POSE                   2
305         /* for posechannels - local with parent  */
306 #define CONSTRAINT_SPACE_PARLOCAL               3
307
308 /* bConstraintChannel.flag */
309 #define CONSTRAINT_CHANNEL_SELECT               0x01
310 #define CONSTRAINT_CHANNEL_PROTECTED    0x02
311
312 /**
313  * The flags for ROTLIKE, LOCLIKE and SIZELIKE should be kept identical
314  * (that is, same effect, different name). It simplifies the Python API access a lot.
315  */
316
317 /* bRotateLikeConstraint.flag */
318 #define ROTLIKE_X               0x01
319 #define ROTLIKE_Y               0x02
320 #define ROTLIKE_Z               0x04
321 #define ROTLIKE_X_INVERT        0x10
322 #define ROTLIKE_Y_INVERT        0x20
323 #define ROTLIKE_Z_INVERT        0x40
324 #define ROTLIKE_OFFSET  0x80
325
326 /* bLocateLikeConstraint.flag */
327 #define LOCLIKE_X                       0x01
328 #define LOCLIKE_Y                       0x02
329 #define LOCLIKE_Z                       0x04
330 #define LOCLIKE_TIP                     0x08
331 #define LOCLIKE_X_INVERT        0x10
332 #define LOCLIKE_Y_INVERT        0x20
333 #define LOCLIKE_Z_INVERT        0x40
334 #define LOCLIKE_OFFSET          0x80
335  
336 /* bSizeLikeConstraint.flag */
337 #define SIZELIKE_X              0x01
338 #define SIZELIKE_Y              0x02
339 #define SIZELIKE_Z              0x04
340 #define SIZELIKE_OFFSET 0x80
341
342 /* Axis flags */
343 #define LOCK_X          0x00
344 #define LOCK_Y          0x01
345 #define LOCK_Z          0x02
346
347 #define UP_X            0x00
348 #define UP_Y            0x01
349 #define UP_Z            0x02
350
351 #define TRACK_X         0x00
352 #define TRACK_Y         0x01
353 #define TRACK_Z         0x02
354 #define TRACK_nX        0x03
355 #define TRACK_nY        0x04
356 #define TRACK_nZ        0x05
357
358 /* bTrackToConstraint->flags */
359 #define TARGET_Z_UP 0x01
360
361 #define VOLUME_XZ       0x00
362 #define VOLUME_X        0x01
363 #define VOLUME_Z        0x02
364 #define NO_VOLUME       0x03
365
366 #define PLANE_X         0x00
367 #define PLANE_Y         0x01
368 #define PLANE_Z         0x02
369
370 /* Clamp-To Constraint ->flag */
371 #define CLAMPTO_AUTO    0
372 #define CLAMPTO_X               1
373 #define CLAMPTO_Y               2
374 #define CLAMPTO_Z               3
375
376 /* bKinematicConstraint->flag */
377 #define CONSTRAINT_IK_TIP               1
378 #define CONSTRAINT_IK_ROT               2
379 #define CONSTRAINT_IK_AUTO              4
380 #define CONSTRAINT_IK_TEMP              8
381 #define CONSTRAINT_IK_STRETCH   16
382 #define CONSTRAINT_IK_POS               32
383
384 /* MinMax (floor) flags */
385 #define MINMAX_STICKY   0x01
386 #define MINMAX_STUCK    0x02
387 #define MINMAX_USEROT   0x04
388
389 /* transform limiting constraints -> flag  */
390 #define LIMIT_XMIN 0x01
391 #define LIMIT_XMAX 0x02
392 #define LIMIT_YMIN 0x04
393 #define LIMIT_YMAX 0x08
394 #define LIMIT_ZMIN 0x10
395 #define LIMIT_ZMAX 0x20
396
397 #define LIMIT_XROT 0x01
398 #define LIMIT_YROT 0x02
399 #define LIMIT_ZROT 0x04
400
401 /* not used anymore - for older Limit Location constraints only */
402 #define LIMIT_NOPARENT 0x01
403
404 /* python constraint -> flag */
405 #define PYCON_USETARGETS        0x01
406 #define PYCON_SCRIPTERROR       0x02
407
408 /* ChildOf Constraint -> flag */
409 #define CHILDOF_LOCX    0x001
410 #define CHILDOF_LOCY    0x002
411 #define CHILDOF_LOCZ    0x004
412 #define CHILDOF_ROTX    0x008
413 #define CHILDOF_ROTY    0x010
414 #define CHILDOF_ROTZ    0x020
415 #define CHILDOF_SIZEX   0x040
416 #define CHILDOF_SIZEY   0x080
417 #define CHILDOF_SIZEZ   0x100
418
419 /* Rigid-Body Constraint */
420 #define CONSTRAINT_DRAW_PIVOT 0x40
421
422 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
423 #define CONSTRAINT_RB_BALL              1
424 #define CONSTRAINT_RB_HINGE             2
425 #define CONSTRAINT_RB_CONETWIST 4
426 #define CONSTRAINT_RB_VEHICLE   11
427 #define CONSTRAINT_RB_GENERIC6DOF 12
428
429 #endif