GPencil: Hide self_overlap parameter for Texture strokes
[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    * Subtarget 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   /** MAX_ID_NAME-2. */
319   char subtarget[64];
320   int _pad;
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   char _pad[4];
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   char _pad[6];
405 } bRigidBodyJointConstraint;
406
407 /* Clamp-To Constraint */
408 typedef struct bClampToConstraint {
409   /** 'target' must be a curve. */
410   struct Object *tar;
411   /** Which axis/plane to compare owner's location on . */
412   int flag;
413   /** For legacy reasons, this is flag2. used for any extra settings. */
414   int flag2;
415 } bClampToConstraint;
416
417 /* Child Of Constraint */
418 typedef struct bChildOfConstraint {
419   /** Object which will act as parent (or target comes from). */
420   struct Object *tar;
421   /** Settings. */
422   int flag;
423   char _pad[4];
424   /** Parent-inverse matrix to use. */
425   float invmat[4][4];
426   /** String to specify a subobject target, MAX_ID_NAME-2. */
427   char subtarget[64];
428 } bChildOfConstraint;
429
430 /* Generic Transform->Transform Constraint */
431 typedef struct bTransformConstraint {
432   /** Target (i.e. 'driver' object/bone). */
433   struct Object *tar;
434   /** MAX_ID_NAME-2. */
435   char subtarget[64];
436
437   /** Can be loc(0), rot(1) or size(2). */
438   short from, to;
439   /** Defines which target-axis deform is copied by each owner-axis. */
440   char map[3];
441   /** Extrapolate motion? if 0, confine to ranges. */
442   char expo;
443
444   /** From_min/max defines range of target transform. */
445   float from_min[3];
446   /** To map on to to_min/max range. */
447   float from_max[3];
448   /** Range of motion on owner caused by target . */
449   float to_min[3];
450   float to_max[3];
451
452   /** From_min/max defines range of target transform. */
453   float from_min_rot[3];
454   /** To map on to to_min/max range. */
455   float from_max_rot[3];
456   /** Range of motion on owner caused by target . */
457   float to_min_rot[3];
458   float to_max_rot[3];
459
460   /** From_min/max defines range of target transform. */
461   float from_min_scale[3];
462   /** To map on to to_min/max range. */
463   float from_max_scale[3];
464   /** Range of motion on owner caused by target . */
465   float to_min_scale[3];
466   float to_max_scale[3];
467 } bTransformConstraint;
468
469 /* Pivot Constraint */
470 typedef struct bPivotConstraint {
471   /* Pivot Point:
472    * Either target object + offset, or just offset is used
473    */
474   /** Target object (optional). */
475   struct Object *tar;
476   /** Subtarget name (optional), MAX_ID_NAME-2. */
477   char subtarget[64];
478   /** Offset from the target to use, regardless of whether it exists. */
479   float offset[3];
480
481   /* Rotation-driven activation:
482    * This option provides easier one-stop setups for footrolls
483    */
484   /** Rotation axes to consider for this (#ePivotConstraint_Axis). */
485   short rotAxis;
486
487   /* General flags */
488   /** #ePivotConstraint_Flag. */
489   short flag;
490 } bPivotConstraint;
491
492 /* transform limiting constraints - zero target ----------------------------  */
493 /* Limit Location Constraint */
494 typedef struct bLocLimitConstraint {
495   float xmin, xmax;
496   float ymin, ymax;
497   float zmin, zmax;
498   short flag;
499   short flag2;
500 } bLocLimitConstraint;
501
502 /* Limit Rotation Constraint */
503 typedef struct bRotLimitConstraint {
504   float xmin, xmax;
505   float ymin, ymax;
506   float zmin, zmax;
507   short flag;
508   short flag2;
509 } bRotLimitConstraint;
510
511 /* Limit Scale Constraint */
512 typedef struct bSizeLimitConstraint {
513   float xmin, xmax;
514   float ymin, ymax;
515   float zmin, zmax;
516   short flag;
517   short flag2;
518 } bSizeLimitConstraint;
519
520 /* Limit Distance Constraint */
521 typedef struct bDistLimitConstraint {
522   struct Object *tar;
523   /** MAX_ID_NAME-2. */
524   char subtarget[64];
525
526   /** Distance (radius of clamping sphere) from target. */
527   float dist;
528   /** Distance from clamping-sphere to start applying 'fade'. */
529   float soft;
530
531   /** Settings. */
532   short flag;
533   /** How to limit in relation to clamping sphere. */
534   short mode;
535   char _pad[4];
536 } bDistLimitConstraint;
537
538 /* ShrinkWrap Constraint */
539 typedef struct bShrinkwrapConstraint {
540   struct Object *target;
541   /** Distance to kept from target. */
542   float dist;
543   /** Shrink type (look on MOD shrinkwrap for values). */
544   short shrinkType;
545   /** Axis to project/constrain. */
546   char projAxis;
547   /** Space to project axis in. */
548   char projAxisSpace;
549   /** Distance to search. */
550   float projLimit;
551   /** Inside/outside/on surface (see MOD shrinkwrap). */
552   char shrinkMode;
553   /** Options. */
554   char flag;
555   /** Axis to align to normal. */
556   char trackAxis;
557   char _pad;
558 } bShrinkwrapConstraint;
559
560 /* Follow Track constraints */
561 typedef struct bFollowTrackConstraint {
562   struct MovieClip *clip;
563   /** MAX_NAME. */
564   char track[64];
565   int flag;
566   int frame_method;
567   /** MAX_NAME. */
568   char object[64];
569   struct Object *camera;
570   struct Object *depth_ob;
571 } bFollowTrackConstraint;
572
573 /* Camera Solver constraints */
574 typedef struct bCameraSolverConstraint {
575   struct MovieClip *clip;
576   int flag;
577   char _pad[4];
578 } bCameraSolverConstraint;
579
580 /* Camera Solver constraints */
581 typedef struct bObjectSolverConstraint {
582   struct MovieClip *clip;
583   int flag;
584   char _pad[4];
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   /** FILE_MAX. */
596   char object_path[1024];
597
598   /* Runtime. */
599   struct CacheReader *reader;
600   char reader_object_path[1024];
601 } bTransformCacheConstraint;
602
603 /* ------------------------------------------ */
604
605 /* bConstraint->type
606  * - Do not ever change the order of these, or else files could get
607  *   broken as their correct value cannot be resolved
608  */
609 typedef enum eBConstraint_Types {
610   /** Invalid/legacy constraint */
611   CONSTRAINT_TYPE_NULL = 0,
612   /** Unimplemented non longer :) - during constraints recode, Aligorith */
613   CONSTRAINT_TYPE_CHILDOF = 1,
614   CONSTRAINT_TYPE_TRACKTO = 2,
615   CONSTRAINT_TYPE_KINEMATIC = 3,
616   CONSTRAINT_TYPE_FOLLOWPATH = 4,
617   /** Unimplemented no longer :) - Aligorith */
618   CONSTRAINT_TYPE_ROTLIMIT = 5,
619   /** Unimplemented no longer :) - Aligorith */
620   CONSTRAINT_TYPE_LOCLIMIT = 6,
621   /** Unimplemented no longer :) - Aligorith */
622   CONSTRAINT_TYPE_SIZELIMIT = 7,
623   CONSTRAINT_TYPE_ROTLIKE = 8,
624   CONSTRAINT_TYPE_LOCLIKE = 9,
625   CONSTRAINT_TYPE_SIZELIKE = 10,
626   /** Unimplemented no longer :) - Aligorith. Scripts */
627   CONSTRAINT_TYPE_PYTHON = 11,
628   CONSTRAINT_TYPE_ACTION = 12,
629   /** New Tracking constraint that locks an axis in place - theeth */
630   CONSTRAINT_TYPE_LOCKTRACK = 13,
631   /** limit distance */
632   CONSTRAINT_TYPE_DISTLIMIT = 14,
633   /** claiming this to be mine :) is in tuhopuu bjornmose */
634   CONSTRAINT_TYPE_STRETCHTO = 15,
635   /** floor constraint */
636   CONSTRAINT_TYPE_MINMAX = 16,
637   /* CONSTRAINT_TYPE_DEPRECATED = 17 */
638   /** clampto constraint */
639   CONSTRAINT_TYPE_CLAMPTO = 18,
640   /** transformation (loc/rot/size -> loc/rot/size) constraint */
641   CONSTRAINT_TYPE_TRANSFORM = 19,
642   /** shrinkwrap (loc/rot) constraint */
643   CONSTRAINT_TYPE_SHRINKWRAP = 20,
644   /** New Tracking constraint that minimizes twisting */
645   CONSTRAINT_TYPE_DAMPTRACK = 21,
646   /** Spline-IK - Align 'n' bones to a curve */
647   CONSTRAINT_TYPE_SPLINEIK = 22,
648   /** Copy transform matrix */
649   CONSTRAINT_TYPE_TRANSLIKE = 23,
650   /** Maintain volume during scaling */
651   CONSTRAINT_TYPE_SAMEVOL = 24,
652   /** Pivot Constraint */
653   CONSTRAINT_TYPE_PIVOT = 25,
654   /** Follow Track Constraint */
655   CONSTRAINT_TYPE_FOLLOWTRACK = 26,
656   /** Camera Solver Constraint */
657   CONSTRAINT_TYPE_CAMERASOLVER = 27,
658   /** Object Solver Constraint */
659   CONSTRAINT_TYPE_OBJECTSOLVER = 28,
660   /** Transform Cache Constraint */
661   CONSTRAINT_TYPE_TRANSFORM_CACHE = 29,
662   /** Armature Deform Constraint */
663   CONSTRAINT_TYPE_ARMATURE = 30,
664
665   /* NOTE: no constraints are allowed to be added after this */
666   NUM_CONSTRAINT_TYPES,
667 } eBConstraint_Types;
668
669 /* bConstraint->flag */
670 /* flags 0x2 (1 << 1) and 0x8 (1 << 3) were used in past */
671 /* flag 0x20 (1 << 5) was used to indicate that a constraint was evaluated
672  *                  using a 'local' hack for posebones only. */
673 typedef enum eBConstraint_Flags {
674   /* expand for UI */
675   CONSTRAINT_EXPAND = (1 << 0),
676   /* pre-check for illegal object name or bone name */
677   CONSTRAINT_DISABLE = (1 << 2),
678   /* to indicate which Ipo should be shown, maybe for 3d access later too */
679   CONSTRAINT_ACTIVE = (1 << 4),
680   /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
681   CONSTRAINT_SPACEONCE = (1 << 6),
682   /* influence ipo is on constraint itself, not in action channel */
683   CONSTRAINT_OWN_IPO = (1 << 7),
684   /* indicates that constraint was added locally (i.e.  didn't come from the proxy-lib) */
685   CONSTRAINT_PROXY_LOCAL = (1 << 8),
686   /* indicates that constraint is temporarily disabled (only used in GE) */
687   CONSTRAINT_OFF = (1 << 9),
688   /* use bbone curve shape when calculating headtail values (also used by dependency graph!) */
689   CONSTRAINT_BBONE_SHAPE = (1 << 10),
690   /* That constraint has been inserted in local override (i.e. it can be fully edited!). */
691   CONSTRAINT_OVERRIDE_LIBRARY_LOCAL = (1 << 11),
692   /* use full transformation (not just segment locations) - only set at runtime  */
693   CONSTRAINT_BBONE_SHAPE_FULL = (1 << 12),
694 } eBConstraint_Flags;
695
696 /* bConstraint->ownspace/tarspace */
697 typedef enum eBConstraint_SpaceTypes {
698   /** Default for all - worldspace. */
699   CONSTRAINT_SPACE_WORLD = 0,
700   /** For objects (relative to parent/without parent influence),
701    * for bones (along normals of bone, without parent/restpositions). */
702   CONSTRAINT_SPACE_LOCAL = 1,
703   /** For posechannels - pose space. */
704   CONSTRAINT_SPACE_POSE = 2,
705   /** For posechannels - local with parent. */
706   CONSTRAINT_SPACE_PARLOCAL = 3,
707   /** For files from between 2.43-2.46 (should have been parlocal). */
708   CONSTRAINT_SPACE_INVALID = 4, /* do not exchange for anything! */
709 } eBConstraint_SpaceTypes;
710
711 /* bConstraintChannel.flag */
712 // XXX deprecated... old AnimSys
713 typedef enum eConstraintChannel_Flags {
714   CONSTRAINT_CHANNEL_SELECT = (1 << 0),
715   CONSTRAINT_CHANNEL_PROTECTED = (1 << 1),
716 } eConstraintChannel_Flags;
717
718 /* -------------------------------------- */
719
720 /* bRotateLikeConstraint.flag */
721 typedef enum eCopyRotation_Flags {
722   ROTLIKE_X = (1 << 0),
723   ROTLIKE_Y = (1 << 1),
724   ROTLIKE_Z = (1 << 2),
725   ROTLIKE_X_INVERT = (1 << 4),
726   ROTLIKE_Y_INVERT = (1 << 5),
727   ROTLIKE_Z_INVERT = (1 << 6),
728   ROTLIKE_OFFSET = (1 << 7),
729 } eCopyRotation_Flags;
730
731 /* bLocateLikeConstraint.flag */
732 typedef enum eCopyLocation_Flags {
733   LOCLIKE_X = (1 << 0),
734   LOCLIKE_Y = (1 << 1),
735   LOCLIKE_Z = (1 << 2),
736   /** LOCLIKE_TIP is a deprecated option... use headtail=1.0f instead */
737   LOCLIKE_TIP = (1 << 3),
738   LOCLIKE_X_INVERT = (1 << 4),
739   LOCLIKE_Y_INVERT = (1 << 5),
740   LOCLIKE_Z_INVERT = (1 << 6),
741   LOCLIKE_OFFSET = (1 << 7),
742 } eCopyLocation_Flags;
743
744 /* bSizeLikeConstraint.flag */
745 typedef enum eCopyScale_Flags {
746   SIZELIKE_X = (1 << 0),
747   SIZELIKE_Y = (1 << 1),
748   SIZELIKE_Z = (1 << 2),
749   SIZELIKE_OFFSET = (1 << 3),
750   SIZELIKE_MULTIPLY = (1 << 4),
751 } eCopyScale_Flags;
752
753 /* bTransformConstraint.to/from */
754 typedef enum eTransform_ToFrom {
755   TRANS_LOCATION = 0,
756   TRANS_ROTATION = 1,
757   TRANS_SCALE = 2,
758 } eTransform_ToFrom;
759
760 /* bSameVolumeConstraint.free_axis */
761 typedef enum eSameVolume_Axis {
762   SAMEVOL_X = 0,
763   SAMEVOL_Y = 1,
764   SAMEVOL_Z = 2,
765 } eSameVolume_Axis;
766
767 /* bSameVolumeConstraint.mode */
768 typedef enum eSameVolume_Mode {
769   /* Strictly maintain the volume, overriding non-free axis scale. */
770   SAMEVOL_STRICT = 0,
771   /* Maintain the volume when scale is uniform, pass non-uniform other axis scale through. */
772   SAMEVOL_UNIFORM = 1,
773   /* Maintain the volume when scaled only on the free axis, pass other axis scale through. */
774   SAMEVOL_SINGLE_AXIS = 2,
775 } eSameVolume_Mode;
776
777 /* bActionConstraint.flag */
778 typedef enum eActionConstraint_Flags {
779   /* Bones use "object" part of target action, instead of "same bone name" part */
780   ACTCON_BONE_USE_OBJECT_ACTION = (1 << 0),
781 } eActionConstraint_Flags;
782
783 /* Locked-Axis Values (Locked Track) */
784 typedef enum eLockAxis_Modes {
785   LOCK_X = 0,
786   LOCK_Y = 1,
787   LOCK_Z = 2,
788 } eLockAxis_Modes;
789
790 /* Up-Axis Values (TrackTo and Locked Track) */
791 typedef enum eUpAxis_Modes {
792   UP_X = 0,
793   UP_Y = 1,
794   UP_Z = 2,
795 } eUpAxis_Modes;
796
797 /* Tracking axis (TrackTo, Locked Track, Damped Track) and minmax (floor) constraint */
798 typedef enum eTrackToAxis_Modes {
799   TRACK_X = 0,
800   TRACK_Y = 1,
801   TRACK_Z = 2,
802   TRACK_nX = 3,
803   TRACK_nY = 4,
804   TRACK_nZ = 5,
805 } eTrackToAxis_Modes;
806
807 /* Shrinkwrap flags */
808 typedef enum eShrinkwrap_Flags {
809   /* Also raycast in the opposite direction. */
810   CON_SHRINKWRAP_PROJECT_OPPOSITE = (1 << 0),
811   /* Invert the cull mode when projecting opposite. */
812   CON_SHRINKWRAP_PROJECT_INVERT_CULL = (1 << 1),
813   /* Align the specified axis to the target normal. */
814   CON_SHRINKWRAP_TRACK_NORMAL = (1 << 2),
815
816   /* Ignore front faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE */
817   CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE = (1 << 3),
818   /* Ignore back faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_BACKFACE */
819   CON_SHRINKWRAP_PROJECT_CULL_BACKFACE = (1 << 4),
820 } eShrinkwrap_Flags;
821
822 #define CON_SHRINKWRAP_PROJECT_CULL_MASK \
823   (CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE | CON_SHRINKWRAP_PROJECT_CULL_BACKFACE)
824
825 /* FollowPath flags */
826 typedef enum eFollowPath_Flags {
827   FOLLOWPATH_FOLLOW = (1 << 0),
828   FOLLOWPATH_STATIC = (1 << 1),
829   FOLLOWPATH_RADIUS = (1 << 2),
830 } eFollowPath_Flags;
831
832 /* bTrackToConstraint->flags */
833 typedef enum eTrackTo_Flags {
834   TARGET_Z_UP = (1 << 0),
835 } eTrackTo_Flags;
836
837 /* Stretch To Constraint -> volmode */
838 typedef enum eStretchTo_VolMode {
839   VOLUME_XZ = 0,
840   VOLUME_X = 1,
841   VOLUME_Z = 2,
842   NO_VOLUME = 3,
843 } eStretchTo_VolMode;
844
845 /* Stretch To Constraint -> plane mode */
846 typedef enum eStretchTo_PlaneMode {
847   PLANE_X = 0,
848   PLANE_Y = 1,
849   PLANE_Z = 2,
850 } eStretchTo_PlaneMode;
851
852 /* Clamp-To Constraint ->flag */
853 typedef enum eClampTo_Modes {
854   CLAMPTO_AUTO = 0,
855   CLAMPTO_X = 1,
856   CLAMPTO_Y = 2,
857   CLAMPTO_Z = 3,
858 } eClampTo_Modes;
859
860 /* ClampTo Constraint ->flag2 */
861 typedef enum eClampTo_Flags {
862   CLAMPTO_CYCLIC = (1 << 0),
863 } eClampTo_Flags;
864
865 /* bKinematicConstraint->flag */
866 typedef enum eKinematic_Flags {
867   CONSTRAINT_IK_TIP = (1 << 0),
868   CONSTRAINT_IK_ROT = (1 << 1),
869   /* targetless */
870   CONSTRAINT_IK_AUTO = (1 << 2),
871   /* autoik */
872   CONSTRAINT_IK_TEMP = (1 << 3),
873   CONSTRAINT_IK_STRETCH = (1 << 4),
874   CONSTRAINT_IK_POS = (1 << 5),
875   CONSTRAINT_IK_SETANGLE = (1 << 6),
876   CONSTRAINT_IK_GETANGLE = (1 << 7),
877   /* limit axis */
878   CONSTRAINT_IK_NO_POS_X = (1 << 8),
879   CONSTRAINT_IK_NO_POS_Y = (1 << 9),
880   CONSTRAINT_IK_NO_POS_Z = (1 << 10),
881   CONSTRAINT_IK_NO_ROT_X = (1 << 11),
882   CONSTRAINT_IK_NO_ROT_Y = (1 << 12),
883   CONSTRAINT_IK_NO_ROT_Z = (1 << 13),
884   /* axis relative to target */
885   CONSTRAINT_IK_TARGETAXIS = (1 << 14),
886 } eKinematic_Flags;
887
888 /* bSplineIKConstraint->flag */
889 typedef enum eSplineIK_Flags {
890   /* chain has been attached to spline */
891   CONSTRAINT_SPLINEIK_BOUND = (1 << 0),
892   /* root of chain is not influenced by the constraint */
893   CONSTRAINT_SPLINEIK_NO_ROOT = (1 << 1),
894 #ifdef DNA_DEPRECATED
895   /* bones in the chain should not scale to fit the curve */
896   CONSTRAINT_SPLINEIK_SCALE_LIMITED = (1 << 2),
897 #endif
898   /* evenly distribute the bones along the path regardless of length */
899   CONSTRAINT_SPLINEIK_EVENSPLITS = (1 << 3),
900   /* don't adjust the x and z scaling of the bones by the curve radius */
901   CONSTRAINT_SPLINEIK_NO_CURVERAD = (1 << 4),
902
903   /* for "volumetric" xz scale mode, limit the minimum or maximum scale values */
904   CONSTRAINT_SPLINEIK_USE_BULGE_MIN = (1 << 5),
905   CONSTRAINT_SPLINEIK_USE_BULGE_MAX = (1 << 6),
906
907   /* apply volume preservation over original scaling of the bone */
908   CONSTRAINT_SPLINEIK_USE_ORIGINAL_SCALE = (1 << 7),
909 } eSplineIK_Flags;
910
911 /* bSplineIKConstraint->xzScaleMode */
912 typedef enum eSplineIK_XZScaleModes {
913   /* no x/z scaling */
914   CONSTRAINT_SPLINEIK_XZS_NONE = 0,
915   /* bones in the chain should take their x/z scales from the original scaling */
916   CONSTRAINT_SPLINEIK_XZS_ORIGINAL = 1,
917   /* x/z scales are the inverse of the y-scale */
918   CONSTRAINT_SPLINEIK_XZS_INVERSE = 2,
919   /* x/z scales are computed using a volume preserving technique (from Stretch To constraint) */
920   CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC = 3,
921 } eSplineIK_XZScaleModes;
922
923 /* bSplineIKConstraint->yScaleMode */
924 typedef enum eSplineIK_YScaleModes {
925   /* no y scaling */
926   CONSTRAINT_SPLINEIK_YS_NONE = 0,
927   /* bones in the chain should be scaled to fit the length of the curve */
928   CONSTRAINT_SPLINEIK_YS_FIT_CURVE = 1,
929   /* bones in the chain should take their y scales from the original scaling */
930   CONSTRAINT_SPLINEIK_YS_ORIGINAL = 2,
931 } eSplineIK_YScaleModes;
932
933 /* bArmatureConstraint -> flag */
934 typedef enum eArmature_Flags {
935   /** use dual quaternion blending */
936   CONSTRAINT_ARMATURE_QUATERNION = (1 << 0),
937   /** use envelopes */
938   CONSTRAINT_ARMATURE_ENVELOPE = (1 << 1),
939   /** use current bone location */
940   CONSTRAINT_ARMATURE_CUR_LOCATION = (1 << 2),
941 } eArmature_Flags;
942
943 /* MinMax (floor) flags */
944 typedef enum eFloor_Flags {
945   /* MINMAX_STICKY = (1 << 0), */ /* Deprecated. */
946   /* MINMAX_STUCK = (1 << 1), */  /* Deprecated. */
947   MINMAX_USEROT = (1 << 2),
948 } eFloor_Flags;
949
950 /* transform limiting constraints -> flag2 */
951 typedef enum eTransformLimits_Flags2 {
952   /* not used anymore - for older Limit Location constraints only */
953   LIMIT_NOPARENT = (1 << 0),
954   /* for all Limit constraints - allow to be used during transform? */
955   LIMIT_TRANSFORM = (1 << 1),
956 } eTransformLimits_Flags2;
957
958 /* transform limiting constraints -> flag (own flags)  */
959 typedef enum eTransformLimits_Flags {
960   LIMIT_XMIN = (1 << 0),
961   LIMIT_XMAX = (1 << 1),
962   LIMIT_YMIN = (1 << 2),
963   LIMIT_YMAX = (1 << 3),
964   LIMIT_ZMIN = (1 << 4),
965   LIMIT_ZMAX = (1 << 5),
966 } eTransformLimits_Flags;
967
968 /* limit rotation constraint -> flag (own flags) */
969 typedef enum eRotLimit_Flags {
970   LIMIT_XROT = (1 << 0),
971   LIMIT_YROT = (1 << 1),
972   LIMIT_ZROT = (1 << 2),
973 } eRotLimit_Flags;
974
975 /* distance limit constraint */
976 /* bDistLimitConstraint->flag */
977 typedef enum eDistLimit_Flag {
978   /* "soft" cushion effect when reaching the limit sphere */  // NOT IMPLEMENTED!
979   LIMITDIST_USESOFT = (1 << 0),
980   /* as for all Limit constraints - allow to be used during transform? */
981   LIMITDIST_TRANSFORM = (1 << 1),
982 } eDistLimit_Flag;
983
984 /* bDistLimitConstraint->mode */
985 typedef enum eDistLimit_Modes {
986   LIMITDIST_INSIDE = 0,
987   LIMITDIST_OUTSIDE = 1,
988   LIMITDIST_ONSURFACE = 2,
989 } eDistLimit_Modes;
990
991 /* python constraint -> flag */
992 typedef enum ePyConstraint_Flags {
993   PYCON_USETARGETS = (1 << 0),
994   PYCON_SCRIPTERROR = (1 << 1),
995 } ePyConstraint_Flags;
996
997 /* ChildOf Constraint -> flag */
998 typedef enum eChildOf_Flags {
999   CHILDOF_LOCX = (1 << 0),
1000   CHILDOF_LOCY = (1 << 1),
1001   CHILDOF_LOCZ = (1 << 2),
1002   CHILDOF_ROTX = (1 << 3),
1003   CHILDOF_ROTY = (1 << 4),
1004   CHILDOF_ROTZ = (1 << 5),
1005   CHILDOF_SIZEX = (1 << 6),
1006   CHILDOF_SIZEY = (1 << 7),
1007   CHILDOF_SIZEZ = (1 << 8),
1008   CHILDOF_ALL = 511,
1009 } eChildOf_Flags;
1010
1011 /* Pivot Constraint */
1012 /* Restrictions for Pivot Constraint axis to consider for enabling constraint */
1013 typedef enum ePivotConstraint_Axis {
1014   /* do not consider this activity-clamping */
1015   PIVOTCON_AXIS_NONE = -1,
1016
1017   /* consider -ve x-axis rotations */
1018   PIVOTCON_AXIS_X_NEG = 0,
1019   /* consider -ve y-axis rotations */
1020   PIVOTCON_AXIS_Y_NEG = 1,
1021   /* consider -ve z-axis rotations */
1022   PIVOTCON_AXIS_Z_NEG = 2,
1023
1024   /* consider +ve x-axis rotations */
1025   PIVOTCON_AXIS_X = 3,
1026   /* consider +ve y-axis rotations */
1027   PIVOTCON_AXIS_Y = 4,
1028   /* consider +ve z-axis rotations */
1029   PIVOTCON_AXIS_Z = 5,
1030 } ePivotConstraint_Axis;
1031
1032 /* settings for Pivot Constraint in general */
1033 typedef enum ePivotConstraint_Flag {
1034   /* offset is to be interpreted as being a fixed-point in space */
1035   PIVOTCON_FLAG_OFFSET_ABS = (1 << 0),
1036   /* rotation-based activation uses negative rotation to drive result */
1037   PIVOTCON_FLAG_ROTACT_NEG = (1 << 1),
1038 } ePivotConstraint_Flag;
1039
1040 typedef enum eFollowTrack_Flags {
1041   FOLLOWTRACK_ACTIVECLIP = (1 << 0),
1042   FOLLOWTRACK_USE_3D_POSITION = (1 << 1),
1043   FOLLOWTRACK_USE_UNDISTORTION = (1 << 2),
1044 } eFollowTrack_Flags;
1045
1046 typedef enum eFollowTrack_FrameMethod {
1047   FOLLOWTRACK_FRAME_STRETCH = 0,
1048   FOLLOWTRACK_FRAME_FIT = 1,
1049   FOLLOWTRACK_FRAME_CROP = 2,
1050 } eFollowTrack_FrameMethod;
1051
1052 /* CameraSolver Constraint -> flag */
1053 typedef enum eCameraSolver_Flags {
1054   CAMERASOLVER_ACTIVECLIP = (1 << 0),
1055 } eCameraSolver_Flags;
1056
1057 /* ObjectSolver Constraint -> flag */
1058 typedef enum eObjectSolver_Flags {
1059   OBJECTSOLVER_ACTIVECLIP = (1 << 0),
1060 } eObjectSolver_Flags;
1061
1062 /* ObjectSolver Constraint -> flag */
1063 typedef enum eStretchTo_Flags {
1064   STRETCHTOCON_USE_BULGE_MIN = (1 << 0),
1065   STRETCHTOCON_USE_BULGE_MAX = (1 << 1),
1066 } eStretchTo_Flags;
1067
1068 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
1069 #define CONSTRAINT_RB_BALL 1
1070 #define CONSTRAINT_RB_HINGE 2
1071 #define CONSTRAINT_RB_CONETWIST 4
1072 #define CONSTRAINT_RB_VEHICLE 11
1073 #define CONSTRAINT_RB_GENERIC6DOF 12
1074
1075 #endif