DNA_constraint_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "DNA_ID.h"
#include "DNA_defs.h"
#include "DNA_listBase.h"
 
struct Ipo;
struct Text;
 
/* channels reside in Object or Action (ListBase) constraintChannels */
/* XXX: deprecated... old AnimSys. */
typedef struct bConstraintChannel {
  struct bConstraintChannel *next, *prev;
  struct Ipo *ipo;
  short flag;
  char name[30];
} bConstraintChannel;
 
typedef struct bConstraint {
  struct bConstraint *next, *prev;
 
  void *data;
  short type;
  short flag;
 
  char ownspace;
  char tarspace;
 
  /* An "expand" bit for each of the constraint's (sub)panels (uiPanelDataExpansion). */
  short ui_expand_flag;
 
  struct Object *space_object;
  char space_subtarget[64];
 
  char name[64];
 
  float enforce;
  float headtail;
 
  /* old animation system, deprecated for 2.5. */
  struct Ipo *ipo DNA_DEPRECATED;
 
  /* Below are read-only fields that are set at runtime
   * by the solver for use in the GE (only IK at the moment). */
  float lin_error;
  float rot_error;
} bConstraint;
 
/* Multiple-target constraints --------------------- */
 
/* This struct defines a constraint target.
 * It is used during constraint solving regardless of how many targets the
 * constraint has.
 */
typedef struct bConstraintTarget {
  struct bConstraintTarget *next, *prev;
 
  struct Object *tar;
  char subtarget[64];
 
  float matrix[4][4];
 
  short space;
  short flag;
  short type;
  short rotOrder;
  float weight;
  char _pad[4];
} bConstraintTarget;
 
/* bConstraintTarget -> flag */
typedef enum eConstraintTargetFlag {
  CONSTRAINT_TAR_TEMP = (1 << 0),
  CONSTRAINT_TAR_CUSTOM_SPACE = (1 << 1),
} eConstraintTargetFlag;
 
/* bConstraintTarget/bConstraintOb -> type */
typedef enum eConstraintObType {
  CONSTRAINT_OBTYPE_OBJECT = 1,
  CONSTRAINT_OBTYPE_BONE = 2,
  CONSTRAINT_OBTYPE_VERT = 3,
  /* CONSTRAINT_OBTYPE_CV = 4, */ /* UNUSED */
} eConstraintObType;
 
/* Python Script Constraint */
typedef struct bPythonConstraint {
  struct Text *text;
  IDProperty *prop;
 
  int flag;
  int tarnum;
 
  ListBase targets;
 
  struct Object *tar;
  char subtarget[64];
} bPythonConstraint;
 
/* Inverse-Kinematics (IK) constraint
 * This constraint supports a variety of mode determine by the type field
 * according to eConstraint_IK_Type.
 * Some fields are used by all types, some are specific to some types
 * This is indicated in the comments for each field
 */
typedef struct bKinematicConstraint {
  struct Object *tar;
  short iterations;
  short flag;
  short rootbone;
  short max_rootbone;
  char subtarget[64];
  struct Object *poletar;
  char polesubtarget[64];
  float poleangle;
  float weight;
  float orientweight;
  float grabtarget[3];
  short type;
  short mode;
  float dist;
} bKinematicConstraint;
 
typedef enum eConstraint_IK_Type {
  CONSTRAINT_IK_COPYPOSE = 0,
  CONSTRAINT_IK_DISTANCE = 1,
} eConstraint_IK_Type;
 
/* Spline IK Constraint
 * Aligns 'n' bones to the curvature defined by the curve,
 * with the chain ending on the bone that owns this constraint,
 * and starting on the nth parent.
 */
typedef struct bSplineIKConstraint {
  /* target(s) */
  struct Object *tar;
 
  /* binding details */
  float *points;
  short numpoints;
  short chainlen;
 
  /* settings */
  short flag;
  short xzScaleMode;
  short yScaleMode;
  short _pad[3];
 
  /* volume preservation settings */
  float bulge;
  float bulge_min;
  float bulge_max;
  float bulge_smooth;
} bSplineIKConstraint;
 
/* Armature Constraint */
typedef struct bArmatureConstraint {
  int flag;
  char _pad[4];
 
  ListBase targets;
} bArmatureConstraint;
 
/* Single-target sub-object constraints --------------------- */
 
/* Track To Constraint */
typedef struct bTrackToConstraint {
  struct Object *tar;
  int reserved1;
  int reserved2;
  int flags;
  char _pad[4];
  char subtarget[64];
} bTrackToConstraint;
 
