== file browser ==
[blender.git] / source / blender / makesdna / DNA_constraint_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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): 2007, Joshua Leung, major recode
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  * Constraint DNA data
29  */
30
31 #ifndef DNA_CONSTRAINT_TYPES_H
32 #define DNA_CONSTRAINT_TYPES_H
33
34 /** \file DNA_constraint_types.h
35  *  \ingroup DNA
36  */
37
38 #include "DNA_ID.h"
39 #include "DNA_listBase.h"
40
41 struct Action;
42 struct Text;
43 struct Ipo;
44
45 /* channels reside in Object or Action (ListBase) constraintChannels */
46 // XXX depreceated... old AnimSys
47 typedef struct bConstraintChannel {
48         struct bConstraintChannel *next, *prev;
49         struct Ipo                      *ipo;
50         short           flag;
51         char            name[30];
52 } bConstraintChannel;
53
54 /* A Constraint */
55 typedef struct bConstraint {
56         struct bConstraint *next, *prev;
57         
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 (only used if 1 target) */
64         
65         char            name[30];       /*      Constraint name */
66         
67         float           enforce;        /*      Amount of influence exherted by constraint (0.0-1.0) */
68         float           headtail;       /*      Point along subtarget bone where the actual target is. 0=head (default for all), 1=tail*/
69         int                     pad;
70         
71         struct Ipo *ipo;                /* local influence ipo or driver */ // XXX depreceated for 2.5... old animation system hack
72         
73         /* below are readonly fields that are set at runtime by the solver for use in the GE (only IK atm) */
74         float       lin_error;          /* residual error on constraint expressed in blender unit*/
75         float       rot_error;          /* residual error on constraint expressed in radiant */
76 } bConstraint;
77
78
79 /* Multiple-target constraints ---------------------  */
80
81 /* This struct defines a constraint target.
82  * It is used during constraint solving regardless of how many targets the
83  * constraint has.
84  */
85 typedef struct bConstraintTarget {
86         struct bConstraintTarget *next, *prev;
87
88         struct Object *tar;                     /* object to use as target */
89         char subtarget[32];             /* subtarget - pchan or vgroup name */
90         
91         float matrix[4][4];             /* matrix used during constraint solving - should be cleared before each use */
92         
93         short space;                    /* space that target should be evaluated in (overrides bConstraint->tarspace) */
94         short flag;                             /* runtime settings (for editor, etc.) */
95         short type;                             /* type of target (B_CONSTRAINT_OB_TYPE) */
96         short rotOrder;                 /* rotation order for target (as defined in BLI_math.h) */
97 } bConstraintTarget;
98
99 /* bConstraintTarget -> flag */
100 typedef enum B_CONSTRAINT_TARGET_FLAG {
101         CONSTRAINT_TAR_TEMP = (1<<0)            /* temporary target-struct that needs to be freed after use */
102 } B_CONSTRAINT_TARGET_FLAG;
103
104 /* bConstraintTarget/bConstraintOb -> type */
105 typedef enum B_CONSTRAINT_OB_TYPE {
106         CONSTRAINT_OBTYPE_OBJECT = 1,   /*      string is ""                            */
107         CONSTRAINT_OBTYPE_BONE,                 /*      string is bone-name             */
108         CONSTRAINT_OBTYPE_VERT,                 /*      string is vertex-group name     */
109         CONSTRAINT_OBTYPE_CV                    /*      string is vertex-group name - is not available until curves get vgroups */
110 } B_CONSTRAINT_OB_TYPE;
111
112
113
114 /* Python Script Constraint */
115 typedef struct bPythonConstraint {      
116         struct Text *text;              /* text-buffer (containing script) to execute */
117         IDProperty *prop;               /* 'id-properties' used to store custom properties for constraint */
118         
119         int flag;                               /* general settings/state indicators accessed by bitmapping */
120         int tarnum;                             /* number of targets - usually only 1-3 are needed */
121         
122         ListBase targets;               /* a list of targets that this constraint has (bConstraintTarget-s) */
123         
124         struct Object *tar;             /* target from previous implementation (version-patch sets this to NULL on file-load) */
125         char subtarget[32];             /* subtarger from previous implentation (version-patch sets this to "" on file-load) */
126 } bPythonConstraint;
127
128
129 /* Inverse-Kinematics (IK) constraint
130    This constraint supports a variety of mode determine by the type field 
131    according to B_CONSTRAINT_IK_TYPE.
132    Some fields are used by all types, some are specific to some types
133    This is indicated in the comments for each field
134  */
135 typedef struct bKinematicConstraint {
136         struct Object           *tar;                   /* All: target object in case constraint needs a target */
137         short           iterations;             /* All: Maximum number of iterations to try */
138         short           flag;                   /* All & CopyPose: some options Like CONSTRAINT_IK_TIP */
139         short           rootbone;               /* All: index to rootbone, if zero go all the way to mother bone */
140         short           max_rootbone;   /* CopyPose: for auto-ik, maximum length of chain */
141         char            subtarget[32];  /* All: String to specify sub-object target */
142         struct Object           *poletar;                       /* All: Pole vector target */
143         char            polesubtarget[32];      /* All: Pole vector sub-object target */
144         float           poleangle;                      /* All: Pole vector rest angle */
145         float           weight;                 /* All: Weight of constraint in IK tree */
146         float           orientweight;   /* CopyPose: Amount of rotation a target applies on chain */
147         float           grabtarget[3];  /* CopyPose: for target-less IK */
148         short           type;                   /* subtype of IK constraint: B_CONSTRAINT_IK_TYPE */
149         short           mode;                   /* Distance: how to limit in relation to clamping sphere: LIMITDIST_.. */
150         float           dist;                   /* Distance: distance (radius of clamping sphere) from target */
151 } bKinematicConstraint;
152
153 typedef enum B_CONSTRAINT_IK_TYPE {
154         CONSTRAINT_IK_COPYPOSE = 0,             /* 'standard' IK constraint: match position and/or orientation of target */
155         CONSTRAINT_IK_DISTANCE                  /* maintain distance with target */
156 } B_CONSTRAINT_IK_TYPE;
157
158
159 /* Spline IK Constraint 
160  * Aligns 'n' bones to the curvature defined by the curve,
161  * with the chain ending on the bone that owns this constraint, 
162  * and starting on the nth parent.
163  */
164 typedef struct bSplineIKConstraint {
165                 /* target(s) */
166         struct Object *tar;             /* curve object (with follow path enabled) which drives the bone chain */
167         
168                 /* binding details */
169         float           *points;        /* array of numpoints items, denoting parametric positions along curve that joints should follow */
170         short           numpoints;      /* number of points to bound in points array */
171         short           chainlen;       /* number of bones ('n') that are in the chain */
172         
173                 /* settings */  
174         short flag;                             /* general settings for constraint */
175         short xzScaleMode;              /* method used for determining the x & z scaling of the bones */
176 } bSplineIKConstraint;
177
178
179 /* Single-target subobject constraints ---------------------  */
180
181 /* Track To Constraint */
182 typedef struct bTrackToConstraint {
183         struct Object           *tar;
184         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*/
185         int                     reserved2;
186         int                     flags;
187         int                     pad;
188         char            subtarget[32];
189 } bTrackToConstraint;
190
191 /* Copy Rotation Constraint */
192 typedef struct bRotateLikeConstraint {
193         struct Object           *tar;
194         int                     flag;
195         int                     reserved1;
196         char            subtarget[32];
197 } bRotateLikeConstraint;
198
199 /* Copy Location Constraint */
200 typedef struct bLocateLikeConstraint {
201         struct Object           *tar;
202         int                     flag;
203         int                     reserved1;
204         char            subtarget[32];
205 } bLocateLikeConstraint;
206
207 /* Copy Scale Constraint */
208 typedef struct bSizeLikeConstraint {
209         struct Object           *tar;
210         int                     flag;
211         int                     reserved1;
212         char            subtarget[32];
213 } bSizeLikeConstraint;
214
215 /* Maintain Volume Constraint */
216 typedef struct bSameVolumeConstraint {
217         int                     flag;
218         float           volume;
219 } bSameVolumeConstraint;
220
221 /* Copy Transform Constraint */
222 typedef struct bTransLikeConstraint {
223         struct Object *tar;
224         char            subtarget[32];
225 } bTransLikeConstraint;
226
227 /* Floor Constraint */
228 typedef struct bMinMaxConstraint {
229         struct Object *tar;
230         int                     minmaxflag;
231         float           offset;
232         int                     flag;
233         short           sticky, stuck, pad1, pad2; /* for backward compatability */
234         float           cache[3];
235         char            subtarget[32];
236 } bMinMaxConstraint;
237
238 /* Action Constraint */
239 typedef struct bActionConstraint {
240         struct Object           *tar;
241         short           type;   /* what transform 'channel' drives the result */
242         short           local;  /* was used in versions prior to the Constraints recode */
243         int                     start;
244         int                     end;
245         float           min;
246         float           max;
247         int         pad;
248         struct bAction  *act;
249         char            subtarget[32];
250 } bActionConstraint;
251
252 /* Locked Axis Tracking constraint */
253 typedef struct bLockTrackConstraint {
254         struct Object           *tar;
255         int                     trackflag;
256         int                     lockflag;
257         char            subtarget[32];
258 } bLockTrackConstraint;
259
260 /* Damped Tracking constraint */
261 typedef struct bDampTrackConstraint {
262         struct Object           *tar;
263         int                     trackflag;
264         int                     pad;
265         char            subtarget[32];
266 } bDampTrackConstraint;
267
268 /* Follow Path constraints */
269 typedef struct bFollowPathConstraint {
270         struct Object           *tar;           /* Must be path object */
271         
272         float           offset;                 /* Offset in time on the path (in frames), when NOT using 'fixed position' */
273         float           offset_fac;             /* Parametric offset factor defining position along path, when using 'fixed position' */
274         
275         int                     followflag;
276         
277         short           trackflag;
278         short           upflag;
279 } bFollowPathConstraint;
280
281 /* Stretch to constraint */
282 typedef struct bStretchToConstraint {
283         struct Object           *tar;
284         int                     volmode; 
285         int         plane;
286         float           orglength;
287         float           bulge;
288         char            subtarget[32];
289 } bStretchToConstraint;
290
291 /* Rigid Body constraint */
292 typedef struct bRigidBodyJointConstraint {
293         struct Object           *tar;
294         struct Object           *child;
295         int         type;
296         float       pivX;
297         float       pivY;
298         float       pivZ;
299         float       axX;
300         float       axY;
301         float       axZ;
302         float       minLimit[6];
303         float       maxLimit[6];
304         float       extraFz;
305         short           flag;
306         short           pad;
307         short           pad1;
308         short           pad2;
309 } bRigidBodyJointConstraint;
310
311 /* Clamp-To Constraint */
312 typedef struct bClampToConstraint {
313         struct Object           *tar;                   /* 'target' must be a curve */
314         int                     flag;                   /* which axis/plane to compare owner's location on  */
315         int                     flag2;                  /* for legacy reasons, this is flag2. used for any extra settings */
316 } bClampToConstraint;
317
318 /* Child Of Constraint */
319 typedef struct bChildOfConstraint {
320         struct Object           *tar;                   /* object which will act as parent (or target comes from) */
321         int             flag;                   /* settings */
322         int                     pad;
323         float           invmat[4][4];   /* parent-inverse matrix to use */
324         char            subtarget[32];  /* string to specify a subobject target */
325 } bChildOfConstraint;
326
327 /* Generic Transform->Transform Constraint */
328 typedef struct bTransformConstraint {
329         struct Object           *tar;                   /* target (i.e. 'driver' object/bone) */
330         char            subtarget[32];  
331         
332         short           from, to;               /* can be loc(0) , rot(1),  or size(2) */
333         char            map[3];                 /* defines which target-axis deform is copied by each owner-axis */
334         char            expo;                   /* extrapolate motion? if 0, confine to ranges */
335         
336         float           from_min[3];    /* from_min/max defines range of target transform       */
337         float           from_max[3];    /*      to map on to to_min/max range.                  */
338         
339         float           to_min[3];              /* range of motion on owner caused by target  */
340         float           to_max[3];      
341 } bTransformConstraint;
342
343 /* Pivot Constraint */
344 typedef struct bPivotConstraint {
345         /* Pivot Point:
346          *      Either target object + offset, or just offset is used
347          */
348         struct Object           *tar;                   /* target object (optional) */
349         char            subtarget[32];          /* subtarget name (optional) */
350         float           offset[3];              /* offset from the target to use, regardless of whether it exists */
351         
352         /* Rotation-driven activation:
353          *      This option provides easier one-stop setups for footrolls
354          */
355         short           rotAxis;                /* rotation axes to consider for this (ePivotConstraint_Axis) */
356         
357         /* General flags */
358         short           flag;                   /* ePivotConstraint_Flag */
359 } bPivotConstraint;
360
361 /* transform limiting constraints - zero target ----------------------------  */
362 /* Limit Location Constraint */
363 typedef struct bLocLimitConstraint {
364         float           xmin, xmax;
365         float           ymin, ymax;
366         float           zmin, zmax;
367         short           flag;
368         short           flag2;
369 } bLocLimitConstraint;
370
371 /* Limit Rotation Constraint */
372 typedef struct bRotLimitConstraint {
373         float           xmin, xmax;
374         float           ymin, ymax;
375         float           zmin, zmax;
376         short           flag;
377         short           flag2;
378 } bRotLimitConstraint;
379
380 /* Limit Scaling Constraint */
381 typedef struct bSizeLimitConstraint {
382         float           xmin, xmax;
383         float           ymin, ymax;
384         float           zmin, zmax;
385         short           flag;
386         short           flag2;
387 } bSizeLimitConstraint;
388
389 /* Limit Distance Constraint */
390 typedef struct bDistLimitConstraint {
391         struct Object           *tar;
392         char            subtarget[32];
393         
394         float           dist;                   /* distance (radius of clamping sphere) from target */
395         float           soft;                   /* distance from clamping-sphere to start applying 'fade' */
396         
397         short           flag;                   /* settings */
398         short           mode;                   /* how to limit in relation to clamping sphere */
399         int             pad;
400 } bDistLimitConstraint;
401
402 /* ShrinkWrap Constraint */
403 typedef struct bShrinkwrapConstraint {
404         struct Object           *target;
405         float           dist;                   /* distance to kept from target */
406         short           shrinkType;             /* shrink type (look on MOD shrinkwrap for values) */
407         char            projAxis;               /* axis to project over UP_X, UP_Y, UP_Z */
408         char            pad[9];
409 } bShrinkwrapConstraint;
410
411
412 /* ------------------------------------------ */
413
414 /* bConstraint->type 
415  *      - Do not ever change the order of these, or else files could get
416  *        broken as their correct value cannot be resolved
417  */
418 typedef enum eBConstraint_Types {
419         CONSTRAINT_TYPE_NULL = 0,                       /* Invalid/legacy constraint */
420         CONSTRAINT_TYPE_CHILDOF,                        /* Unimplemented non longer :) - during constraints recode, Aligorith */
421         CONSTRAINT_TYPE_TRACKTO,
422         CONSTRAINT_TYPE_KINEMATIC,
423         CONSTRAINT_TYPE_FOLLOWPATH,
424         CONSTRAINT_TYPE_ROTLIMIT,                       /* Unimplemented no longer :) - Aligorith */
425         CONSTRAINT_TYPE_LOCLIMIT,                       /* Unimplemented no longer :) - Aligorith */
426         CONSTRAINT_TYPE_SIZELIMIT,                      /* Unimplemented no longer :) - Aligorith */
427         CONSTRAINT_TYPE_ROTLIKE,        
428         CONSTRAINT_TYPE_LOCLIKE,        
429         CONSTRAINT_TYPE_SIZELIKE,
430         CONSTRAINT_TYPE_PYTHON,                         /* Unimplemented no longer :) - Aligorith. Scripts */
431         CONSTRAINT_TYPE_ACTION,
432         CONSTRAINT_TYPE_LOCKTRACK,                      /* New Tracking constraint that locks an axis in place - theeth */
433         CONSTRAINT_TYPE_DISTLIMIT,                      /* limit distance */
434         CONSTRAINT_TYPE_STRETCHTO,                      /* claiming this to be mine :) is in tuhopuu bjornmose */ 
435         CONSTRAINT_TYPE_MINMAX,                         /* floor constraint */
436         CONSTRAINT_TYPE_RIGIDBODYJOINT,         /* rigidbody constraint */
437         CONSTRAINT_TYPE_CLAMPTO,                        /* clampto constraint */        
438         CONSTRAINT_TYPE_TRANSFORM,                      /* transformation (loc/rot/size -> loc/rot/size) constraint */  
439         CONSTRAINT_TYPE_SHRINKWRAP,                     /* shrinkwrap (loc/rot) constraint */
440         CONSTRAINT_TYPE_DAMPTRACK,                      /* New Tracking constraint that minimises twisting */
441         CONSTRAINT_TYPE_SPLINEIK,                       /* Spline-IK - Align 'n' bones to a curve */
442         CONSTRAINT_TYPE_TRANSLIKE,                      /* Copy transform matrix */
443         CONSTRAINT_TYPE_SAMEVOL,                        /* Maintain volume during scaling */
444         CONSTRAINT_TYPE_PIVOT,                          /* Pivot Constraint */
445         
446         /* NOTE: no constraints are allowed to be added after this */
447         NUM_CONSTRAINT_TYPES
448 } eBConstraint_Types; 
449
450 /* bConstraint->flag */
451 /* flags 0x2 (1<<1) and 0x8 (1<<3) were used in past */
452 /* flag 0x20 (1<<5) was used to indicate that a constraint was evaluated using a 'local' hack for posebones only  */
453 typedef enum eBConstraint_Flags {
454                 /* expand for UI */
455         CONSTRAINT_EXPAND =             (1<<0), 
456                 /* pre-check for illegal object name or bone name */
457         CONSTRAINT_DISABLE =    (1<<2), 
458                 /* to indicate which Ipo should be shown, maybe for 3d access later too */      
459         CONSTRAINT_ACTIVE =     (1<<4), 
460                 /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
461         CONSTRAINT_SPACEONCE =  (1<<6),
462                 /* influence ipo is on constraint itself, not in action channel */
463         CONSTRAINT_OWN_IPO      = (1<<7),
464                 /* indicates that constraint was added locally (i.e.  didn't come from the proxy-lib) */
465         CONSTRAINT_PROXY_LOCAL = (1<<8),
466                 /* indicates that constraint is temporarily disabled (only used in GE) */
467         CONSTRAINT_OFF = (1<<9)
468 } eBConstraint_Flags;
469
470 /* bConstraint->ownspace/tarspace */
471 typedef enum eBConstraint_SpaceTypes {
472                 /* default for all - worldspace */
473         CONSTRAINT_SPACE_WORLD = 0,
474                 /* for objects (relative to parent/without parent influence), 
475                  * for bones (along normals of bone, without parent/restpositions) 
476                  */
477         CONSTRAINT_SPACE_LOCAL, /* = 1 */
478                 /* for posechannels - pose space  */
479         CONSTRAINT_SPACE_POSE, /* = 2 */
480                  /* for posechannels - local with parent  */
481         CONSTRAINT_SPACE_PARLOCAL, /* = 3 */
482                 /* for files from between 2.43-2.46 (should have been parlocal) */
483         CONSTRAINT_SPACE_INVALID /* = 4. do not exchange for anything! */
484 } eBConstraint_SpaceTypes;
485
486 /* bConstraintChannel.flag */
487 // XXX depreceated... old AnimSys
488 typedef enum eConstraintChannel_Flags {
489         CONSTRAINT_CHANNEL_SELECT =             (1<<0),
490         CONSTRAINT_CHANNEL_PROTECTED =  (1<<1)
491 } eConstraintChannel_Flags;
492
493 /* -------------------------------------- */
494
495 /* bRotateLikeConstraint.flag */
496 typedef enum eCopyRotation_Flags {
497         ROTLIKE_X                       = (1<<0),
498         ROTLIKE_Y                       = (1<<1),
499         ROTLIKE_Z                       = (1<<2),
500         ROTLIKE_X_INVERT        = (1<<4),
501         ROTLIKE_Y_INVERT        = (1<<5),
502         ROTLIKE_Z_INVERT        = (1<<6),
503         ROTLIKE_OFFSET          = (1<<7)
504 } eCopyRotation_Flags;
505
506 /* bLocateLikeConstraint.flag */
507 typedef enum eCopyLocation_Flags {
508         LOCLIKE_X                       = (1<<0),
509         LOCLIKE_Y                       = (1<<1),
510         LOCLIKE_Z                       = (1<<2),
511                 /* LOCLIKE_TIP is a depreceated option... use headtail=1.0f instead */
512         LOCLIKE_TIP                     = (1<<3),
513         LOCLIKE_X_INVERT        = (1<<4),
514         LOCLIKE_Y_INVERT        = (1<<5),
515         LOCLIKE_Z_INVERT        = (1<<6),
516         LOCLIKE_OFFSET          = (1<<7)
517 } eCopyLocation_Flags;
518  
519 /* bSizeLikeConstraint.flag */
520 typedef enum eCopyScale_Flags {
521         SIZELIKE_X              = (1<<0),
522         SIZELIKE_Y              = (1<<1),
523         SIZELIKE_Z              = (1<<2), 
524         SIZELIKE_OFFSET = (1<<3)
525 } eCopyScale_Flags;
526
527 /* bSameVolumeConstraint.flag */
528 typedef enum eSameVolume_Modes {
529         SAMEVOL_X               = 0,
530         SAMEVOL_Y,
531         SAMEVOL_Z
532 } eSameVolume_Modes;
533
534 /* Locked-Axis Values (Locked Track) */
535 typedef enum eLockAxis_Modes {
536         LOCK_X  = 0,
537         LOCK_Y,
538         LOCK_Z
539 } eLockAxis_Modes;
540
541 /* Up-Axis Values (TrackTo and Locked Track) */
542 typedef enum eUpAxis_Modes {
543         UP_X    = 0,
544         UP_Y,
545         UP_Z
546 } eUpAxis_Modes;
547
548 /* Tracking axis (TrackTo, Locked Track, Damped Track) and minmax (floor) constraint */
549 typedef enum eTrackToAxis_Modes {
550         TRACK_X         = 0,
551         TRACK_Y,
552         TRACK_Z,
553         TRACK_nX,
554         TRACK_nY,
555         TRACK_nZ
556 } eTrackToAxis_Modes;
557
558 /* FollowPath flags */
559 typedef enum eFollowPath_Flags {
560         FOLLOWPATH_FOLLOW       = (1<<0),
561         FOLLOWPATH_STATIC       = (1<<1),
562         FOLLOWPATH_RADIUS       = (1<<2)
563 } eFollowPath_Flags;
564
565 /* bTrackToConstraint->flags */
566 typedef enum eTrackTo_Flags {
567         TARGET_Z_UP     = (1<<0)
568 } eTrackTo_Flags;
569
570 /* Strech To Constraint -> volmode */
571 typedef enum eStretchTo_VolMode {
572         VOLUME_XZ       = 0,
573         VOLUME_X,
574         VOLUME_Z,
575         NO_VOLUME
576 } eStretchTo_VolMode;
577
578 /* Stretch To Constraint -> plane mode */
579 typedef enum eStretchTo_PlaneMode {
580         PLANE_X         = 0,
581         PLANE_Y,
582         PLANE_Z
583 } eStretchTo_PlaneMode;
584
585 /* Clamp-To Constraint ->flag */
586 typedef enum eClampTo_Modes {
587         CLAMPTO_AUTO = 0,
588         CLAMPTO_X,
589         CLAMPTO_Y,
590         CLAMPTO_Z
591 } eClampTo_Modes;
592
593 /* ClampTo Constraint ->flag2 */
594 typedef enum eClampTo_Flags {
595         CLAMPTO_CYCLIC  = (1<<0)
596 } eClampTo_Flags;
597
598 /* bKinematicConstraint->flag */
599 typedef enum eKinematic_Flags {
600         CONSTRAINT_IK_TIP                       = (1<<0),
601         CONSTRAINT_IK_ROT                       = (1<<1),
602         /* targetless */
603         CONSTRAINT_IK_AUTO                      = (1<<2),
604         /* autoik */
605         CONSTRAINT_IK_TEMP                      = (1<<3),
606         CONSTRAINT_IK_STRETCH           = (1<<4),
607         CONSTRAINT_IK_POS                       = (1<<5),
608         CONSTRAINT_IK_SETANGLE          = (1<<6),
609         CONSTRAINT_IK_GETANGLE          = (1<<7),
610         /* limit axis */
611         CONSTRAINT_IK_NO_POS_X          = (1<<8),
612         CONSTRAINT_IK_NO_POS_Y          = (1<<9),
613         CONSTRAINT_IK_NO_POS_Z          = (1<<10),
614         CONSTRAINT_IK_NO_ROT_X          = (1<<11),
615         CONSTRAINT_IK_NO_ROT_Y          = (1<<12),
616         CONSTRAINT_IK_NO_ROT_Z          = (1<<13),
617         /* axis relative to target */
618         CONSTRAINT_IK_TARGETAXIS        = (1<<14)
619 } eKinematic_Flags;
620
621 /* bSplineIKConstraint->flag */
622 typedef enum eSplineIK_Flags {
623         /* chain has been attached to spline */
624         CONSTRAINT_SPLINEIK_BOUND                       = (1<<0),
625         /* root of chain is not influenced by the constraint */
626         CONSTRAINT_SPLINEIK_NO_ROOT                     = (1<<1),
627         /* bones in the chain should not scale to fit the curve */
628         CONSTRAINT_SPLINEIK_SCALE_LIMITED       = (1<<2),
629         /* evenly distribute the bones along the path regardless of length */
630         CONSTRAINT_SPLINEIK_EVENSPLITS          = (1<<3),       
631         /* don't adjust the x and z scaling of the bones by the curve radius */
632         CONSTRAINT_SPLINEIK_NO_CURVERAD = (1<<4)
633 } eSplineIK_Flags;
634
635 /* bSplineIKConstraint->xzScaleMode */
636 typedef enum eSplineIK_XZScaleModes {
637         /* no x/z scaling */
638         CONSTRAINT_SPLINEIK_XZS_NONE                    = 0,
639         /* bones in the chain should take their x/z scales from the original scaling */
640         CONSTRAINT_SPLINEIK_XZS_ORIGINAL,
641         /* x/z scales are the inverse of the y-scale */
642         CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC
643 } eSplineIK_XZScaleModes;
644
645 /* MinMax (floor) flags */
646 typedef enum eFloor_Flags {
647         MINMAX_STICKY   = (1<<0),
648         MINMAX_STUCK    = (1<<1),
649         MINMAX_USEROT   = (1<<2)
650 } eFloor_Flags;
651
652 /* transform limiting constraints -> flag2 */
653 typedef enum eTransformLimits_Flags2 {
654         /* not used anymore - for older Limit Location constraints only */
655         LIMIT_NOPARENT  = (1<<0),
656         /* for all Limit constraints - allow to be used during transform? */
657         LIMIT_TRANSFORM = (1<<1)
658 } eTransformLimits_Flags2;
659
660 /* transform limiting constraints -> flag (own flags)  */
661 typedef enum eTransformLimits_Flags {
662         LIMIT_XMIN = (1<<0),
663         LIMIT_XMAX = (1<<1),
664         LIMIT_YMIN = (1<<2),
665         LIMIT_YMAX = (1<<3),
666         LIMIT_ZMIN = (1<<4),
667         LIMIT_ZMAX = (1<<5)
668 } eTransformLimits_Flags;
669
670 /* limit rotation constraint -> flag (own flags) */
671 typedef enum eRotLimit_Flags {
672         LIMIT_XROT = (1<<0),
673         LIMIT_YROT = (1<<1),
674         LIMIT_ZROT = (1<<2)
675 } eRotLimit_Flags;
676
677 /* distance limit constraint */
678         /* bDistLimitConstraint->flag */
679 typedef enum eDistLimit_Flag {
680         LIMITDIST_USESOFT       = (1<<0)
681 } eDistLimit_Flag;
682
683         /* bDistLimitConstraint->mode */
684 typedef enum eDistLimit_Modes {
685         LIMITDIST_INSIDE = 0,
686         LIMITDIST_OUTSIDE,
687         LIMITDIST_ONSURFACE
688 } eDistLimit_Modes;
689         
690 /* python constraint -> flag */
691 typedef enum ePyConstraint_Flags {
692         PYCON_USETARGETS        = (1<<0),
693         PYCON_SCRIPTERROR       = (1<<1)
694 } ePyConstraint_Flags;
695
696 /* ChildOf Constraint -> flag */
697 typedef enum eChildOf_Flags {
698         CHILDOF_LOCX    = (1<<0),
699         CHILDOF_LOCY    = (1<<1),
700         CHILDOF_LOCZ    = (1<<2),
701         CHILDOF_ROTX    = (1<<3),
702         CHILDOF_ROTY    = (1<<4),
703         CHILDOF_ROTZ    = (1<<5),
704         CHILDOF_SIZEX   = (1<<6),
705         CHILDOF_SIZEY   = (1<<7),
706         CHILDOF_SIZEZ   = (1<<8),
707         CHILDOF_ALL             = 511
708 } eChildOf_Flags;
709
710 /* Pivot Constraint */
711         /* Restrictions for Pivot Constraint axis to consider for enabling constraint */
712 typedef enum ePivotConstraint_Axis {
713         /* do not consider this activity-clamping */
714         PIVOTCON_AXIS_NONE = -1,        
715         
716         /* consider -ve x-axis rotations */
717         PIVOTCON_AXIS_X_NEG,
718         /* consider -ve y-axis rotations */
719         PIVOTCON_AXIS_Y_NEG,
720         /* consider -ve z-axis rotations */
721         PIVOTCON_AXIS_Z_NEG,
722         
723         /* consider +ve x-axis rotations */
724         PIVOTCON_AXIS_X,
725         /* consider +ve y-axis rotations */
726         PIVOTCON_AXIS_Y,
727         /* consider +ve z-axis rotations */
728         PIVOTCON_AXIS_Z
729 } ePivotConstraint_Axis;
730
731         /* settings for Pivot Constraint in general */
732 typedef enum ePivotConstraint_Flag {
733         /* offset is to be interpreted as being a fixed-point in space */
734         PIVOTCON_FLAG_OFFSET_ABS        = (1<<0),
735         /* rotation-based activation uses negative rotation to drive result */
736         PIVOTCON_FLAG_ROTACT_NEG        = (1<<1)
737 } ePivotConstraint_Flag;
738
739 /* Rigid-Body Constraint */
740 #define CONSTRAINT_DRAW_PIVOT 0x40
741 #define         CONSTRAINT_DISABLE_LINKED_COLLISION 0x80
742
743 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
744 #define         CONSTRAINT_RB_BALL              1
745 #define         CONSTRAINT_RB_HINGE             2
746 #define         CONSTRAINT_RB_CONETWIST 4
747 #define         CONSTRAINT_RB_VEHICLE   11
748 #define         CONSTRAINT_RB_GENERIC6DOF 12
749
750 #endif