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