/* Copy Rotation Constraint */
typedef struct bRotateLikeConstraint {
  struct Object *tar;
  int flag;
  char euler_order;
  char mix_mode;
  char _pad[2];
  char subtarget[64];
} bRotateLikeConstraint;
 
/* Copy Location Constraint */
typedef struct bLocateLikeConstraint {
  struct Object *tar;
  int flag;
  int reserved1;
  char subtarget[64];
} bLocateLikeConstraint;
 
/* Copy Scale Constraint */
typedef struct bSizeLikeConstraint {
  struct Object *tar;
  int flag;
  float power;
  char subtarget[64];
} bSizeLikeConstraint;
 
/* Maintain Volume Constraint */
typedef struct bSameVolumeConstraint {
  char free_axis;
  char mode;
  char _pad[2];
  float volume;
} bSameVolumeConstraint;
 
/* Copy Transform Constraint */
typedef struct bTransLikeConstraint {
  struct Object *tar;
  int flag;
  char mix_mode;
  char _pad[3];
  char subtarget[64];
} bTransLikeConstraint;
 
/* Floor Constraint */
typedef struct bMinMaxConstraint {
  struct Object *tar;
  int minmaxflag;
  float offset;
  int flag;
  char subtarget[64];
  int _pad;
} bMinMaxConstraint;
 
/* Action Constraint */
typedef struct bActionConstraint {
  struct Object *tar;
  short type;
  short local;
  int start;
  int end;
  float min;
  float max;
  int flag;
  char mix_mode;
  char _pad[3];
  float eval_time; /* Only used when flag ACTCON_USE_EVAL_TIME is set. */
  struct bAction *act;
  int32_t action_slot_handle;
  char action_slot_name[66]; /* MAX_ID_NAME */
  char _pad1[2];
  char subtarget[64];
} bActionConstraint;
 
/* Locked Axis Tracking constraint */
typedef struct bLockTrackConstraint {
  struct Object *tar;
  int trackflag;
  int lockflag;
  char subtarget[64];
} bLockTrackConstraint;
 
/* Damped Tracking constraint */
typedef struct bDampTrackConstraint {
  struct Object *tar;
  int trackflag;
  char _pad[4];
  char subtarget[64];
} bDampTrackConstraint;
 
/* Follow Path constraints */
typedef struct bFollowPathConstraint {
  struct Object *tar;
 
  float offset;
  float offset_fac;
 
  int followflag;
 
  short trackflag;
  short upflag;
} bFollowPathConstraint;
 
/* Stretch to constraint */
typedef struct bStretchToConstraint {
  struct Object *tar;
  int flag;
  int volmode;
  int plane;
  float orglength;
  float bulge;
  float bulge_min;
  float bulge_max;
  float bulge_smooth;
  char subtarget[64];
} bStretchToConstraint;
 
/* DEPRECATED: Rigid Body constraint */
typedef struct bRigidBodyJointConstraint {
  struct Object *tar;
  struct Object *child;
  int type;
  float pivX;
  float pivY;
  float pivZ;
  float axX;
  float axY;
  float axZ;
  float minLimit[6];
  float maxLimit[6];
  float extraFz;
  short flag;
  char _pad[6];
} bRigidBodyJointConstraint;
 
/* Clamp-To Constraint */
typedef struct bClampToConstraint {
  struct Object *tar;
  int flag;
  int flag2;
} bClampToConstraint;
 
/* Child Of Constraint */
typedef struct bChildOfConstraint {
  struct Object *tar;
  int flag;
  char _pad[4];
  float invmat[4][4];
  char subtarget[64];
} bChildOfConstraint;
 
/* Generic Transform->Transform Constraint */
typedef struct bTransformConstraint {
  struct Object *tar;
  char subtarget[64];
 
  short from, to;
  char map[3];
  char expo;
 
  char from_rotation_mode;
  char to_euler_order;
 
  char mix_mode_loc;
  char mix_mode_rot;
  char mix_mode_scale;
 
  char _pad[3];
 
  float from_min[3];
  float from_max[3];
  float to_min[3];
  float to_max[3];
 
  float from_min_rot[3];
  float from_max_rot[3];
  float to_min_rot[3];
  float to_max_rot[3];
 
  float from_min_scale[3];
  float from_max_scale[3];
  float to_min_scale[3];
  float to_max_scale[3];
} bTransformConstraint;
 
