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