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