/* Pivot Constraint */
typedef struct bPivotConstraint {
  /* Pivot Point:
   * Either target object + offset, or just offset is used
   */
  struct Object *tar;
  char subtarget[64];
  float offset[3];
 
  /* Rotation-driven activation:
   * This option provides easier one-stop setups for foot-rolls.
   */
  short rotAxis;
 
  /* General flags */
  short flag;
} bPivotConstraint;
 
/* transform limiting constraints - zero target ---------------------------- */
/* Limit Location Constraint */
typedef struct bLocLimitConstraint {
  float xmin, xmax;
  float ymin, ymax;
  float zmin, zmax;
  short flag;
  short flag2;
} bLocLimitConstraint;
 
/* Limit Rotation Constraint */
typedef struct bRotLimitConstraint {
  float xmin, xmax;
  float ymin, ymax;
  float zmin, zmax;
  short flag;
  short flag2;
  char euler_order;
  char _pad[3];
} bRotLimitConstraint;
 
/* Limit Scale Constraint */
typedef struct bSizeLimitConstraint {
  float xmin, xmax;
  float ymin, ymax;
  float zmin, zmax;
  short flag;
  short flag2;
} bSizeLimitConstraint;
 
/* Limit Distance Constraint */
typedef struct bDistLimitConstraint {
  struct Object *tar;
  char subtarget[64];
 
  float dist;
  float soft;
 
  short flag;
  short mode;
  char _pad[4];
} bDistLimitConstraint;
 
/* ShrinkWrap Constraint */
typedef struct bShrinkwrapConstraint {
  struct Object *target;
  float dist;
  short shrinkType;
  char projAxis;
  char projAxisSpace;
  float projLimit;
  char shrinkMode;
  char flag;
  char trackAxis;
  char _pad;
} bShrinkwrapConstraint;
 
/* Follow Track constraints */
typedef struct bFollowTrackConstraint {
  struct MovieClip *clip;
  char track[64];
  int flag;
  int frame_method;
  char object[64];
  struct Object *camera;
  struct Object *depth_ob;
} bFollowTrackConstraint;
 
/* Camera Solver constraints */
typedef struct bCameraSolverConstraint {
  struct MovieClip *clip;
  int flag;
  char _pad[4];
} bCameraSolverConstraint;
 
/* Camera Solver constraints */
typedef struct bObjectSolverConstraint {
  struct MovieClip *clip;
  int flag;
  char _pad[4];
  char object[64];
  float invmat[4][4];
  struct Object *camera;
} bObjectSolverConstraint;
 
/* Transform matrix cache constraint */
typedef struct bTransformCacheConstraint {
  struct CacheFile *cache_file;
  char object_path[1024];
 
  /* Runtime. */
  struct CacheReader *reader;
  char reader_object_path[1024];
} bTransformCacheConstraint;
 
/* ------------------------------------------ */
 
/* bConstraint->type
 * - Do not ever change the order of these, or else files could get
 *   broken as their correct value cannot be resolved
 */
typedef enum eBConstraint_Types {
  CONSTRAINT_TYPE_NULL = 0,
  CONSTRAINT_TYPE_CHILDOF = 1,
  CONSTRAINT_TYPE_TRACKTO = 2,
  CONSTRAINT_TYPE_KINEMATIC = 3,
  CONSTRAINT_TYPE_FOLLOWPATH = 4,
  CONSTRAINT_TYPE_ROTLIMIT = 5,
  CONSTRAINT_TYPE_LOCLIMIT = 6,
  CONSTRAINT_TYPE_SIZELIMIT = 7,
  CONSTRAINT_TYPE_ROTLIKE = 8,
  CONSTRAINT_TYPE_LOCLIKE = 9,
  CONSTRAINT_TYPE_SIZELIKE = 10,
  CONSTRAINT_TYPE_PYTHON = 11,
  CONSTRAINT_TYPE_ACTION = 12,
  CONSTRAINT_TYPE_LOCKTRACK = 13,
  CONSTRAINT_TYPE_DISTLIMIT = 14,
  CONSTRAINT_TYPE_STRETCHTO = 15,
  CONSTRAINT_TYPE_MINMAX = 16,
  /* CONSTRAINT_TYPE_DEPRECATED = 17 */
  CONSTRAINT_TYPE_CLAMPTO = 18,
  CONSTRAINT_TYPE_TRANSFORM = 19,
  CONSTRAINT_TYPE_SHRINKWRAP = 20,
  CONSTRAINT_TYPE_DAMPTRACK = 21,
  CONSTRAINT_TYPE_SPLINEIK = 22,
  CONSTRAINT_TYPE_TRANSLIKE = 23,
  CONSTRAINT_TYPE_SAMEVOL = 24,
  CONSTRAINT_TYPE_PIVOT = 25,
  CONSTRAINT_TYPE_FOLLOWTRACK = 26,
  CONSTRAINT_TYPE_CAMERASOLVER = 27,
  CONSTRAINT_TYPE_OBJECTSOLVER = 28,
  CONSTRAINT_TYPE_TRANSFORM_CACHE = 29,
  CONSTRAINT_TYPE_ARMATURE = 30,
 
  /* This should be the last entry in this list. */
  NUM_CONSTRAINT_TYPES,
} eBConstraint_Types;
 
