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