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