/* bConstraint->flag */
/* flags 0x2 (1 << 1) and 0x8 (1 << 3) were used in past */
/* flag 0x20 (1 << 5) was used to indicate that a constraint was evaluated
 *                    using a 'local' hack for pose-bones only. */
typedef enum eBConstraint_Flags {
#ifdef DNA_DEPRECATED_ALLOW
  /* Expansion for old box constraint layouts. Just for versioning. */
  CONSTRAINT_EXPAND_DEPRECATED = (1 << 0),
#endif
  /* Constraint is disabled because it is considered invalid. `is_valid` in RNA. */
  CONSTRAINT_DISABLE = (1 << 2),
  /* to indicate which Ipo should be shown, maybe for 3d access later too */
  CONSTRAINT_ACTIVE = (1 << 4),
  /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
  CONSTRAINT_SPACEONCE = (1 << 6),
  /* influence ipo is on constraint itself, not in action channel */
  CONSTRAINT_OWN_IPO = (1 << 7),
  /* Constraint is disabled by the user or the animation system (eye icon in the interface). */
  CONSTRAINT_OFF = (1 << 9),
  /* use bbone curve shape when calculating headtail values (also used by dependency graph!) */
  CONSTRAINT_BBONE_SHAPE = (1 << 10),
  /* That constraint has been inserted in local override (i.e. it can be fully edited!). */
  CONSTRAINT_OVERRIDE_LIBRARY_LOCAL = (1 << 11),
  /* use full transformation (not just segment locations) - only set at runtime. */
  CONSTRAINT_BBONE_SHAPE_FULL = (1 << 12),
} eBConstraint_Flags;
 
/* bConstraint->ownspace/tarspace */
typedef enum eBConstraint_SpaceTypes {
  CONSTRAINT_SPACE_WORLD = 0,
  CONSTRAINT_SPACE_CUSTOM = 5,
  CONSTRAINT_SPACE_LOCAL = 1,
  CONSTRAINT_SPACE_POSE = 2,
  CONSTRAINT_SPACE_PARLOCAL = 3,
  CONSTRAINT_SPACE_OWNLOCAL = 6,
  CONSTRAINT_SPACE_INVALID = 4, /* do not exchange for anything! */
} eBConstraint_SpaceTypes;
 
/* Common enum for constraints that support override. */
typedef enum eConstraint_EulerOrder {
  CONSTRAINT_EULER_AUTO = 0,
 
  CONSTRAINT_EULER_XYZ = 1,
  CONSTRAINT_EULER_XZY = 2,
  CONSTRAINT_EULER_YXZ = 3,
  CONSTRAINT_EULER_YZX = 4,
  CONSTRAINT_EULER_ZXY = 5,
  CONSTRAINT_EULER_ZYX = 6,
} eConstraint_EulerOrder;
 
/* -------------------------------------- */
 
typedef enum eCopyRotation_Flags {
  ROTLIKE_X = (1 << 0),
  ROTLIKE_Y = (1 << 1),
  ROTLIKE_Z = (1 << 2),
  ROTLIKE_X_INVERT = (1 << 4),
  ROTLIKE_Y_INVERT = (1 << 5),
  ROTLIKE_Z_INVERT = (1 << 6),
#ifdef DNA_DEPRECATED_ALLOW
  ROTLIKE_OFFSET = (1 << 7),
#endif
} eCopyRotation_Flags;
 
typedef enum eCopyRotation_MixMode {
  /* Replace rotation channel values. */
  ROTLIKE_MIX_REPLACE = 0,
  /* Legacy Offset mode - don't use. */
  ROTLIKE_MIX_OFFSET = 1,
  /* Add Euler components together. */
  ROTLIKE_MIX_ADD = 2,
  /* Multiply the copied rotation on the left. */
  ROTLIKE_MIX_BEFORE = 3,
  /* Multiply the copied rotation on the right. */
  ROTLIKE_MIX_AFTER = 4,
} eCopyRotation_MixMode;
 
