Cleanup: spaces around operators in DNA headers
[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
22  * \ingroup DNA
23  */
24
25 #ifndef __DNA_CONSTRAINT_TYPES_H__
26 #define __DNA_CONSTRAINT_TYPES_H__
27
28 #include "DNA_defs.h"
29 #include "DNA_ID.h"
30 #include "DNA_listBase.h"
31
32 struct Action;
33 struct Ipo;
34 struct Text;
35
36 /* channels reside in Object or Action (ListBase) constraintChannels */
37 // XXX deprecated... old AnimSys
38 typedef struct bConstraintChannel {
39         struct bConstraintChannel *next, *prev;
40         struct Ipo                      *ipo;
41         short           flag;
42         char            name[30];
43 } bConstraintChannel;
44
45 /* A Constraint */
46 typedef struct bConstraint {
47         struct bConstraint *next, *prev;
48
49         /** Constraint data     (a valid constraint type). */
50         void            *data;
51         /** Constraint type.    */
52         short           type;
53         /** Flag - General Settings.    */
54         short           flag;
55
56         /** Space that owner should be evaluated in. */
57         char            ownspace;
58         /** Space that target should be evaluated in (only used if 1 target). */
59         char            tarspace;
60
61         /** Constraint name, MAX_NAME. */
62         char            name[64];
63
64         char            _pad[2];
65
66         /** Amount of influence exherted by constraint (0.0-1.0). */
67         float           enforce;
68         /** Point along subtarget bone where the actual target is. 0=head (default for all), 1=tail. */
69         float           headtail;
70
71         /* old animation system, deprecated for 2.5. */
72         /** Local influence ipo or driver */
73         struct Ipo *ipo    DNA_DEPRECATED;
74
75         /* below are readonly fields that are set at runtime
76          * by the solver for use in the GE (only IK atm) */
77         /** Residual error on constraint expressed in blender unit. */
78         float       lin_error;
79         /** Residual error on constraint expressed in radiant. */
80         float       rot_error;
81 } bConstraint;
82
83
84 /* Multiple-target constraints ---------------------  */
85
86 /* This struct defines a constraint target.
87  * It is used during constraint solving regardless of how many targets the
88  * constraint has.
89  */
90 typedef struct bConstraintTarget {
91         struct bConstraintTarget *next, *prev;
92
93         /** Object to use as target. */
94         struct Object *tar;
95         /** Subtarget - pchan or vgroup name, MAX_ID_NAME-2. */
96         char subtarget[64];
97
98         /** Matrix used during constraint solving - should be cleared before each use. */
99         float matrix[4][4];
100
101         /** Space that target should be evaluated in (overrides bConstraint->tarspace). */
102         short space;
103         /** Runtime settings (for editor, etc.). */
104         short flag;
105         /** Type of target (eConstraintObType). */
106         short type;
107         /** Rotation order for target (as defined in BLI_math.h). */
108         short rotOrder;
109         /** Weight for armature deform. */
110         float weight;
111         char _pad[4];
112 } bConstraintTarget;
113
114 /* bConstraintTarget -> flag */
115 typedef enum eConstraintTargetFlag {
116         /** temporary target-struct that needs to be freed after use */
117         CONSTRAINT_TAR_TEMP = (1 << 0),
118 } eConstraintTargetFlag;
119
120 /* bConstraintTarget/bConstraintOb -> type */
121 typedef enum eConstraintObType {
122         /** string is "" */
123         CONSTRAINT_OBTYPE_OBJECT = 1,
124         /** string is bone-name */
125         CONSTRAINT_OBTYPE_BONE   = 2,
126         /** string is vertex-group name */
127         CONSTRAINT_OBTYPE_VERT   = 3,
128         /** string is vertex-group name - is not available until curves get vgroups */
129         CONSTRAINT_OBTYPE_CV     = 4,
130 } eConstraintObType;
131
132
133 /* Python Script Constraint */
134 typedef struct bPythonConstraint {
135         /** Text-buffer (containing script) to execute. */
136         struct Text *text;
137         /** 'id-properties' used to store custom properties for constraint. */
138         IDProperty *prop;
139
140         /** General settings/state indicators accessed by bitmapping. */
141         int flag;
142         /** Number of targets - usually only 1-3 are needed. */
143         int tarnum;
144
145         /** A list of targets that this constraint has (bConstraintTarget-s). */
146         ListBase targets;
147
148         /**
149          * Target from previous implementation
150          * (version-patch sets this to NULL on file-load).
151          */
152         struct Object *tar;
153         /**
154          * Subtarger from previous implementation
155          * (version-patch sets this to "" on file-load), MAX_ID_NAME-2.
156          */
157         char subtarget[64];
158 } bPythonConstraint;
159
160
161 /* Inverse-Kinematics (IK) constraint
162  * This constraint supports a variety of mode determine by the type field
163  * according to eConstraint_IK_Type.
164  * Some fields are used by all types, some are specific to some types
165  * This is indicated in the comments for each field
166  */
167 typedef struct bKinematicConstraint {
168         /** All: target object in case constraint needs a target. */
169         struct Object           *tar;
170         /** All: Maximum number of iterations to try. */
171         short           iterations;
172         /** All & CopyPose: some options Like CONSTRAINT_IK_TIP. */
173         short           flag;
174         /** All: index to rootbone, if zero go all the way to mother bone. */
175         short           rootbone;
176         /** CopyPose: for auto-ik, maximum length of chain. */
177         short           max_rootbone;
178         /** All: String to specify sub-object target, MAX_ID_NAME-2. */
179         char            subtarget[64];
180         /** All: Pole vector target. */
181         struct Object           *poletar;
182         /** All: Pole vector sub-object target, MAX_ID_NAME-2. */
183         char            polesubtarget[64];
184         /** All: Pole vector rest angle. */
185         float           poleangle;
186         /** All: Weight of constraint in IK tree. */
187         float           weight;
188         /** CopyPose: Amount of rotation a target applies on chain. */
189         float           orientweight;
190         /** CopyPose: for target-less IK. */
191         float           grabtarget[3];
192         /** Subtype of IK constraint: eConstraint_IK_Type. */
193         short           type;
194         /** Distance: how to limit in relation to clamping sphere: LIMITDIST_... */
195         short           mode;
196         /** Distance: distance (radius of clamping sphere) from target. */
197         float           dist;
198 } bKinematicConstraint;
199
200 typedef enum eConstraint_IK_Type {
201         /** 'standard' IK constraint: match position and/or orientation of target */
202         CONSTRAINT_IK_COPYPOSE = 0,
203         /** maintain distance with target */
204         CONSTRAINT_IK_DISTANCE = 1,
205 } eConstraint_IK_Type;
206
207
208 /* Spline IK Constraint
209  * Aligns 'n' bones to the curvature defined by the curve,
210  * with the chain ending on the bone that owns this constraint,
211  * and starting on the nth parent.
212  */
213 typedef struct bSplineIKConstraint {
214                 /* target(s) */
215         /** Curve object (with follow path enabled) which drives the bone chain. */
216         struct Object *tar;
217
218                 /* binding details */
219         /**
220          * Array of numpoints items,
221          * denoting parametric positions along curve that joints should follow.
222          */
223         float           *points;
224         /** Number of points to bound in points array. */
225         short           numpoints;
226         /** Number of bones ('n') that are in the chain. */
227         short           chainlen;
228
229                 /* settings */
230         /** General settings for constraint. */
231         short flag;
232         /** Method used for determining the x & z scaling of the bones. */
233         short xzScaleMode;
234
235                 /* volume preservation settings */
236         float           bulge;
237         float           bulge_min;
238         float           bulge_max;
239         float           bulge_smooth;
240 } bSplineIKConstraint;
241
242 /* Armature Constraint */
243 typedef struct bArmatureConstraint {
244         /** General settings/state indicators accessed by bitmapping. */
245         int flag;
246         char _pad[4];
247
248         /** A list of targets that this constraint has (bConstraintTarget-s). */
249         ListBase targets;
250 } bArmatureConstraint;
251
252 /* Single-target subobject constraints ---------------------  */
253
254 /* Track To Constraint */
255 typedef struct bTrackToConstraint {
256         struct Object           *tar;
257         /**
258          * I'll be using reserved1 and reserved2 as Track and Up flags,
259          * not sure if that's what they were intended for anyway.
260          * Not sure either if it would create backward incompatibility if I were to rename them.
261          * - theeth
262          */
263         int                     reserved1;
264         int                     reserved2;
265         int                     flags;
266         char _pad[4];
267         /** MAX_ID_NAME-2. */
268         char            subtarget[64];
269 } bTrackToConstraint;
270
271 /* Copy Rotation Constraint */
272 typedef struct bRotateLikeConstraint {
273         struct Object           *tar;
274         int                     flag;
275         int                     reserved1;
276         /** MAX_ID_NAME-2. */
277         char            subtarget[64];
278 } bRotateLikeConstraint;
279
280 /* Copy Location Constraint */
281 typedef struct bLocateLikeConstraint {
282         struct Object           *tar;
283         int                     flag;
284         int                     reserved1;
285         /** MAX_ID_NAME-2. */
286         char            subtarget[64];
287 } bLocateLikeConstraint;
288
289 /* Copy Scale Constraint */
290 typedef struct bSizeLikeConstraint {
291         struct Object           *tar;
292         int                     flag;
293         int                     reserved1;
294         /** MAX_ID_NAME-2. */
295         char            subtarget[64];
296 } bSizeLikeConstraint;
297
298 /* Maintain Volume Constraint */
299 typedef struct bSameVolumeConstraint {
300         int                     flag;
301         float           volume;
302 } bSameVolumeConstraint;
303
304 /* Copy Transform Constraint */
305 typedef struct bTransLikeConstraint {
306         struct Object *tar;
307         /** MAX_ID_NAME-2. */
308         char            subtarget[64];
309 } bTransLikeConstraint;
310
311 /* Floor Constraint */
312 typedef struct bMinMaxConstraint {
313         struct Object *tar;
314         int                     minmaxflag;
315         float           offset;
316         int                     flag;
317         /** For backward compatibility. */
318         short           sticky, stuck;
319         char _pad[4];
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         char _pad[4];
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         char _pad[6];
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         char _pad[4];
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         char _pad[4];
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;
579         char _pad[4];
580 } bCameraSolverConstraint;
581
582 /* Camera Solver constraints */
583 typedef struct bObjectSolverConstraint {
584         struct MovieClip        *clip;
585         int             flag;
586         char _pad[4];
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         /** Invalid/legacy constraint */
610         CONSTRAINT_TYPE_NULL = 0,
611         /** Unimplemented non longer :) - during constraints recode, Aligorith */
612         CONSTRAINT_TYPE_CHILDOF = 1,
613         CONSTRAINT_TYPE_TRACKTO = 2,
614         CONSTRAINT_TYPE_KINEMATIC = 3,
615         CONSTRAINT_TYPE_FOLLOWPATH = 4,
616         /** Unimplemented no longer :) - Aligorith */
617         CONSTRAINT_TYPE_ROTLIMIT = 5,
618         /** Unimplemented no longer :) - Aligorith */
619         CONSTRAINT_TYPE_LOCLIMIT = 6,
620         /** Unimplemented no longer :) - Aligorith */
621         CONSTRAINT_TYPE_SIZELIMIT = 7,
622         CONSTRAINT_TYPE_ROTLIKE = 8,
623         CONSTRAINT_TYPE_LOCLIKE = 9,
624         CONSTRAINT_TYPE_SIZELIKE = 10,
625         /** Unimplemented no longer :) - Aligorith. Scripts */
626         CONSTRAINT_TYPE_PYTHON = 11,
627         CONSTRAINT_TYPE_ACTION = 12,
628         /** New Tracking constraint that locks an axis in place - theeth */
629         CONSTRAINT_TYPE_LOCKTRACK = 13,
630         /** limit distance */
631         CONSTRAINT_TYPE_DISTLIMIT = 14,
632         /** claiming this to be mine :) is in tuhopuu bjornmose */
633         CONSTRAINT_TYPE_STRETCHTO = 15,
634         /** floor constraint */
635         CONSTRAINT_TYPE_MINMAX = 16,
636         /* CONSTRAINT_TYPE_DEPRECATED = 17 */
637         /** clampto constraint */
638         CONSTRAINT_TYPE_CLAMPTO = 18,
639         /** transformation (loc/rot/size -> loc/rot/size) constraint */
640         CONSTRAINT_TYPE_TRANSFORM = 19,
641         /** shrinkwrap (loc/rot) constraint */
642         CONSTRAINT_TYPE_SHRINKWRAP = 20,
643         /** New Tracking constraint that minimizes twisting */
644         CONSTRAINT_TYPE_DAMPTRACK = 21,
645         /** Spline-IK - Align 'n' bones to a curve */
646         CONSTRAINT_TYPE_SPLINEIK = 22,
647         /** Copy transform matrix */
648         CONSTRAINT_TYPE_TRANSLIKE = 23,
649         /** Maintain volume during scaling */
650         CONSTRAINT_TYPE_SAMEVOL = 24,
651         /** Pivot Constraint */
652         CONSTRAINT_TYPE_PIVOT = 25,
653         /** Follow Track Constraint */
654         CONSTRAINT_TYPE_FOLLOWTRACK = 26,
655         /** Camera Solver Constraint */
656         CONSTRAINT_TYPE_CAMERASOLVER = 27,
657         /** Object Solver Constraint */
658         CONSTRAINT_TYPE_OBJECTSOLVER = 28,
659         /** Transform Cache Constraint */
660         CONSTRAINT_TYPE_TRANSFORM_CACHE = 29,
661         /** Armature Deform Constraint */
662         CONSTRAINT_TYPE_ARMATURE = 30,
663
664         /* NOTE: no constraints are allowed to be added after this */
665         NUM_CONSTRAINT_TYPES
666 } eBConstraint_Types;
667
668 /* bConstraint->flag */
669 /* flags 0x2 (1 << 1) and 0x8 (1 << 3) were used in past */
670 /* flag 0x20 (1 << 5) was used to indicate that a constraint was evaluated
671  *                  using a 'local' hack for posebones only. */
672 typedef enum eBConstraint_Flags {
673         /* expand for UI */
674         CONSTRAINT_EXPAND =             (1 << 0),
675         /* pre-check for illegal object name or bone name */
676         CONSTRAINT_DISABLE =    (1 << 2),
677         /* to indicate which Ipo should be shown, maybe for 3d access later too */
678         CONSTRAINT_ACTIVE =     (1 << 4),
679         /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
680         CONSTRAINT_SPACEONCE =  (1 << 6),
681         /* influence ipo is on constraint itself, not in action channel */
682         CONSTRAINT_OWN_IPO      = (1 << 7),
683         /* indicates that constraint was added locally (i.e.  didn't come from the proxy-lib) */
684         CONSTRAINT_PROXY_LOCAL = (1 << 8),
685         /* indicates that constraint is temporarily disabled (only used in GE) */
686         CONSTRAINT_OFF = (1 << 9),
687         /* use bbone curve shape when calculating headtail values (also used by dependency graph!) */
688         CONSTRAINT_BBONE_SHAPE = (1 << 10),
689         /* That constraint has been inserted in local override (i.e. it can be fully edited!). */
690         CONSTRAINT_STATICOVERRIDE_LOCAL = (1 << 11),
691         /* use full transformation (not just segment locations) - only set at runtime  */
692         CONSTRAINT_BBONE_SHAPE_FULL = (1 << 12),
693 } eBConstraint_Flags;
694
695 /* bConstraint->ownspace/tarspace */
696 typedef enum eBConstraint_SpaceTypes {
697         /** Default for all - worldspace. */
698         CONSTRAINT_SPACE_WORLD = 0,
699         /** For objects (relative to parent/without parent influence),
700          * for bones (along normals of bone, without parent/restpositions). */
701         CONSTRAINT_SPACE_LOCAL = 1,
702         /** For posechannels - pose space. */
703         CONSTRAINT_SPACE_POSE = 2,
704         /** For posechannels - local with parent. */
705         CONSTRAINT_SPACE_PARLOCAL = 3,
706         /** For files from between 2.43-2.46 (should have been parlocal). */
707         CONSTRAINT_SPACE_INVALID = 4 /* do not exchange for anything! */
708 } eBConstraint_SpaceTypes;
709
710 /* bConstraintChannel.flag */
711 // XXX deprecated... old AnimSys
712 typedef enum eConstraintChannel_Flags {
713         CONSTRAINT_CHANNEL_SELECT =             (1 << 0),
714         CONSTRAINT_CHANNEL_PROTECTED =  (1 << 1),
715 } eConstraintChannel_Flags;
716
717 /* -------------------------------------- */
718
719 /* bRotateLikeConstraint.flag */
720 typedef enum eCopyRotation_Flags {
721         ROTLIKE_X                       = (1 << 0),
722         ROTLIKE_Y                       = (1 << 1),
723         ROTLIKE_Z                       = (1 << 2),
724         ROTLIKE_X_INVERT        = (1 << 4),
725         ROTLIKE_Y_INVERT        = (1 << 5),
726         ROTLIKE_Z_INVERT        = (1 << 6),
727         ROTLIKE_OFFSET          = (1 << 7),
728 } eCopyRotation_Flags;
729
730 /* bLocateLikeConstraint.flag */
731 typedef enum eCopyLocation_Flags {
732         LOCLIKE_X                       = (1 << 0),
733         LOCLIKE_Y                       = (1 << 1),
734         LOCLIKE_Z                       = (1 << 2),
735         /** LOCLIKE_TIP is a deprecated option... use headtail=1.0f instead */
736         LOCLIKE_TIP                     = (1 << 3),
737         LOCLIKE_X_INVERT        = (1 << 4),
738         LOCLIKE_Y_INVERT        = (1 << 5),
739         LOCLIKE_Z_INVERT        = (1 << 6),
740         LOCLIKE_OFFSET          = (1 << 7),
741 } eCopyLocation_Flags;
742
743 /* bSizeLikeConstraint.flag */
744 typedef enum eCopyScale_Flags {
745         SIZELIKE_X              = (1 << 0),
746         SIZELIKE_Y              = (1 << 1),
747         SIZELIKE_Z              = (1 << 2),
748         SIZELIKE_OFFSET = (1 << 3),
749         SIZELIKE_MULTIPLY = (1 << 4),
750 } eCopyScale_Flags;
751
752 /* bTransformConstraint.to/from */
753 typedef enum eTransform_ToFrom {
754         TRANS_LOCATION = 0,
755         TRANS_ROTATION = 1,
756         TRANS_SCALE    = 2,
757 } eTransform_ToFrom;
758
759 /* bSameVolumeConstraint.flag */
760 typedef enum eSameVolume_Modes {
761         SAMEVOL_X               = 0,
762         SAMEVOL_Y               = 1,
763         SAMEVOL_Z               = 2,
764 } eSameVolume_Modes;
765
766 /* bActionConstraint.flag */
767 typedef enum eActionConstraint_Flags {
768         /* Bones use "object" part of target action, instead of "same bone name" part */
769         ACTCON_BONE_USE_OBJECT_ACTION = (1 << 0),
770 } eActionConstraint_Flags;
771
772 /* Locked-Axis Values (Locked Track) */
773 typedef enum eLockAxis_Modes {
774         LOCK_X = 0,
775         LOCK_Y = 1,
776         LOCK_Z = 2,
777 } eLockAxis_Modes;
778
779 /* Up-Axis Values (TrackTo and Locked Track) */
780 typedef enum eUpAxis_Modes {
781         UP_X = 0,
782         UP_Y = 1,
783         UP_Z = 2,
784 } eUpAxis_Modes;
785
786 /* Tracking axis (TrackTo, Locked Track, Damped Track) and minmax (floor) constraint */
787 typedef enum eTrackToAxis_Modes {
788         TRACK_X         = 0,
789         TRACK_Y         = 1,
790         TRACK_Z         = 2,
791         TRACK_nX        = 3,
792         TRACK_nY        = 4,
793         TRACK_nZ        = 5
794 } eTrackToAxis_Modes;
795
796 /* Shrinkwrap flags */
797 typedef enum eShrinkwrap_Flags {
798         /* Also raycast in the opposite direction. */
799         CON_SHRINKWRAP_PROJECT_OPPOSITE         = (1 << 0),
800         /* Invert the cull mode when projecting opposite. */
801         CON_SHRINKWRAP_PROJECT_INVERT_CULL      = (1 << 1),
802         /* Align the specified axis to the target normal. */
803         CON_SHRINKWRAP_TRACK_NORMAL             = (1 << 2),
804
805         /* Ignore front faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE */
806         CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE   = (1 << 3),
807         /* Ignore back faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_BACKFACE */
808         CON_SHRINKWRAP_PROJECT_CULL_BACKFACE    = (1 << 4),
809 } eShrinkwrap_Flags;
810
811 #define CON_SHRINKWRAP_PROJECT_CULL_MASK (CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE | CON_SHRINKWRAP_PROJECT_CULL_BACKFACE)
812
813 /* FollowPath flags */
814 typedef enum eFollowPath_Flags {
815         FOLLOWPATH_FOLLOW       = (1 << 0),
816         FOLLOWPATH_STATIC       = (1 << 1),
817         FOLLOWPATH_RADIUS       = (1 << 2),
818 } eFollowPath_Flags;
819
820 /* bTrackToConstraint->flags */
821 typedef enum eTrackTo_Flags {
822         TARGET_Z_UP     = (1 << 0),
823 } eTrackTo_Flags;
824
825 /* Stretch To Constraint -> volmode */
826 typedef enum eStretchTo_VolMode {
827         VOLUME_XZ       = 0,
828         VOLUME_X        = 1,
829         VOLUME_Z        = 2,
830         NO_VOLUME       = 3,
831 } eStretchTo_VolMode;
832
833 /* Stretch To Constraint -> plane mode */
834 typedef enum eStretchTo_PlaneMode {
835         PLANE_X         = 0,
836         PLANE_Y         = 1,
837         PLANE_Z         = 2,
838 } eStretchTo_PlaneMode;
839
840 /* Clamp-To Constraint ->flag */
841 typedef enum eClampTo_Modes {
842         CLAMPTO_AUTO = 0,
843         CLAMPTO_X    = 1,
844         CLAMPTO_Y    = 2,
845         CLAMPTO_Z    = 3,
846 } eClampTo_Modes;
847
848 /* ClampTo Constraint ->flag2 */
849 typedef enum eClampTo_Flags {
850         CLAMPTO_CYCLIC  = (1 << 0),
851 } eClampTo_Flags;
852
853 /* bKinematicConstraint->flag */
854 typedef enum eKinematic_Flags {
855         CONSTRAINT_IK_TIP                       = (1 << 0),
856         CONSTRAINT_IK_ROT                       = (1 << 1),
857         /* targetless */
858         CONSTRAINT_IK_AUTO                      = (1 << 2),
859         /* autoik */
860         CONSTRAINT_IK_TEMP                      = (1 << 3),
861         CONSTRAINT_IK_STRETCH           = (1 << 4),
862         CONSTRAINT_IK_POS                       = (1 << 5),
863         CONSTRAINT_IK_SETANGLE          = (1 << 6),
864         CONSTRAINT_IK_GETANGLE          = (1 << 7),
865         /* limit axis */
866         CONSTRAINT_IK_NO_POS_X          = (1 << 8),
867         CONSTRAINT_IK_NO_POS_Y          = (1 << 9),
868         CONSTRAINT_IK_NO_POS_Z          = (1 << 10),
869         CONSTRAINT_IK_NO_ROT_X          = (1 << 11),
870         CONSTRAINT_IK_NO_ROT_Y          = (1 << 12),
871         CONSTRAINT_IK_NO_ROT_Z          = (1 << 13),
872         /* axis relative to target */
873         CONSTRAINT_IK_TARGETAXIS        = (1 << 14),
874 } eKinematic_Flags;
875
876 /* bSplineIKConstraint->flag */
877 typedef enum eSplineIK_Flags {
878         /* chain has been attached to spline */
879         CONSTRAINT_SPLINEIK_BOUND                       = (1 << 0),
880         /* root of chain is not influenced by the constraint */
881         CONSTRAINT_SPLINEIK_NO_ROOT                     = (1 << 1),
882         /* bones in the chain should not scale to fit the curve */
883         CONSTRAINT_SPLINEIK_SCALE_LIMITED       = (1 << 2),
884         /* evenly distribute the bones along the path regardless of length */
885         CONSTRAINT_SPLINEIK_EVENSPLITS          = (1 << 3),
886         /* don't adjust the x and z scaling of the bones by the curve radius */
887         CONSTRAINT_SPLINEIK_NO_CURVERAD         = (1 << 4),
888
889         /* for "volumetric" xz scale mode, limit the minimum or maximum scale values */
890         CONSTRAINT_SPLINEIK_USE_BULGE_MIN       = (1 << 5),
891         CONSTRAINT_SPLINEIK_USE_BULGE_MAX       = (1 << 6),
892 } eSplineIK_Flags;
893
894 /* bSplineIKConstraint->xzScaleMode */
895 typedef enum eSplineIK_XZScaleModes {
896         /* no x/z scaling */
897         CONSTRAINT_SPLINEIK_XZS_NONE                    = 0,
898         /* bones in the chain should take their x/z scales from the original scaling */
899         CONSTRAINT_SPLINEIK_XZS_ORIGINAL                = 1,
900         /* x/z scales are the inverse of the y-scale */
901         CONSTRAINT_SPLINEIK_XZS_INVERSE                 = 2,
902         /* x/z scales are computed using a volume preserving technique (from Stretch To constraint) */
903         CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC              = 3,
904 } eSplineIK_XZScaleModes;
905
906 /* bArmatureConstraint -> flag */
907 typedef enum eArmature_Flags {
908         /** use dual quaternion blending */
909         CONSTRAINT_ARMATURE_QUATERNION      = (1 << 0),
910         /** use envelopes */
911         CONSTRAINT_ARMATURE_ENVELOPE        = (1 << 1),
912         /** use current bone location */
913         CONSTRAINT_ARMATURE_CUR_LOCATION    = (1 << 2),
914 } eArmature_Flags;
915
916 /* MinMax (floor) flags */
917 typedef enum eFloor_Flags {
918         MINMAX_STICKY   = (1 << 0),
919         MINMAX_STUCK    = (1 << 1),
920         MINMAX_USEROT   = (1 << 2),
921 } eFloor_Flags;
922
923 /* transform limiting constraints -> flag2 */
924 typedef enum eTransformLimits_Flags2 {
925         /* not used anymore - for older Limit Location constraints only */
926         LIMIT_NOPARENT  = (1 << 0),
927         /* for all Limit constraints - allow to be used during transform? */
928         LIMIT_TRANSFORM = (1 << 1),
929 } eTransformLimits_Flags2;
930
931 /* transform limiting constraints -> flag (own flags)  */
932 typedef enum eTransformLimits_Flags {
933         LIMIT_XMIN = (1 << 0),
934         LIMIT_XMAX = (1 << 1),
935         LIMIT_YMIN = (1 << 2),
936         LIMIT_YMAX = (1 << 3),
937         LIMIT_ZMIN = (1 << 4),
938         LIMIT_ZMAX = (1 << 5),
939 } eTransformLimits_Flags;
940
941 /* limit rotation constraint -> flag (own flags) */
942 typedef enum eRotLimit_Flags {
943         LIMIT_XROT = (1 << 0),
944         LIMIT_YROT = (1 << 1),
945         LIMIT_ZROT = (1 << 2),
946 } eRotLimit_Flags;
947
948 /* distance limit constraint */
949         /* bDistLimitConstraint->flag */
950 typedef enum eDistLimit_Flag {
951         /* "soft" cushion effect when reaching the limit sphere */ // NOT IMPLEMENTED!
952         LIMITDIST_USESOFT       = (1 << 0),
953         /* as for all Limit constraints - allow to be used during transform? */
954         LIMITDIST_TRANSFORM = (1 << 1),
955 } eDistLimit_Flag;
956
957         /* bDistLimitConstraint->mode */
958 typedef enum eDistLimit_Modes {
959         LIMITDIST_INSIDE    = 0,
960         LIMITDIST_OUTSIDE   = 1,
961         LIMITDIST_ONSURFACE = 2,
962 } eDistLimit_Modes;
963
964 /* python constraint -> flag */
965 typedef enum ePyConstraint_Flags {
966         PYCON_USETARGETS        = (1 << 0),
967         PYCON_SCRIPTERROR       = (1 << 1),
968 } ePyConstraint_Flags;
969
970 /* ChildOf Constraint -> flag */
971 typedef enum eChildOf_Flags {
972         CHILDOF_LOCX    = (1 << 0),
973         CHILDOF_LOCY    = (1 << 1),
974         CHILDOF_LOCZ    = (1 << 2),
975         CHILDOF_ROTX    = (1 << 3),
976         CHILDOF_ROTY    = (1 << 4),
977         CHILDOF_ROTZ    = (1 << 5),
978         CHILDOF_SIZEX   = (1 << 6),
979         CHILDOF_SIZEY   = (1 << 7),
980         CHILDOF_SIZEZ   = (1 << 8),
981         CHILDOF_ALL             = 511,
982 } eChildOf_Flags;
983
984 /* Pivot Constraint */
985         /* Restrictions for Pivot Constraint axis to consider for enabling constraint */
986 typedef enum ePivotConstraint_Axis {
987         /* do not consider this activity-clamping */
988         PIVOTCON_AXIS_NONE = -1,
989
990         /* consider -ve x-axis rotations */
991         PIVOTCON_AXIS_X_NEG = 0,
992         /* consider -ve y-axis rotations */
993         PIVOTCON_AXIS_Y_NEG = 1,
994         /* consider -ve z-axis rotations */
995         PIVOTCON_AXIS_Z_NEG = 2,
996
997         /* consider +ve x-axis rotations */
998         PIVOTCON_AXIS_X = 3,
999         /* consider +ve y-axis rotations */
1000         PIVOTCON_AXIS_Y = 4,
1001         /* consider +ve z-axis rotations */
1002         PIVOTCON_AXIS_Z = 5,
1003 } ePivotConstraint_Axis;
1004
1005         /* settings for Pivot Constraint in general */
1006 typedef enum ePivotConstraint_Flag {
1007         /* offset is to be interpreted as being a fixed-point in space */
1008         PIVOTCON_FLAG_OFFSET_ABS        = (1 << 0),
1009         /* rotation-based activation uses negative rotation to drive result */
1010         PIVOTCON_FLAG_ROTACT_NEG        = (1 << 1),
1011 } ePivotConstraint_Flag;
1012
1013 typedef enum eFollowTrack_Flags {
1014         FOLLOWTRACK_ACTIVECLIP  = (1 << 0),
1015         FOLLOWTRACK_USE_3D_POSITION     = (1 << 1),
1016         FOLLOWTRACK_USE_UNDISTORTION    = (1 << 2),
1017 } eFollowTrack_Flags;
1018
1019 typedef enum eFollowTrack_FrameMethod {
1020         FOLLOWTRACK_FRAME_STRETCH = 0,
1021         FOLLOWTRACK_FRAME_FIT = 1,
1022         FOLLOWTRACK_FRAME_CROP = 2,
1023 } eFollowTrack_FrameMethod;
1024
1025 /* CameraSolver Constraint -> flag */
1026 typedef enum eCameraSolver_Flags {
1027         CAMERASOLVER_ACTIVECLIP = (1 << 0),
1028 } eCameraSolver_Flags;
1029
1030 /* ObjectSolver Constraint -> flag */
1031 typedef enum eObjectSolver_Flags {
1032         OBJECTSOLVER_ACTIVECLIP = (1 << 0),
1033 } eObjectSolver_Flags;
1034
1035 /* ObjectSolver Constraint -> flag */
1036 typedef enum eStretchTo_Flags {
1037         STRETCHTOCON_USE_BULGE_MIN = (1 << 0),
1038         STRETCHTOCON_USE_BULGE_MAX = (1 << 1),
1039 } eStretchTo_Flags;
1040
1041 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
1042 #define CONSTRAINT_RB_BALL      1
1043 #define CONSTRAINT_RB_HINGE     2
1044 #define CONSTRAINT_RB_CONETWIST 4
1045 #define CONSTRAINT_RB_VEHICLE   11
1046 #define CONSTRAINT_RB_GENERIC6DOF 12
1047
1048 #endif