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