CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.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_ID.h"
29 #include "DNA_defs.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, */ /* UNUSED */
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   char euler_order;
275   char mix_mode;
276   char _pad[2];
277   /** MAX_ID_NAME-2. */
278   char subtarget[64];
279 } bRotateLikeConstraint;
280
281 /* Copy Location Constraint */
282 typedef struct bLocateLikeConstraint {
283   struct Object *tar;
284   int flag;
285   int reserved1;
286   /** MAX_ID_NAME-2. */
287   char subtarget[64];
288 } bLocateLikeConstraint;
289
290 /* Copy Scale Constraint */
291 typedef struct bSizeLikeConstraint {
292   struct Object *tar;
293   int flag;
294   float power;
295   /** MAX_ID_NAME-2. */
296   char subtarget[64];
297 } bSizeLikeConstraint;
298
299 /* Maintain Volume Constraint */
300 typedef struct bSameVolumeConstraint {
301   char free_axis;
302   char mode;
303   char _pad[2];
304   float volume;
305 } bSameVolumeConstraint;
306
307 /* Copy Transform Constraint */
308 typedef struct bTransLikeConstraint {
309   struct Object *tar;
310   char mix_mode;
311   char _pad[7];
312   /** MAX_ID_NAME-2. */
313   char subtarget[64];
314 } bTransLikeConstraint;
315
316 /* Floor Constraint */
317 typedef struct bMinMaxConstraint {
318   struct Object *tar;
319   int minmaxflag;
320   float offset;
321   int flag;
322   /** MAX_ID_NAME-2. */
323   char subtarget[64];
324   int _pad;
325 } bMinMaxConstraint;
326
327 /* Action Constraint */
328 typedef struct bActionConstraint {
329   struct Object *tar;
330   /** What transform 'channel' drives the result. */
331   short type;
332   /** Was used in versions prior to the Constraints recode. */
333   short local;
334   int start;
335   int end;
336   float min;
337   float max;
338   int flag;
339   char mix_mode;
340   char _pad[7];
341   struct bAction *act;
342   /** MAX_ID_NAME-2. */
343   char subtarget[64];
344 } bActionConstraint;
345
346 /* Locked Axis Tracking constraint */
347 typedef struct bLockTrackConstraint {
348   struct Object *tar;
349   int trackflag;
350   int lockflag;
351   /** MAX_ID_NAME-2. */
352   char subtarget[64];
353 } bLockTrackConstraint;
354
355 /* Damped Tracking constraint */
356 typedef struct bDampTrackConstraint {
357   struct Object *tar;
358   int trackflag;
359   char _pad[4];
360   /** MAX_ID_NAME-2. */
361   char subtarget[64];
362 } bDampTrackConstraint;
363
364 /* Follow Path constraints */
365 typedef struct bFollowPathConstraint {
366   /** Must be path object. */
367   struct Object *tar;
368
369   /** Offset in time on the path (in frames), when NOT using 'fixed position'. */
370   float offset;
371   /** Parametric offset factor defining position along path, when using 'fixed position'. */
372   float offset_fac;
373
374   int followflag;
375
376   short trackflag;
377   short upflag;
378 } bFollowPathConstraint;
379
380 /* Stretch to constraint */
381 typedef struct bStretchToConstraint {
382   struct Object *tar;
383   int flag;
384   int volmode;
385   int plane;
386   float orglength;
387   float bulge;
388   float bulge_min;
389   float bulge_max;
390   float bulge_smooth;
391   /** MAX_ID_NAME-2. */
392   char subtarget[64];
393 } bStretchToConstraint;
394
395 /* Rigid Body constraint */
396 typedef struct bRigidBodyJointConstraint {
397   struct Object *tar;
398   struct Object *child;
399   int type;
400   float pivX;
401   float pivY;
402   float pivZ;
403   float axX;
404   float axY;
405   float axZ;
406   float minLimit[6];
407   float maxLimit[6];
408   float extraFz;
409   short flag;
410   char _pad[6];
411 } bRigidBodyJointConstraint;
412
413 /* Clamp-To Constraint */
414 typedef struct bClampToConstraint {
415   /** 'target' must be a curve. */
416   struct Object *tar;
417   /** Which axis/plane to compare owner's location on . */
418   int flag;
419   /** For legacy reasons, this is flag2. used for any extra settings. */
420   int flag2;
421 } bClampToConstraint;
422
423 /* Child Of Constraint */
424 typedef struct bChildOfConstraint {
425   /** Object which will act as parent (or target comes from). */
426   struct Object *tar;
427   /** Settings. */
428   int flag;
429   char _pad[4];
430   /** Parent-inverse matrix to use. */
431   float invmat[4][4];
432   /** String to specify a subobject target, MAX_ID_NAME-2. */
433   char subtarget[64];
434 } bChildOfConstraint;
435
436 /* Generic Transform->Transform Constraint */
437 typedef struct bTransformConstraint {
438   /** Target (i.e. 'driver' object/bone). */
439   struct Object *tar;
440   /** MAX_ID_NAME-2. */
441   char subtarget[64];
442
443   /** Can be loc(0), rot(1) or size(2). */
444   short from, to;
445   /** Defines which target-axis deform is copied by each owner-axis. */
446   char map[3];
447   /** Extrapolate motion? if 0, confine to ranges. */
448   char expo;
449
450   /** Input rotation type - uses the same values as driver targets. */
451   char from_rotation_mode;
452   /** Output euler order override. */
453   char to_euler_order;
454
455   /** Mixing modes for location, rotation, and scale. */
456   char mix_mode_loc;
457   char mix_mode_rot;
458   char mix_mode_scale;
459
460   char _pad[3];
461
462   /** From_min/max defines range of target transform. */
463   float from_min[3];
464   /** To map on to to_min/max range. */
465   float from_max[3];
466   /** Range of motion on owner caused by target . */
467   float to_min[3];
468   float to_max[3];
469
470   /** From_min/max defines range of target transform. */
471   float from_min_rot[3];
472   /** To map on to to_min/max range. */
473   float from_max_rot[3];
474   /** Range of motion on owner caused by target . */
475   float to_min_rot[3];
476   float to_max_rot[3];
477
478   /** From_min/max defines range of target transform. */
479   float from_min_scale[3];
480   /** To map on to to_min/max range. */
481   float from_max_scale[3];
482   /** Range of motion on owner caused by target . */
483   float to_min_scale[3];
484   float to_max_scale[3];
485 } bTransformConstraint;
486
487 /* Pivot Constraint */
488 typedef struct bPivotConstraint {
489   /* Pivot Point:
490    * Either target object + offset, or just offset is used
491    */
492   /** Target object (optional). */
493   struct Object *tar;
494   /** Subtarget name (optional), MAX_ID_NAME-2. */
495   char subtarget[64];
496   /** Offset from the target to use, regardless of whether it exists. */
497   float offset[3];
498
499   /* Rotation-driven activation:
500    * This option provides easier one-stop setups for foot-rolls.
501    */
502   /** Rotation axes to consider for this (#ePivotConstraint_Axis). */
503   short rotAxis;
504
505   /* General flags */
506   /** #ePivotConstraint_Flag. */
507   short flag;
508 } bPivotConstraint;
509
510 /* transform limiting constraints - zero target ----------------------------  */
511 /* Limit Location Constraint */
512 typedef struct bLocLimitConstraint {
513   float xmin, xmax;
514   float ymin, ymax;
515   float zmin, zmax;
516   short flag;
517   short flag2;
518 } bLocLimitConstraint;
519
520 /* Limit Rotation Constraint */
521 typedef struct bRotLimitConstraint {
522   float xmin, xmax;
523   float ymin, ymax;
524   float zmin, zmax;
525   short flag;
526   short flag2;
527 } bRotLimitConstraint;
528
529 /* Limit Scale Constraint */
530 typedef struct bSizeLimitConstraint {
531   float xmin, xmax;
532   float ymin, ymax;
533   float zmin, zmax;
534   short flag;
535   short flag2;
536 } bSizeLimitConstraint;
537
538 /* Limit Distance Constraint */
539 typedef struct bDistLimitConstraint {
540   struct Object *tar;
541   /** MAX_ID_NAME-2. */
542   char subtarget[64];
543
544   /** Distance (radius of clamping sphere) from target. */
545   float dist;
546   /** Distance from clamping-sphere to start applying 'fade'. */
547   float soft;
548
549   /** Settings. */
550   short flag;
551   /** How to limit in relation to clamping sphere. */
552   short mode;
553   char _pad[4];
554 } bDistLimitConstraint;
555
556 /* ShrinkWrap Constraint */
557 typedef struct bShrinkwrapConstraint {
558   struct Object *target;
559   /** Distance to kept from target. */
560   float dist;
561   /** Shrink type (look on MOD shrinkwrap for values). */
562   short shrinkType;
563   /** Axis to project/constrain. */
564   char projAxis;
565   /** Space to project axis in. */
566   char projAxisSpace;
567   /** Distance to search. */
568   float projLimit;
569   /** Inside/outside/on surface (see MOD shrinkwrap). */
570   char shrinkMode;
571   /** Options. */
572   char flag;
573   /** Axis to align to normal. */
574   char trackAxis;
575   char _pad;
576 } bShrinkwrapConstraint;
577
578 /* Follow Track constraints */
579 typedef struct bFollowTrackConstraint {
580   struct MovieClip *clip;
581   /** MAX_NAME. */
582   char track[64];
583   int flag;
584   int frame_method;
585   /** MAX_NAME. */
586   char object[64];
587   struct Object *camera;
588   struct Object *depth_ob;
589 } bFollowTrackConstraint;
590
591 /* Camera Solver constraints */
592 typedef struct bCameraSolverConstraint {
593   struct MovieClip *clip;
594   int flag;
595   char _pad[4];
596 } bCameraSolverConstraint;
597
598 /* Camera Solver constraints */
599 typedef struct bObjectSolverConstraint {
600   struct MovieClip *clip;
601   int flag;
602   char _pad[4];
603   /** MAX_NAME. */
604   char object[64];
605   /** Parent-inverse matrix to use. */
606   float invmat[4][4];
607   struct Object *camera;
608 } bObjectSolverConstraint;
609
610 /* Transform matrix cache constraint */
611 typedef struct bTransformCacheConstraint {
612   struct CacheFile *cache_file;
613   /** FILE_MAX. */
614   char object_path[1024];
615
616   /* Runtime. */
617   struct CacheReader *reader;
618   char reader_object_path[1024];
619 } bTransformCacheConstraint;
620
621 /* ------------------------------------------ */
622
623 /* bConstraint->type
624  * - Do not ever change the order of these, or else files could get
625  *   broken as their correct value cannot be resolved
626  */
627 typedef enum eBConstraint_Types {
628   /** Invalid/legacy constraint */
629   CONSTRAINT_TYPE_NULL = 0,
630   /** Unimplemented non longer :) - during constraints recode, Aligorith */
631   CONSTRAINT_TYPE_CHILDOF = 1,
632   CONSTRAINT_TYPE_TRACKTO = 2,
633   CONSTRAINT_TYPE_KINEMATIC = 3,
634   CONSTRAINT_TYPE_FOLLOWPATH = 4,
635   /** Unimplemented no longer :) - Aligorith */
636   CONSTRAINT_TYPE_ROTLIMIT = 5,
637   /** Unimplemented no longer :) - Aligorith */
638   CONSTRAINT_TYPE_LOCLIMIT = 6,
639   /** Unimplemented no longer :) - Aligorith */
640   CONSTRAINT_TYPE_SIZELIMIT = 7,
641   CONSTRAINT_TYPE_ROTLIKE = 8,
642   CONSTRAINT_TYPE_LOCLIKE = 9,
643   CONSTRAINT_TYPE_SIZELIKE = 10,
644   /** Unimplemented no longer :) - Aligorith. Scripts */
645   CONSTRAINT_TYPE_PYTHON = 11,
646   CONSTRAINT_TYPE_ACTION = 12,
647   /** New Tracking constraint that locks an axis in place - theeth */
648   CONSTRAINT_TYPE_LOCKTRACK = 13,
649   /** limit distance */
650   CONSTRAINT_TYPE_DISTLIMIT = 14,
651   /** claiming this to be mine :) is in tuhopuu bjornmose */
652   CONSTRAINT_TYPE_STRETCHTO = 15,
653   /** floor constraint */
654   CONSTRAINT_TYPE_MINMAX = 16,
655   /* CONSTRAINT_TYPE_DEPRECATED = 17 */
656   /** clampto constraint */
657   CONSTRAINT_TYPE_CLAMPTO = 18,
658   /** transformation (loc/rot/size -> loc/rot/size) constraint */
659   CONSTRAINT_TYPE_TRANSFORM = 19,
660   /** shrinkwrap (loc/rot) constraint */
661   CONSTRAINT_TYPE_SHRINKWRAP = 20,
662   /** New Tracking constraint that minimizes twisting */
663   CONSTRAINT_TYPE_DAMPTRACK = 21,
664   /** Spline-IK - Align 'n' bones to a curve */
665   CONSTRAINT_TYPE_SPLINEIK = 22,
666   /** Copy transform matrix */
667   CONSTRAINT_TYPE_TRANSLIKE = 23,
668   /** Maintain volume during scaling */
669   CONSTRAINT_TYPE_SAMEVOL = 24,
670   /** Pivot Constraint */
671   CONSTRAINT_TYPE_PIVOT = 25,
672   /** Follow Track Constraint */
673   CONSTRAINT_TYPE_FOLLOWTRACK = 26,
674   /** Camera Solver Constraint */
675   CONSTRAINT_TYPE_CAMERASOLVER = 27,
676   /** Object Solver Constraint */
677   CONSTRAINT_TYPE_OBJECTSOLVER = 28,
678   /** Transform Cache Constraint */
679   CONSTRAINT_TYPE_TRANSFORM_CACHE = 29,
680   /** Armature Deform Constraint */
681   CONSTRAINT_TYPE_ARMATURE = 30,
682
683   /* NOTE: no constraints are allowed to be added after this */
684   NUM_CONSTRAINT_TYPES,
685 } eBConstraint_Types;
686
687 /* bConstraint->flag */
688 /* flags 0x2 (1 << 1) and 0x8 (1 << 3) were used in past */
689 /* flag 0x20 (1 << 5) was used to indicate that a constraint was evaluated
690  *                  using a 'local' hack for posebones only. */
691 typedef enum eBConstraint_Flags {
692   /* expand for UI */
693   CONSTRAINT_EXPAND = (1 << 0),
694   /* pre-check for illegal object name or bone name */
695   CONSTRAINT_DISABLE = (1 << 2),
696   /* to indicate which Ipo should be shown, maybe for 3d access later too */
697   CONSTRAINT_ACTIVE = (1 << 4),
698   /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
699   CONSTRAINT_SPACEONCE = (1 << 6),
700   /* influence ipo is on constraint itself, not in action channel */
701   CONSTRAINT_OWN_IPO = (1 << 7),
702   /* indicates that constraint was added locally (i.e.  didn't come from the proxy-lib) */
703   CONSTRAINT_PROXY_LOCAL = (1 << 8),
704   /* indicates that constraint is temporarily disabled (only used in GE) */
705   CONSTRAINT_OFF = (1 << 9),
706   /* use bbone curve shape when calculating headtail values (also used by dependency graph!) */
707   CONSTRAINT_BBONE_SHAPE = (1 << 10),
708   /* That constraint has been inserted in local override (i.e. it can be fully edited!). */
709   CONSTRAINT_OVERRIDE_LIBRARY_LOCAL = (1 << 11),
710   /* use full transformation (not just segment locations) - only set at runtime  */
711   CONSTRAINT_BBONE_SHAPE_FULL = (1 << 12),
712 } eBConstraint_Flags;
713
714 /* bConstraint->ownspace/tarspace */
715 typedef enum eBConstraint_SpaceTypes {
716   /** Default for all - worldspace. */
717   CONSTRAINT_SPACE_WORLD = 0,
718   /**
719    * For objects (relative to parent/without parent influence),
720    * for bones (along normals of bone, without parent/rest-positions).
721    */
722   CONSTRAINT_SPACE_LOCAL = 1,
723   /** For posechannels - pose space. */
724   CONSTRAINT_SPACE_POSE = 2,
725   /** For posechannels - local with parent. */
726   CONSTRAINT_SPACE_PARLOCAL = 3,
727   /** For files from between 2.43-2.46 (should have been parlocal). */
728   CONSTRAINT_SPACE_INVALID = 4, /* do not exchange for anything! */
729 } eBConstraint_SpaceTypes;
730
731 /* Common enum for constraints that support override. */
732 typedef enum eConstraint_EulerOrder {
733   /** Automatic euler mode. */
734   CONSTRAINT_EULER_AUTO = 0,
735
736   /** Explicit euler rotation modes - must sync with BLI_math_rotation.h defines. */
737   CONSTRAINT_EULER_XYZ = 1,
738   CONSTRAINT_EULER_XZY = 2,
739   CONSTRAINT_EULER_YXZ = 3,
740   CONSTRAINT_EULER_YZX = 4,
741   CONSTRAINT_EULER_ZXY = 5,
742   CONSTRAINT_EULER_ZYX = 6,
743 } eConstraint_EulerOrder;
744
745 /* -------------------------------------- */
746
747 /* bRotateLikeConstraint.flag */
748 typedef enum eCopyRotation_Flags {
749   ROTLIKE_X = (1 << 0),
750   ROTLIKE_Y = (1 << 1),
751   ROTLIKE_Z = (1 << 2),
752   ROTLIKE_X_INVERT = (1 << 4),
753   ROTLIKE_Y_INVERT = (1 << 5),
754   ROTLIKE_Z_INVERT = (1 << 6),
755 #ifdef DNA_DEPRECATED_ALLOW
756   ROTLIKE_OFFSET = (1 << 7),
757 #endif
758 } eCopyRotation_Flags;
759
760 /* bRotateLikeConstraint.mix_mode */
761 typedef enum eCopyRotation_MixMode {
762   /* Replace rotation channel values. */
763   ROTLIKE_MIX_REPLACE = 0,
764   /* Legacy Offset mode - don't use. */
765   ROTLIKE_MIX_OFFSET = 1,
766   /* Add Euler components together. */
767   ROTLIKE_MIX_ADD = 2,
768   /* Multiply the copied rotation on the left. */
769   ROTLIKE_MIX_BEFORE = 3,
770   /* Multiply the copied rotation on the right. */
771   ROTLIKE_MIX_AFTER = 4,
772 } eCopyRotation_MixMode;
773
774 /* bLocateLikeConstraint.flag */
775 typedef enum eCopyLocation_Flags {
776   LOCLIKE_X = (1 << 0),
777   LOCLIKE_Y = (1 << 1),
778   LOCLIKE_Z = (1 << 2),
779   /** LOCLIKE_TIP is a deprecated option... use headtail=1.0f instead */
780   LOCLIKE_TIP = (1 << 3),
781   LOCLIKE_X_INVERT = (1 << 4),
782   LOCLIKE_Y_INVERT = (1 << 5),
783   LOCLIKE_Z_INVERT = (1 << 6),
784   LOCLIKE_OFFSET = (1 << 7),
785 } eCopyLocation_Flags;
786
787 /* bSizeLikeConstraint.flag */
788 typedef enum eCopyScale_Flags {
789   SIZELIKE_X = (1 << 0),
790   SIZELIKE_Y = (1 << 1),
791   SIZELIKE_Z = (1 << 2),
792   SIZELIKE_OFFSET = (1 << 3),
793   SIZELIKE_MULTIPLY = (1 << 4),
794   SIZELIKE_UNIFORM = (1 << 5),
795 } eCopyScale_Flags;
796
797 /* bTransLikeConstraint.mix_mode */
798 typedef enum eCopyTransforms_MixMode {
799   /* Replace rotation channel values. */
800   TRANSLIKE_MIX_REPLACE = 0,
801   /* Multiply the copied transformation on the left, with anti-shear scale handling. */
802   TRANSLIKE_MIX_BEFORE = 1,
803   /* Multiply the copied transformation on the right, with anti-shear scale handling. */
804   TRANSLIKE_MIX_AFTER = 2,
805 } eCopyTransforms_MixMode;
806
807 /* bTransformConstraint.to/from */
808 typedef enum eTransform_ToFrom {
809   TRANS_LOCATION = 0,
810   TRANS_ROTATION = 1,
811   TRANS_SCALE = 2,
812 } eTransform_ToFrom;
813
814 /* bTransformConstraint.mix_mode_loc */
815 typedef enum eTransform_MixModeLoc {
816   /* Add component values together (default). */
817   TRANS_MIXLOC_ADD = 0,
818   /* Replace component values. */
819   TRANS_MIXLOC_REPLACE = 1,
820 } eTransform_MixModeLoc;
821
822 /* bTransformConstraint.mix_mode_rot */
823 typedef enum eTransform_MixModeRot {
824   /* Add component values together (default). */
825   TRANS_MIXROT_ADD = 0,
826   /* Replace component values. */
827   TRANS_MIXROT_REPLACE = 1,
828   /* Multiply the generated rotation on the left. */
829   TRANS_MIXROT_BEFORE = 2,
830   /* Multiply the generated rotation on the right. */
831   TRANS_MIXROT_AFTER = 3,
832 } eTransform_MixModeRot;
833
834 /* bTransformConstraint.mix_mode_scale */
835 typedef enum eTransform_MixModeScale {
836   /* Replace component values (default). */
837   TRANS_MIXSCALE_REPLACE = 0,
838   /* Multiply component values together. */
839   TRANS_MIXSCALE_MULTIPLY = 1,
840 } eTransform_MixModeScale;
841
842 /* bSameVolumeConstraint.free_axis */
843 typedef enum eSameVolume_Axis {
844   SAMEVOL_X = 0,
845   SAMEVOL_Y = 1,
846   SAMEVOL_Z = 2,
847 } eSameVolume_Axis;
848
849 /* bSameVolumeConstraint.mode */
850 typedef enum eSameVolume_Mode {
851   /* Strictly maintain the volume, overriding non-free axis scale. */
852   SAMEVOL_STRICT = 0,
853   /* Maintain the volume when scale is uniform, pass non-uniform other axis scale through. */
854   SAMEVOL_UNIFORM = 1,
855   /* Maintain the volume when scaled only on the free axis, pass other axis scale through. */
856   SAMEVOL_SINGLE_AXIS = 2,
857 } eSameVolume_Mode;
858
859 /* bActionConstraint.flag */
860 typedef enum eActionConstraint_Flags {
861   /* Bones use "object" part of target action, instead of "same bone name" part */
862   ACTCON_BONE_USE_OBJECT_ACTION = (1 << 0),
863 } eActionConstraint_Flags;
864
865 /* bActionConstraint.mix_mode */
866 typedef enum eActionConstraint_MixMode {
867   /* Multiply the action transformation on the right. */
868   ACTCON_MIX_AFTER_FULL = 0,
869   /* Multiply the action transformation on the right, with anti-shear scale handling. */
870   ACTCON_MIX_AFTER = 1,
871   /* Multiply the action transformation on the left, with anti-shear scale handling. */
872   ACTCON_MIX_BEFORE = 2,
873 } eActionConstraint_MixMode;
874
875 /* Locked-Axis Values (Locked Track) */
876 typedef enum eLockAxis_Modes {
877   LOCK_X = 0,
878   LOCK_Y = 1,
879   LOCK_Z = 2,
880 } eLockAxis_Modes;
881
882 /* Up-Axis Values (TrackTo and Locked Track) */
883 typedef enum eUpAxis_Modes {
884   UP_X = 0,
885   UP_Y = 1,
886   UP_Z = 2,
887 } eUpAxis_Modes;
888
889 /* Tracking axis (TrackTo, Locked Track, Damped Track) and minmax (floor) constraint */
890 typedef enum eTrackToAxis_Modes {
891   TRACK_X = 0,
892   TRACK_Y = 1,
893   TRACK_Z = 2,
894   TRACK_nX = 3,
895   TRACK_nY = 4,
896   TRACK_nZ = 5,
897 } eTrackToAxis_Modes;
898
899 /* Shrinkwrap flags */
900 typedef enum eShrinkwrap_Flags {
901   /* Also raycast in the opposite direction. */
902   CON_SHRINKWRAP_PROJECT_OPPOSITE = (1 << 0),
903   /* Invert the cull mode when projecting opposite. */
904   CON_SHRINKWRAP_PROJECT_INVERT_CULL = (1 << 1),
905   /* Align the specified axis to the target normal. */
906   CON_SHRINKWRAP_TRACK_NORMAL = (1 << 2),
907
908   /* Ignore front faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE */
909   CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE = (1 << 3),
910   /* Ignore back faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_BACKFACE */
911   CON_SHRINKWRAP_PROJECT_CULL_BACKFACE = (1 << 4),
912 } eShrinkwrap_Flags;
913
914 #define CON_SHRINKWRAP_PROJECT_CULL_MASK \
915   (CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE | CON_SHRINKWRAP_PROJECT_CULL_BACKFACE)
916
917 /* FollowPath flags */
918 typedef enum eFollowPath_Flags {
919   FOLLOWPATH_FOLLOW = (1 << 0),
920   FOLLOWPATH_STATIC = (1 << 1),
921   FOLLOWPATH_RADIUS = (1 << 2),
922 } eFollowPath_Flags;
923
924 /* bTrackToConstraint->flags */
925 typedef enum eTrackTo_Flags {
926   TARGET_Z_UP = (1 << 0),
927 } eTrackTo_Flags;
928
929 /* Stretch To Constraint -> volmode */
930 typedef enum eStretchTo_VolMode {
931   VOLUME_XZ = 0,
932   VOLUME_X = 1,
933   VOLUME_Z = 2,
934   NO_VOLUME = 3,
935 } eStretchTo_VolMode;
936
937 /* Stretch To Constraint -> plane mode */
938 typedef enum eStretchTo_PlaneMode {
939   PLANE_X = 0,
940   SWING_Y = 1,
941   PLANE_Z = 2,
942 } eStretchTo_PlaneMode;
943
944 /* Clamp-To Constraint ->flag */
945 typedef enum eClampTo_Modes {
946   CLAMPTO_AUTO = 0,
947   CLAMPTO_X = 1,
948   CLAMPTO_Y = 2,
949   CLAMPTO_Z = 3,
950 } eClampTo_Modes;
951
952 /* ClampTo Constraint ->flag2 */
953 typedef enum eClampTo_Flags {
954   CLAMPTO_CYCLIC = (1 << 0),
955 } eClampTo_Flags;
956
957 /* bKinematicConstraint->flag */
958 typedef enum eKinematic_Flags {
959   CONSTRAINT_IK_TIP = (1 << 0),
960   CONSTRAINT_IK_ROT = (1 << 1),
961   /* targetless */
962   CONSTRAINT_IK_AUTO = (1 << 2),
963   /* autoik */
964   CONSTRAINT_IK_TEMP = (1 << 3),
965   CONSTRAINT_IK_STRETCH = (1 << 4),
966   CONSTRAINT_IK_POS = (1 << 5),
967   CONSTRAINT_IK_SETANGLE = (1 << 6),
968   CONSTRAINT_IK_GETANGLE = (1 << 7),
969   /* limit axis */
970   CONSTRAINT_IK_NO_POS_X = (1 << 8),
971   CONSTRAINT_IK_NO_POS_Y = (1 << 9),
972   CONSTRAINT_IK_NO_POS_Z = (1 << 10),
973   CONSTRAINT_IK_NO_ROT_X = (1 << 11),
974   CONSTRAINT_IK_NO_ROT_Y = (1 << 12),
975   CONSTRAINT_IK_NO_ROT_Z = (1 << 13),
976   /* axis relative to target */
977   CONSTRAINT_IK_TARGETAXIS = (1 << 14),
978 } eKinematic_Flags;
979
980 /* bSplineIKConstraint->flag */
981 typedef enum eSplineIK_Flags {
982   /* chain has been attached to spline */
983   CONSTRAINT_SPLINEIK_BOUND = (1 << 0),
984   /* root of chain is not influenced by the constraint */
985   CONSTRAINT_SPLINEIK_NO_ROOT = (1 << 1),
986 #ifdef DNA_DEPRECATED_ALLOW
987   /* bones in the chain should not scale to fit the curve */
988   CONSTRAINT_SPLINEIK_SCALE_LIMITED = (1 << 2),
989 #endif
990   /* evenly distribute the bones along the path regardless of length */
991   CONSTRAINT_SPLINEIK_EVENSPLITS = (1 << 3),
992   /* don't adjust the x and z scaling of the bones by the curve radius */
993   CONSTRAINT_SPLINEIK_NO_CURVERAD = (1 << 4),
994
995   /* for "volumetric" xz scale mode, limit the minimum or maximum scale values */
996   CONSTRAINT_SPLINEIK_USE_BULGE_MIN = (1 << 5),
997   CONSTRAINT_SPLINEIK_USE_BULGE_MAX = (1 << 6),
998
999   /* apply volume preservation over original scaling of the bone */
1000   CONSTRAINT_SPLINEIK_USE_ORIGINAL_SCALE = (1 << 7),
1001 } eSplineIK_Flags;
1002
1003 /* bSplineIKConstraint->xzScaleMode */
1004 typedef enum eSplineIK_XZScaleModes {
1005   /* no x/z scaling */
1006   CONSTRAINT_SPLINEIK_XZS_NONE = 0,
1007   /* bones in the chain should take their x/z scales from the original scaling */
1008   CONSTRAINT_SPLINEIK_XZS_ORIGINAL = 1,
1009   /* x/z scales are the inverse of the y-scale */
1010   CONSTRAINT_SPLINEIK_XZS_INVERSE = 2,
1011   /* x/z scales are computed using a volume preserving technique (from Stretch To constraint) */
1012   CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC = 3,
1013 } eSplineIK_XZScaleModes;
1014
1015 /* bSplineIKConstraint->yScaleMode */
1016 typedef enum eSplineIK_YScaleModes {
1017   /* no y scaling */
1018   CONSTRAINT_SPLINEIK_YS_NONE = 0,
1019   /* bones in the chain should be scaled to fit the length of the curve */
1020   CONSTRAINT_SPLINEIK_YS_FIT_CURVE = 1,
1021   /* bones in the chain should take their y scales from the original scaling */
1022   CONSTRAINT_SPLINEIK_YS_ORIGINAL = 2,
1023 } eSplineIK_YScaleModes;
1024
1025 /* bArmatureConstraint -> flag */
1026 typedef enum eArmature_Flags {
1027   /** use dual quaternion blending */
1028   CONSTRAINT_ARMATURE_QUATERNION = (1 << 0),
1029   /** use envelopes */
1030   CONSTRAINT_ARMATURE_ENVELOPE = (1 << 1),
1031   /** use current bone location */
1032   CONSTRAINT_ARMATURE_CUR_LOCATION = (1 << 2),
1033 } eArmature_Flags;
1034
1035 /* MinMax (floor) flags */
1036 typedef enum eFloor_Flags {
1037   /* MINMAX_STICKY = (1 << 0), */ /* Deprecated. */
1038   /* MINMAX_STUCK = (1 << 1), */  /* Deprecated. */
1039   MINMAX_USEROT = (1 << 2),
1040 } eFloor_Flags;
1041
1042 /* transform limiting constraints -> flag2 */
1043 typedef enum eTransformLimits_Flags2 {
1044   /* not used anymore - for older Limit Location constraints only */
1045   /* LIMIT_NOPARENT = (1 << 0), */ /* UNUSED */
1046   /* for all Limit constraints - allow to be used during transform? */
1047   LIMIT_TRANSFORM = (1 << 1),
1048 } eTransformLimits_Flags2;
1049
1050 /* transform limiting constraints -> flag (own flags)  */
1051 typedef enum eTransformLimits_Flags {
1052   LIMIT_XMIN = (1 << 0),
1053   LIMIT_XMAX = (1 << 1),
1054   LIMIT_YMIN = (1 << 2),
1055   LIMIT_YMAX = (1 << 3),
1056   LIMIT_ZMIN = (1 << 4),
1057   LIMIT_ZMAX = (1 << 5),
1058 } eTransformLimits_Flags;
1059
1060 /* limit rotation constraint -> flag (own flags) */
1061 typedef enum eRotLimit_Flags {
1062   LIMIT_XROT = (1 << 0),
1063   LIMIT_YROT = (1 << 1),
1064   LIMIT_ZROT = (1 << 2),
1065 } eRotLimit_Flags;
1066
1067 /* distance limit constraint */
1068 /* bDistLimitConstraint->flag */
1069 typedef enum eDistLimit_Flag {
1070   /* "soft" cushion effect when reaching the limit sphere */  // NOT IMPLEMENTED!
1071   LIMITDIST_USESOFT = (1 << 0),
1072   /* as for all Limit constraints - allow to be used during transform? */
1073   LIMITDIST_TRANSFORM = (1 << 1),
1074 } eDistLimit_Flag;
1075
1076 /* bDistLimitConstraint->mode */
1077 typedef enum eDistLimit_Modes {
1078   LIMITDIST_INSIDE = 0,
1079   LIMITDIST_OUTSIDE = 1,
1080   LIMITDIST_ONSURFACE = 2,
1081 } eDistLimit_Modes;
1082
1083 /* python constraint -> flag */
1084 typedef enum ePyConstraint_Flags {
1085   PYCON_USETARGETS = (1 << 0),
1086   PYCON_SCRIPTERROR = (1 << 1),
1087 } ePyConstraint_Flags;
1088
1089 /* ChildOf Constraint -> flag */
1090 typedef enum eChildOf_Flags {
1091   CHILDOF_LOCX = (1 << 0),
1092   CHILDOF_LOCY = (1 << 1),
1093   CHILDOF_LOCZ = (1 << 2),
1094   CHILDOF_ROTX = (1 << 3),
1095   CHILDOF_ROTY = (1 << 4),
1096   CHILDOF_ROTZ = (1 << 5),
1097   CHILDOF_SIZEX = (1 << 6),
1098   CHILDOF_SIZEY = (1 << 7),
1099   CHILDOF_SIZEZ = (1 << 8),
1100   CHILDOF_ALL = 511,
1101   /* Temporary flag used by the Set Inverse operator. */
1102   CHILDOF_SET_INVERSE = (1 << 9),
1103 } eChildOf_Flags;
1104
1105 /* Pivot Constraint */
1106 /* Restrictions for Pivot Constraint axis to consider for enabling constraint */
1107 typedef enum ePivotConstraint_Axis {
1108   /* do not consider this activity-clamping */
1109   PIVOTCON_AXIS_NONE = -1,
1110
1111   /* consider -ve x-axis rotations */
1112   PIVOTCON_AXIS_X_NEG = 0,
1113   /* consider -ve y-axis rotations */
1114   PIVOTCON_AXIS_Y_NEG = 1,
1115   /* consider -ve z-axis rotations */
1116   PIVOTCON_AXIS_Z_NEG = 2,
1117
1118   /* consider +ve x-axis rotations */
1119   PIVOTCON_AXIS_X = 3,
1120   /* consider +ve y-axis rotations */
1121   PIVOTCON_AXIS_Y = 4,
1122   /* consider +ve z-axis rotations */
1123   PIVOTCON_AXIS_Z = 5,
1124 } ePivotConstraint_Axis;
1125
1126 /* settings for Pivot Constraint in general */
1127 typedef enum ePivotConstraint_Flag {
1128   /* offset is to be interpreted as being a fixed-point in space */
1129   PIVOTCON_FLAG_OFFSET_ABS = (1 << 0),
1130   /* rotation-based activation uses negative rotation to drive result */
1131   PIVOTCON_FLAG_ROTACT_NEG = (1 << 1),
1132 } ePivotConstraint_Flag;
1133
1134 typedef enum eFollowTrack_Flags {
1135   FOLLOWTRACK_ACTIVECLIP = (1 << 0),
1136   FOLLOWTRACK_USE_3D_POSITION = (1 << 1),
1137   FOLLOWTRACK_USE_UNDISTORTION = (1 << 2),
1138 } eFollowTrack_Flags;
1139
1140 typedef enum eFollowTrack_FrameMethod {
1141   FOLLOWTRACK_FRAME_STRETCH = 0,
1142   FOLLOWTRACK_FRAME_FIT = 1,
1143   FOLLOWTRACK_FRAME_CROP = 2,
1144 } eFollowTrack_FrameMethod;
1145
1146 /* CameraSolver Constraint -> flag */
1147 typedef enum eCameraSolver_Flags {
1148   CAMERASOLVER_ACTIVECLIP = (1 << 0),
1149 } eCameraSolver_Flags;
1150
1151 /* ObjectSolver Constraint -> flag */
1152 typedef enum eObjectSolver_Flags {
1153   OBJECTSOLVER_ACTIVECLIP = (1 << 0),
1154   /* Temporary flag used by the Set Inverse operator. */
1155   OBJECTSOLVER_SET_INVERSE = (1 << 1),
1156 } eObjectSolver_Flags;
1157
1158 /* ObjectSolver Constraint -> flag */
1159 typedef enum eStretchTo_Flags {
1160   STRETCHTOCON_USE_BULGE_MIN = (1 << 0),
1161   STRETCHTOCON_USE_BULGE_MAX = (1 << 1),
1162 } eStretchTo_Flags;
1163
1164 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
1165 #define CONSTRAINT_RB_BALL 1
1166 #define CONSTRAINT_RB_HINGE 2
1167 #define CONSTRAINT_RB_CONETWIST 4
1168 #define CONSTRAINT_RB_VEHICLE 11
1169 #define CONSTRAINT_RB_GENERIC6DOF 12
1170
1171 #endif