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