typedef enum eCopyLocation_Flags {
  LOCLIKE_X = (1 << 0),
  LOCLIKE_Y = (1 << 1),
  LOCLIKE_Z = (1 << 2),
  LOCLIKE_TIP = (1 << 3),
  LOCLIKE_X_INVERT = (1 << 4),
  LOCLIKE_Y_INVERT = (1 << 5),
  LOCLIKE_Z_INVERT = (1 << 6),
  LOCLIKE_OFFSET = (1 << 7),
} eCopyLocation_Flags;
 
typedef enum eCopyScale_Flags {
  SIZELIKE_X = (1 << 0),
  SIZELIKE_Y = (1 << 1),
  SIZELIKE_Z = (1 << 2),
  SIZELIKE_OFFSET = (1 << 3),
  SIZELIKE_MULTIPLY = (1 << 4),
  SIZELIKE_UNIFORM = (1 << 5),
} eCopyScale_Flags;
 
typedef enum eCopyTransforms_Flags {
  /* Remove shear from the target matrix. */
  TRANSLIKE_REMOVE_TARGET_SHEAR = (1 << 0),
} eCopyTransforms_Flags;
 
typedef enum eCopyTransforms_MixMode {
  /* Replace rotation channel values. */
  TRANSLIKE_MIX_REPLACE = 0,
  /* Multiply the copied transformation on the left, with anti-shear scale handling. */
  TRANSLIKE_MIX_BEFORE = 1,
  /* Multiply the copied transformation on the right, with anti-shear scale handling. */
  TRANSLIKE_MIX_AFTER = 2,
  /* Multiply the copied transformation on the left, handling loc/rot/scale separately. */
  TRANSLIKE_MIX_BEFORE_SPLIT = 3,
  /* Multiply the copied transformation on the right, handling loc/rot/scale separately. */
  TRANSLIKE_MIX_AFTER_SPLIT = 4,
  /* Multiply the copied transformation on the left, using simple matrix multiplication. */
  TRANSLIKE_MIX_BEFORE_FULL = 5,
  /* Multiply the copied transformation on the right, using simple matrix multiplication. */
  TRANSLIKE_MIX_AFTER_FULL = 6,
} eCopyTransforms_MixMode;
 
/* bTransformConstraint.to/from */
typedef enum eTransform_ToFrom {
  TRANS_LOCATION = 0,
  TRANS_ROTATION = 1,
  TRANS_SCALE = 2,
} eTransform_ToFrom;
 
typedef enum eTransform_MixModeLoc {
  /* Add component values together (default). */
  TRANS_MIXLOC_ADD = 0,
  /* Replace component values. */
  TRANS_MIXLOC_REPLACE = 1,
} eTransform_MixModeLoc;
 
typedef enum eTransform_MixModeRot {
  /* Add component values together (default). */
  TRANS_MIXROT_ADD = 0,
  /* Replace component values. */
  TRANS_MIXROT_REPLACE = 1,
  /* Multiply the generated rotation on the left. */
  TRANS_MIXROT_BEFORE = 2,
  /* Multiply the generated rotation on the right. */
  TRANS_MIXROT_AFTER = 3,
} eTransform_MixModeRot;
 
typedef enum eTransform_MixModeScale {
  /* Replace component values (default). */
  TRANS_MIXSCALE_REPLACE = 0,
  /* Multiply component values together. */
  TRANS_MIXSCALE_MULTIPLY = 1,
} eTransform_MixModeScale;
 
typedef enum eSameVolume_Axis {
  SAMEVOL_X = 0,
  SAMEVOL_Y = 1,
  SAMEVOL_Z = 2,
} eSameVolume_Axis;
 
typedef enum eSameVolume_Mode {
  /* Strictly maintain the volume, overriding non-free axis scale. */
  SAMEVOL_STRICT = 0,
  /* Maintain the volume when scale is uniform, pass non-uniform other axis scale through. */
  SAMEVOL_UNIFORM = 1,
  /* Maintain the volume when scaled only on the free axis, pass other axis scale through. */
  SAMEVOL_SINGLE_AXIS = 2,
} eSameVolume_Mode;
 
