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