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