typedef enum eActionConstraint_Flags {
  /* Bones use "object" part of target action, instead of "same bone name" part */
  ACTCON_BONE_USE_OBJECT_ACTION = (1 << 0),
  /* Ignore the transform of 'tar' and use 'eval_time' instead: */
  ACTCON_USE_EVAL_TIME = (1 << 1),
} eActionConstraint_Flags;
 
typedef enum eActionConstraint_MixMode {
  /* Multiply the action transformation on the right. */
  ACTCON_MIX_AFTER_FULL = 0,
  /* Multiply the action transformation on the left. */
  ACTCON_MIX_BEFORE_FULL = 3,
  /* Multiply the action transformation on the right, with anti-shear scale handling. */
  ACTCON_MIX_AFTER = 1,
  /* Multiply the action transformation on the left, with anti-shear scale handling. */
  ACTCON_MIX_BEFORE = 2,
  /* Separately combine Translation, Rotation and Scale, with rotation on the right. */
  ACTCON_MIX_AFTER_SPLIT = 4,
  /* Separately combine Translation, Rotation and Scale, with rotation on the left. */
  ACTCON_MIX_BEFORE_SPLIT = 5,
} eActionConstraint_MixMode;
 
/* Locked-Axis Values (Locked Track) */
typedef enum eLockAxis_Modes {
  LOCK_X = 0,
  LOCK_Y = 1,
  LOCK_Z = 2,
} eLockAxis_Modes;
 
/* Up-Axis Values (TrackTo and Locked Track) */
typedef enum eUpAxis_Modes {
  UP_X = 0,
  UP_Y = 1,
  UP_Z = 2,
} eUpAxis_Modes;
 
/* Tracking axis (TrackTo, Locked Track, Damped Track) and minmax (floor) constraint */
typedef enum eTrackToAxis_Modes {
  TRACK_X = 0,
  TRACK_Y = 1,
  TRACK_Z = 2,
  TRACK_nX = 3,
  TRACK_nY = 4,
  TRACK_nZ = 5,
} eTrackToAxis_Modes;
 
/* Shrinkwrap flags */
typedef enum eShrinkwrap_Flags {
  /* Also ray-cast in the opposite direction. */
  CON_SHRINKWRAP_PROJECT_OPPOSITE = (1 << 0),
  /* Invert the cull mode when projecting opposite. */
  CON_SHRINKWRAP_PROJECT_INVERT_CULL = (1 << 1),
  /* Align the specified axis to the target normal. */
  CON_SHRINKWRAP_TRACK_NORMAL = (1 << 2),
 
  /* Ignore front faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE */
  CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE = (1 << 3),
  /* Ignore back faces in project; same value as MOD_SHRINKWRAP_CULL_TARGET_BACKFACE */
  CON_SHRINKWRAP_PROJECT_CULL_BACKFACE = (1 << 4),
} eShrinkwrap_Flags;
 
#define CON_SHRINKWRAP_PROJECT_CULL_MASK \
  (CON_SHRINKWRAP_PROJECT_CULL_FRONTFACE | CON_SHRINKWRAP_PROJECT_CULL_BACKFACE)
 
/* FollowPath flags */
typedef enum eFollowPath_Flags {
  FOLLOWPATH_FOLLOW = (1 << 0),
  FOLLOWPATH_STATIC = (1 << 1),
  FOLLOWPATH_RADIUS = (1 << 2),
} eFollowPath_Flags;
 
/* bTrackToConstraint->flags */
typedef enum eTrackTo_Flags {
  TARGET_Z_UP = (1 << 0),
} eTrackTo_Flags;
 
/* Stretch To Constraint -> volmode */
typedef enum eStretchTo_VolMode {
  VOLUME_XZ = 0,
  VOLUME_X = 1,
  VOLUME_Z = 2,
  NO_VOLUME = 3,
} eStretchTo_VolMode;
 
/* Stretch To Constraint -> plane mode */
typedef enum eStretchTo_PlaneMode {
  PLANE_X = 0,
  SWING_Y = 1,
  PLANE_Z = 2,
} eStretchTo_PlaneMode;
 
/* Clamp-To Constraint ->flag */
typedef enum eClampTo_Modes {
  CLAMPTO_AUTO = 0,
  CLAMPTO_X = 1,
  CLAMPTO_Y = 2,
  CLAMPTO_Z = 3,
} eClampTo_Modes;
 
/* ClampTo Constraint ->flag2 */
typedef enum eClampTo_Flags {
  CLAMPTO_CYCLIC = (1 << 0),
} eClampTo_Flags;
 
