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