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