/* bKinematicConstraint->flag */
typedef enum eKinematic_Flags {
  CONSTRAINT_IK_TIP = (1 << 0),
  CONSTRAINT_IK_ROT = (1 << 1),
  /* targetless */
  CONSTRAINT_IK_AUTO = (1 << 2),
  /* autoik */
  CONSTRAINT_IK_TEMP = (1 << 3),
  CONSTRAINT_IK_STRETCH = (1 << 4),
  CONSTRAINT_IK_POS = (1 << 5),
  CONSTRAINT_IK_SETANGLE = (1 << 6),
  CONSTRAINT_IK_GETANGLE = (1 << 7),
  /* limit axis */
  CONSTRAINT_IK_NO_POS_X = (1 << 8),
  CONSTRAINT_IK_NO_POS_Y = (1 << 9),
  CONSTRAINT_IK_NO_POS_Z = (1 << 10),
  CONSTRAINT_IK_NO_ROT_X = (1 << 11),
  CONSTRAINT_IK_NO_ROT_Y = (1 << 12),
  CONSTRAINT_IK_NO_ROT_Z = (1 << 13),
  /* axis relative to target */
  CONSTRAINT_IK_TARGETAXIS = (1 << 14),
} eKinematic_Flags;
 
typedef enum eSplineIK_Flags {
  CONSTRAINT_SPLINEIK_BOUND = (1 << 0),
  CONSTRAINT_SPLINEIK_NO_ROOT = (1 << 1),
#ifdef DNA_DEPRECATED_ALLOW
  CONSTRAINT_SPLINEIK_SCALE_LIMITED = (1 << 2),
#endif
  CONSTRAINT_SPLINEIK_EVENSPLITS = (1 << 3),
  CONSTRAINT_SPLINEIK_NO_CURVERAD = (1 << 4),
 
  CONSTRAINT_SPLINEIK_USE_BULGE_MIN = (1 << 5),
  CONSTRAINT_SPLINEIK_USE_BULGE_MAX = (1 << 6),
 
  CONSTRAINT_SPLINEIK_USE_ORIGINAL_SCALE = (1 << 7),
} eSplineIK_Flags;
 
typedef enum eSplineIK_XZScaleModes {
  CONSTRAINT_SPLINEIK_XZS_NONE = 0,
  CONSTRAINT_SPLINEIK_XZS_ORIGINAL = 1,
  CONSTRAINT_SPLINEIK_XZS_INVERSE = 2,
  CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC = 3,
} eSplineIK_XZScaleModes;
 
typedef enum eSplineIK_YScaleModes {
  CONSTRAINT_SPLINEIK_YS_NONE = 0,
  CONSTRAINT_SPLINEIK_YS_FIT_CURVE = 1,
  CONSTRAINT_SPLINEIK_YS_ORIGINAL = 2,
} eSplineIK_YScaleModes;
 
typedef enum eArmature_Flags {
  CONSTRAINT_ARMATURE_QUATERNION = (1 << 0),
  CONSTRAINT_ARMATURE_ENVELOPE = (1 << 1),
  CONSTRAINT_ARMATURE_CUR_LOCATION = (1 << 2),
} eArmature_Flags;
 
/* MinMax (floor) flags */
typedef enum eFloor_Flags {
  /* MINMAX_STICKY = (1 << 0), */ /* Deprecated. */
  /* MINMAX_STUCK = (1 << 1), */  /* Deprecated. */
  MINMAX_USEROT = (1 << 2),
} eFloor_Flags;
 
/* transform limiting constraints -> flag2 */
typedef enum eTransformLimits_Flags2 {
  /* not used anymore - for older Limit Location constraints only */
  /* LIMIT_NOPARENT = (1 << 0), */ /* UNUSED */
  /* for all Limit constraints - allow to be used during transform? */
  LIMIT_TRANSFORM = (1 << 1),
} eTransformLimits_Flags2;
 
/* transform limiting constraints -> flag. */
typedef enum eTransformLimits_Flags {
  LIMIT_XMIN = (1 << 0),
  LIMIT_XMAX = (1 << 1),
  LIMIT_YMIN = (1 << 2),
  LIMIT_YMAX = (1 << 3),
  LIMIT_ZMIN = (1 << 4),
  LIMIT_ZMAX = (1 << 5),
} eTransformLimits_Flags;
 
/* limit rotation constraint -> flag. */
typedef enum eRotLimit_Flags {
  LIMIT_XROT = (1 << 0),
  LIMIT_YROT = (1 << 1),
  LIMIT_ZROT = (1 << 2),
 
  /* Use the legacy behavior of the Limit Rotation constraint. See the
   * implementation of `rotlimit_evaluate()` in constraint.cc for more
   * details. */
  LIMIT_ROT_LEGACY_BEHAVIOR = (1 << 3),
} eRotLimit_Flags;
 
/* distance limit constraint */
/* bDistLimitConstraint->flag */
typedef enum eDistLimit_Flag {
  /* "soft" cushion effect when reaching the limit sphere */ /* NOT IMPLEMENTED! */
  LIMITDIST_USESOFT = (1 << 0),
  /* as for all Limit constraints - allow to be used during transform? */
  LIMITDIST_TRANSFORM = (1 << 1),
} eDistLimit_Flag;
 
/* bDistLimitConstraint->mode */
typedef enum eDistLimit_Modes {
  LIMITDIST_INSIDE = 0,
  LIMITDIST_OUTSIDE = 1,
  LIMITDIST_ONSURFACE = 2,
} eDistLimit_Modes;
 
/* python constraint -> flag */
typedef enum ePyConstraint_Flags {
  PYCON_USETARGETS = (1 << 0),
  PYCON_SCRIPTERROR = (1 << 1),
} ePyConstraint_Flags;
 
/* ChildOf Constraint -> flag */
typedef enum eChildOf_Flags {
  CHILDOF_LOCX = (1 << 0),
  CHILDOF_LOCY = (1 << 1),
  CHILDOF_LOCZ = (1 << 2),
  CHILDOF_ROTX = (1 << 3),
  CHILDOF_ROTY = (1 << 4),
  CHILDOF_ROTZ = (1 << 5),
  CHILDOF_SIZEX = (1 << 6),
  CHILDOF_SIZEY = (1 << 7),
  CHILDOF_SIZEZ = (1 << 8),
  CHILDOF_ALL = 511,
  /* Temporary flag used by the Set Inverse operator. */
  CHILDOF_SET_INVERSE = (1 << 9),
} eChildOf_Flags;
 
typedef enum ePivotConstraint_Axis {
  PIVOTCON_AXIS_NONE = -1,
 
  PIVOTCON_AXIS_X_NEG = 0,
  PIVOTCON_AXIS_Y_NEG = 1,
  PIVOTCON_AXIS_Z_NEG = 2,
 
  PIVOTCON_AXIS_X = 3,
  PIVOTCON_AXIS_Y = 4,
  PIVOTCON_AXIS_Z = 5,
} ePivotConstraint_Axis;
 
/* settings for Pivot Constraint in general */
typedef enum ePivotConstraint_Flag {
  /* offset is to be interpreted as being a fixed-point in space */
  PIVOTCON_FLAG_OFFSET_ABS = (1 << 0),
  /* rotation-based activation uses negative rotation to drive result */
  PIVOTCON_FLAG_ROTACT_NEG = (1 << 1),
} ePivotConstraint_Flag;
 
typedef enum eFollowTrack_Flags {
  FOLLOWTRACK_ACTIVECLIP = (1 << 0),
  FOLLOWTRACK_USE_3D_POSITION = (1 << 1),
  FOLLOWTRACK_USE_UNDISTORTION = (1 << 2),
} eFollowTrack_Flags;
 
typedef enum eFollowTrack_FrameMethod {
  FOLLOWTRACK_FRAME_STRETCH = 0,
  FOLLOWTRACK_FRAME_FIT = 1,
  FOLLOWTRACK_FRAME_CROP = 2,
} eFollowTrack_FrameMethod;
 
/* CameraSolver Constraint -> flag */
typedef enum eCameraSolver_Flags {
  CAMERASOLVER_ACTIVECLIP = (1 << 0),
} eCameraSolver_Flags;
 
/* ObjectSolver Constraint -> flag */
typedef enum eObjectSolver_Flags {
  OBJECTSOLVER_ACTIVECLIP = (1 << 0),
  /* Temporary flag used by the Set Inverse operator. */
  OBJECTSOLVER_SET_INVERSE = (1 << 1),
} eObjectSolver_Flags;
 
/* ObjectSolver Constraint -> flag */
typedef enum eStretchTo_Flags {
  STRETCHTOCON_USE_BULGE_MIN = (1 << 0),
  STRETCHTOCON_USE_BULGE_MAX = (1 << 1),
} eStretchTo_Flags;