source/blender/makesdna/DNA_constraint_types.h

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): 2007, Joshua Leung, major recode
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  * Constraint DNA data
  29  */
  30
  31 #ifndef DNA_CONSTRAINT_TYPES_H
  32 #define DNA_CONSTRAINT_TYPES_H
  33
  34 #include "DNA_ID.h"
  35 #include "DNA_listBase.h"
  36
  37 struct Action;
  38 struct Text;
  39 struct Ipo;
  40
  41 /* channels reside in Object or Action (ListBase) constraintChannels */
  42 // XXX depreceated... old AnimSys
  43 typedef struct bConstraintChannel {
  44         struct bConstraintChannel *next, *prev;
  45         struct Ipo                      *ipo;
  46         short           flag;
  47         char            name[30];
  48 } bConstraintChannel;
  49
  50 /* A Constraint */
  51 typedef struct bConstraint {
  52         struct bConstraint *next, *prev;
  53
  54         void            *data;          /*      Constraint data (a valid constraint type) */
  55         short           type;           /*      Constraint type */
  56         short           flag;           /*      Flag - General Settings */
  57
  58         char            ownspace;       /*      Space that owner should be evaluated in         */
  59         char            tarspace;       /*      Space that target should be evaluated in (only used if 1 target) */
  60
  61         char            name[30];       /*      Constraint name */
  62
  63         float           enforce;        /*      Amount of influence exherted by constraint (0.0-1.0) */
  64         float           headtail;       /*      Point along subtarget bone where the actual target is. 0=head (default for all), 1=tail*/
  65         int                     pad;
  66
  67         struct Ipo *ipo;                /* local influence ipo or driver */ // XXX depreceated for 2.5... old animation system hack
  68
  69         /* below are readonly fields that are set at runtime by the solver for use in the GE (only IK atm) */
  70         float       lin_error;          /* residual error on constraint expressed in blender unit*/
  71         float       rot_error;          /* residual error on constraint expressed in radiant */
  72 } bConstraint;
  73
  74
  75 /* Multiple-target constraints ---------------------  */
  76
  77 /* This struct defines a constraint target.
  78  * It is used during constraint solving regardless of how many targets the
  79  * constraint has.
  80  */
  81 typedef struct bConstraintTarget {
  82         struct bConstraintTarget *next, *prev;
  83
  84         struct Object *tar;                     /* object to use as target */
  85         char subtarget[32];             /* subtarget - pchan or vgroup name */
  86
  87         float matrix[4][4];             /* matrix used during constraint solving - should be cleared before each use */
  88
  89         short space;                    /* space that target should be evaluated in (overrides bConstraint->tarspace) */
  90         short flag;                             /* runtime settings (for editor, etc.) */
  91         short type;                             /* type of target (B_CONSTRAINT_OB_TYPE) */
  92         short rotOrder;                 /* rotation order for target (as defined in BLI_math.h) */
  93 } bConstraintTarget;
  94
  95 /* bConstraintTarget -> flag */
  96 typedef enum B_CONSTRAINT_TARGET_FLAG {
  97         CONSTRAINT_TAR_TEMP = (1<<0),           /* temporary target-struct that needs to be freed after use */
  98 } B_CONSTRAINT_TARGET_FLAG;
  99
 100 /* bConstraintTarget/bConstraintOb -> type */
 101 typedef enum B_CONSTRAINT_OB_TYPE {
 102         CONSTRAINT_OBTYPE_OBJECT = 1,   /*      string is ""                            */
 103         CONSTRAINT_OBTYPE_BONE,                 /*      string is bone-name             */
 104         CONSTRAINT_OBTYPE_VERT,                 /*      string is vertex-group name     */
 105         CONSTRAINT_OBTYPE_CV                    /*      string is vertex-group name - is not available until curves get vgroups */
 106 } B_CONSTRAINT_OB_TYPE;
 107
 108
 109
 110 /* Python Script Constraint */
 111 typedef struct bPythonConstraint {
 112         struct Text *text;              /* text-buffer (containing script) to execute */
 113         IDProperty *prop;               /* 'id-properties' used to store custom properties for constraint */
 114
 115         int flag;                               /* general settings/state indicators accessed by bitmapping */
 116         int tarnum;                             /* number of targets - usually only 1-3 are needed */
 117
 118         ListBase targets;               /* a list of targets that this constraint has (bConstraintTarget-s) */
 119
 120         struct Object *tar;             /* target from previous implementation (version-patch sets this to NULL on file-load) */
 121         char subtarget[32];             /* subtarger from previous implentation (version-patch sets this to "" on file-load) */
 122 } bPythonConstraint;
 123
 124
 125 /* Inverse-Kinematics (IK) constraint
 126    This constraint supports a variety of mode determine by the type field
 127    according to B_CONSTRAINT_IK_TYPE.
 128    Some fields are used by all types, some are specific to some types
 129    This is indicated in the comments for each field
 130  */
 131 typedef struct bKinematicConstraint {
 132         struct Object           *tar;                   /* All: target object in case constraint needs a target */
 133         short           iterations;             /* All: Maximum number of iterations to try */
 134         short           flag;                   /* All & CopyPose: some options Like CONSTRAINT_IK_TIP */
 135         short           rootbone;               /* All: index to rootbone, if zero go all the way to mother bone */
 136         short           max_rootbone;   /* CopyPose: for auto-ik, maximum length of chain */
 137         char            subtarget[32];  /* All: String to specify sub-object target */
 138         struct Object           *poletar;                       /* All: Pole vector target */
 139         char            polesubtarget[32];      /* All: Pole vector sub-object target */
 140         float           poleangle;                      /* All: Pole vector rest angle */
 141         float           weight;                 /* All: Weight of constraint in IK tree */
 142         float           orientweight;   /* CopyPose: Amount of rotation a target applies on chain */
 143         float           grabtarget[3];  /* CopyPose: for target-less IK */
 144         short           type;                   /* subtype of IK constraint: B_CONSTRAINT_IK_TYPE */
 145         short           mode;                   /* Distance: how to limit in relation to clamping sphere: LIMITDIST_.. */
 146         float           dist;                   /* Distance: distance (radius of clamping sphere) from target */
 147 } bKinematicConstraint;
 148
 149 typedef enum B_CONSTRAINT_IK_TYPE {
 150         CONSTRAINT_IK_COPYPOSE = 0,             /* 'standard' IK constraint: match position and/or orientation of target */
 151         CONSTRAINT_IK_DISTANCE                  /* maintain distance with target */
 152 } B_CONSTRAINT_IK_TYPE;
 153
 154
 155 /* Spline IK Constraint
 156  * Aligns 'n' bones to the curvature defined by the curve,
 157  * with the chain ending on the bone that owns this constraint,
 158  * and starting on the nth parent.
 159  */
 160 typedef struct bSplineIKConstraint {
 161                 /* target(s) */
 162         struct Object *tar;             /* curve object (with follow path enabled) which drives the bone chain */
 163
 164                 /* binding details */
 165         float           *points;        /* array of numpoints items, denoting parametric positions along curve that joints should follow */
 166         short           numpoints;      /* number of points to bound in points array */
 167         short           chainlen;       /* number of bones ('n') that are in the chain */
 168
 169                 /* settings */
 170         short flag;                             /* general settings for constraint */
 171         short xzScaleMode;              /* method used for determining the x & z scaling of the bones */
 172 } bSplineIKConstraint;
 173
 174
 175 /* Single-target subobject constraints ---------------------  */
 176
 177 /* Track To Constraint */
 178 typedef struct bTrackToConstraint {
 179         struct Object           *tar;
 180         int                     reserved1; /* I'll be using reserved1 and reserved2 as Track and Up flags, not sure if that's what they were intented for anyway. Not sure either if it would create backward incompatibility if I were to rename them. - theeth*/
 181         int                     reserved2;
 182         int                     flags;
 183         int                     pad;
 184         char            subtarget[32];
 185 } bTrackToConstraint;
 186
 187 /* Copy Rotation Constraint */
 188 typedef struct bRotateLikeConstraint {
 189         struct Object           *tar;
 190         int                     flag;
 191         int                     reserved1;
 192         char            subtarget[32];
 193 } bRotateLikeConstraint;
 194
 195 /* Copy Location Constraint */
 196 typedef struct bLocateLikeConstraint {
 197         struct Object           *tar;
 198         int                     flag;
 199         int                     reserved1;
 200         char            subtarget[32];
 201 } bLocateLikeConstraint;
 202
 203 /* Copy Scale Constraint */
 204 typedef struct bSizeLikeConstraint {
 205         struct Object           *tar;
 206         int                     flag;
 207         int                     reserved1;
 208         char            subtarget[32];
 209 } bSizeLikeConstraint;
 210
 211 /* Maintain Volume Constraint */
 212 typedef struct bSameVolumeConstraint {
 213         int                     flag;
 214         float           volume;
 215 } bSameVolumeConstraint;
 216
 217 /* Copy Transform Constraint */
 218 typedef struct bTransLikeConstraint {
 219         struct Object *tar;
 220         char            subtarget[32];
 221 } bTransLikeConstraint;
 222
 223 /* Floor Constraint */
 224 typedef struct bMinMaxConstraint {
 225         struct Object *tar;
 226         int                     minmaxflag;
 227         float           offset;
 228         int                     flag;
 229         short           sticky, stuck, pad1, pad2; /* for backward compatability */
 230         float           cache[3];
 231         char            subtarget[32];
 232 } bMinMaxConstraint;
 233
 234 /* Action Constraint */
 235 typedef struct bActionConstraint {
 236         struct Object           *tar;
 237         short           type;   /* what transform 'channel' drives the result */
 238         short           local;  /* was used in versions prior to the Constraints recode */
 239         int                     start;
 240         int                     end;
 241         float           min;
 242         float           max;
 243         int         pad;
 244         struct bAction  *act;
 245         char            subtarget[32];
 246 } bActionConstraint;
 247
 248 /* Locked Axis Tracking constraint */
 249 typedef struct bLockTrackConstraint {
 250         struct Object           *tar;
 251         int                     trackflag;
 252         int                     lockflag;
 253         char            subtarget[32];
 254 } bLockTrackConstraint;
 255
 256 /* Damped Tracking constraint */
 257 typedef struct bDampTrackConstraint {
 258         struct Object           *tar;
 259         int                     trackflag;
 260         int                     pad;
 261         char            subtarget[32];
 262 } bDampTrackConstraint;
 263
 264 /* Follow Path constraints */
 265 typedef struct bFollowPathConstraint {
 266         struct Object           *tar;           /* Must be path object */
 267
 268         float           offset;                 /* Offset in time on the path (in frames), when NOT using 'fixed position' */
 269         float           offset_fac;             /* Parametric offset factor defining position along path, when using 'fixed position' */
 270
 271         int                     followflag;
 272
 273         short           trackflag;
 274         short           upflag;
 275 } bFollowPathConstraint;
 276
 277 /* Stretch to constraint */
 278 typedef struct bStretchToConstraint {
 279         struct Object           *tar;
 280         int                     volmode;
 281         int         plane;
 282         float           orglength;
 283         float           bulge;
 284         char            subtarget[32];
 285 } bStretchToConstraint;
 286
 287 /* Rigid Body constraint */
 288 typedef struct bRigidBodyJointConstraint {
 289         struct Object           *tar;
 290         struct Object           *child;
 291         int         type;
 292         float       pivX;
 293         float       pivY;
 294         float       pivZ;
 295         float       axX;
 296         float       axY;
 297         float       axZ;
 298         float       minLimit[6];
 299         float       maxLimit[6];
 300         float       extraFz;
 301         short           flag;
 302         short           pad;
 303         short           pad1;
 304         short           pad2;
 305 } bRigidBodyJointConstraint;
 306
 307 /* Clamp-To Constraint */
 308 typedef struct bClampToConstraint {
 309         struct Object           *tar;                   /* 'target' must be a curve */
 310         int                     flag;                   /* which axis/plane to compare owner's location on  */
 311         int                     flag2;                  /* for legacy reasons, this is flag2. used for any extra settings */
 312 } bClampToConstraint;
 313
 314 /* Child Of Constraint */
 315 typedef struct bChildOfConstraint {
 316         struct Object           *tar;                   /* object which will act as parent (or target comes from) */
 317         int             flag;                   /* settings */
 318         int                     pad;
 319         float           invmat[4][4];   /* parent-inverse matrix to use */
 320         char            subtarget[32];  /* string to specify a subobject target */
 321 } bChildOfConstraint;
 322
 323 /* Generic Transform->Transform Constraint */
 324 typedef struct bTransformConstraint {
 325         struct Object           *tar;                   /* target (i.e. 'driver' object/bone) */
 326         char            subtarget[32];
 327
 328         short           from, to;               /* can be loc(0) , rot(1),  or size(2) */
 329         char            map[3];                 /* defines which target-axis deform is copied by each owner-axis */
 330         char            expo;                   /* extrapolate motion? if 0, confine to ranges */
 331
 332         float           from_min[3];    /* from_min/max defines range of target transform       */
 333         float           from_max[3];    /*      to map on to to_min/max range.                  */
 334
 335         float           to_min[3];              /* range of motion on owner caused by target  */
 336         float           to_max[3];
 337 } bTransformConstraint;
 338
 339 /* Pivot Constraint */
 340 typedef struct bPivotConstraint {
 341         /* Pivot Point:
 342          *      Either target object + offset, or just offset is used
 343          */
 344         struct Object           *tar;                   /* target object (optional) */
 345         char            subtarget[32];          /* subtarget name (optional) */
 346         float           offset[3];              /* offset from the target to use, regardless of whether it exists */
 347
 348         /* Rotation-driven activation:
 349          *      This option provides easier one-stop setups for footrolls
 350          */
 351         short           rotAxis;                /* rotation axes to consider for this (ePivotConstraint_Axis) */
 352
 353         /* General flags */
 354         short           flag;                   /* ePivotConstraint_Flag */
 355 } bPivotConstraint;
 356
 357 /* transform limiting constraints - zero target ----------------------------  */
 358 /* Limit Location Constraint */
 359 typedef struct bLocLimitConstraint {
 360         float           xmin, xmax;
 361         float           ymin, ymax;
 362         float           zmin, zmax;
 363         short           flag;
 364         short           flag2;
 365 } bLocLimitConstraint;
 366
 367 /* Limit Rotation Constraint */
 368 typedef struct bRotLimitConstraint {
 369         float           xmin, xmax;
 370         float           ymin, ymax;
 371         float           zmin, zmax;
 372         short           flag;
 373         short           flag2;
 374 } bRotLimitConstraint;
 375
 376 /* Limit Scaling Constraint */
 377 typedef struct bSizeLimitConstraint {
 378         float           xmin, xmax;
 379         float           ymin, ymax;
 380         float           zmin, zmax;
 381         short           flag;
 382         short           flag2;
 383 } bSizeLimitConstraint;
 384
 385 /* Limit Distance Constraint */
 386 typedef struct bDistLimitConstraint {
 387         struct Object           *tar;
 388         char            subtarget[32];
 389
 390         float           dist;                   /* distance (radius of clamping sphere) from target */
 391         float           soft;                   /* distance from clamping-sphere to start applying 'fade' */
 392
 393         short           flag;                   /* settings */
 394         short           mode;                   /* how to limit in relation to clamping sphere */
 395         int             pad;
 396 } bDistLimitConstraint;
 397
 398 /* ShrinkWrap Constraint */
 399 typedef struct bShrinkwrapConstraint {
 400         struct Object           *target;
 401         float           dist;                   /* distance to kept from target */
 402         short           shrinkType;             /* shrink type (look on MOD shrinkwrap for values) */
 403         char            projAxis;               /* axis to project over UP_X, UP_Y, UP_Z */
 404         char            pad[9];
 405 } bShrinkwrapConstraint;
 406
 407
 408 /* ------------------------------------------ */
 409
 410 /* bConstraint->type
 411  *      - Do not ever change the order of these, or else files could get
 412  *        broken as their correct value cannot be resolved
 413  */
 414 typedef enum eBConstraint_Types {
 415         CONSTRAINT_TYPE_NULL = 0,                       /* Invalid/legacy constraint */
 416         CONSTRAINT_TYPE_CHILDOF,                        /* Unimplemented non longer :) - during constraints recode, Aligorith */
 417         CONSTRAINT_TYPE_TRACKTO,
 418         CONSTRAINT_TYPE_KINEMATIC,
 419         CONSTRAINT_TYPE_FOLLOWPATH,
 420         CONSTRAINT_TYPE_ROTLIMIT,                       /* Unimplemented no longer :) - Aligorith */
 421         CONSTRAINT_TYPE_LOCLIMIT,                       /* Unimplemented no longer :) - Aligorith */
 422         CONSTRAINT_TYPE_SIZELIMIT,                      /* Unimplemented no longer :) - Aligorith */
 423         CONSTRAINT_TYPE_ROTLIKE,
 424         CONSTRAINT_TYPE_LOCLIKE,
 425         CONSTRAINT_TYPE_SIZELIKE,
 426         CONSTRAINT_TYPE_PYTHON,                         /* Unimplemented no longer :) - Aligorith. Scripts */
 427         CONSTRAINT_TYPE_ACTION,
 428         CONSTRAINT_TYPE_LOCKTRACK,                      /* New Tracking constraint that locks an axis in place - theeth */
 429         CONSTRAINT_TYPE_DISTLIMIT,                      /* limit distance */
 430         CONSTRAINT_TYPE_STRETCHTO,                      /* claiming this to be mine :) is in tuhopuu bjornmose */
 431         CONSTRAINT_TYPE_MINMAX,                         /* floor constraint */
 432         CONSTRAINT_TYPE_RIGIDBODYJOINT,         /* rigidbody constraint */
 433         CONSTRAINT_TYPE_CLAMPTO,                        /* clampto constraint */
 434         CONSTRAINT_TYPE_TRANSFORM,                      /* transformation (loc/rot/size -> loc/rot/size) constraint */
 435         CONSTRAINT_TYPE_SHRINKWRAP,                     /* shrinkwrap (loc/rot) constraint */
 436         CONSTRAINT_TYPE_DAMPTRACK,                      /* New Tracking constraint that minimises twisting */
 437         CONSTRAINT_TYPE_SPLINEIK,                       /* Spline-IK - Align 'n' bones to a curve */
 438         CONSTRAINT_TYPE_TRANSLIKE,                      /* Copy transform matrix */
 439         CONSTRAINT_TYPE_SAMEVOL,                        /* Maintain volume during scaling */
 440         CONSTRAINT_TYPE_PIVOT,                          /* Pivot Constraint */
 441
 442         /* NOTE: no constraints are allowed to be added after this */
 443         NUM_CONSTRAINT_TYPES
 444 } eBConstraint_Types;
 445
 446 /* bConstraint->flag */
 447 /* flags 0x2 (1<<1) and 0x8 (1<<3) were used in past */
 448 /* flag 0x20 (1<<5) was used to indicate that a constraint was evaluated using a 'local' hack for posebones only  */
 449 typedef enum eBConstraint_Flags {
 450                 /* expand for UI */
 451         CONSTRAINT_EXPAND =             (1<<0),
 452                 /* pre-check for illegal object name or bone name */
 453         CONSTRAINT_DISABLE =    (1<<2),
 454                 /* to indicate which Ipo should be shown, maybe for 3d access later too */
 455         CONSTRAINT_ACTIVE =     (1<<4),
 456                 /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
 457         CONSTRAINT_SPACEONCE =  (1<<6),
 458                 /* influence ipo is on constraint itself, not in action channel */
 459         CONSTRAINT_OWN_IPO      = (1<<7),
 460                 /* indicates that constraint was added locally (i.e.  didn't come from the proxy-lib) */
 461         CONSTRAINT_PROXY_LOCAL = (1<<8),
 462                 /* indicates that constraint is temporarily disabled (only used in GE) */
 463         CONSTRAINT_OFF = (1<<9)
 464 } eBConstraint_Flags;
 465
 466 /* bConstraint->ownspace/tarspace */
 467 typedef enum eBConstraint_SpaceTypes {
 468                 /* default for all - worldspace */
 469         CONSTRAINT_SPACE_WORLD = 0,
 470                 /* for objects (relative to parent/without parent influence),
 471                  * for bones (along normals of bone, without parent/restpositions)
 472                  */
 473         CONSTRAINT_SPACE_LOCAL, /* = 1 */
 474                 /* for posechannels - pose space  */
 475         CONSTRAINT_SPACE_POSE, /* = 2 */
 476                  /* for posechannels - local with parent  */
 477         CONSTRAINT_SPACE_PARLOCAL, /* = 3 */
 478                 /* for files from between 2.43-2.46 (should have been parlocal) */
 479         CONSTRAINT_SPACE_INVALID, /* = 4. do not exchange for anything! */
 480 } eBConstraint_SpaceTypes;
 481
 482 /* bConstraintChannel.flag */
 483 // XXX depreceated... old AnimSys
 484 typedef enum eConstraintChannel_Flags {
 485         CONSTRAINT_CHANNEL_SELECT =             (1<<0),
 486         CONSTRAINT_CHANNEL_PROTECTED =  (1<<1)
 487 } eConstraintChannel_Flags;
 488
 489 /* -------------------------------------- */
 490
 491 /* bRotateLikeConstraint.flag */
 492 typedef enum eCopyRotation_Flags {
 493         ROTLIKE_X                       = (1<<0),
 494         ROTLIKE_Y                       = (1<<1),
 495         ROTLIKE_Z                       = (1<<2),
 496         ROTLIKE_X_INVERT        = (1<<4),
 497         ROTLIKE_Y_INVERT        = (1<<5),
 498         ROTLIKE_Z_INVERT        = (1<<6),
 499         ROTLIKE_OFFSET          = (1<<7),
 500 } eCopyRotation_Flags;
 501
 502 /* bLocateLikeConstraint.flag */
 503 typedef enum eCopyLocation_Flags {
 504         LOCLIKE_X                       = (1<<0),
 505         LOCLIKE_Y                       = (1<<1),
 506         LOCLIKE_Z                       = (1<<2),
 507                 /* LOCLIKE_TIP is a depreceated option... use headtail=1.0f instead */
 508         LOCLIKE_TIP                     = (1<<3),
 509         LOCLIKE_X_INVERT        = (1<<4),
 510         LOCLIKE_Y_INVERT        = (1<<5),
 511         LOCLIKE_Z_INVERT        = (1<<6),
 512         LOCLIKE_OFFSET          = (1<<7),
 513 } eCopyLocation_Flags;
 514
 515 /* bSizeLikeConstraint.flag */
 516 typedef enum eCopyScale_Flags {
 517         SIZELIKE_X              = (1<<0),
 518         SIZELIKE_Y              = (1<<1),
 519         SIZELIKE_Z              = (1<<2),
 520         SIZELIKE_OFFSET = (1<<3),
 521 } eCopyScale_Flags;
 522
 523 /* bSameVolumeConstraint.flag */
 524 typedef enum eSameVolume_Modes {
 525         SAMEVOL_X               = 0,
 526         SAMEVOL_Y,
 527         SAMEVOL_Z,
 528 } eSameVolume_Modes;
 529
 530 /* Locked-Axis Values (Locked Track) */
 531 typedef enum eLockAxis_Modes {
 532         LOCK_X  = 0,
 533         LOCK_Y,
 534         LOCK_Z,
 535 } eLockAxis_Modes;
 536
 537 /* Up-Axis Values (TrackTo and Locked Track) */
 538 typedef enum eUpAxis_Modes {
 539         UP_X    = 0,
 540         UP_Y,
 541         UP_Z,
 542 } eUpAxis_Modes;
 543
 544 /* Tracking axis (TrackTo, Locked Track, Damped Track) */
 545 typedef enum eTrackToAxis_Modes {
 546         TRACK_X         = 0,
 547         TRACK_Y,
 548         TRACK_Z,
 549         TRACK_nX,
 550         TRACK_nY,
 551         TRACK_nZ,
 552 } eTrackToAxis_Modes;
 553
 554 /* FollowPath flags */
 555 typedef enum eFollowPath_Flags {
 556         FOLLOWPATH_FOLLOW       = (1<<0),
 557         FOLLOWPATH_STATIC       = (1<<1),
 558         FOLLOWPATH_RADIUS       = (1<<2),
 559 } eFollowPath_Flags;
 560
 561 /* bTrackToConstraint->flags */
 562 typedef enum eTrackTo_Flags {
 563         TARGET_Z_UP     = (1<<0),
 564 } eTrackTo_Flags;
 565
 566 /* Strech To Constraint -> volmode */
 567 typedef enum eStretchTo_VolMode {
 568         VOLUME_XZ       = 0,
 569         VOLUME_X,
 570         VOLUME_Z,
 571         NO_VOLUME,
 572 } eStretchTo_VolMode;
 573
 574 /* Stretch To Constraint -> plane mode */
 575 typedef enum eStretchTo_PlaneMode {
 576         PLANE_X         = 0,
 577         PLANE_Y,
 578         PLANE_Z,
 579 } eStretchTo_PlaneMode;
 580
 581 /* Clamp-To Constraint ->flag */
 582 typedef enum eClampTo_Modes {
 583         CLAMPTO_AUTO = 0,
 584         CLAMPTO_X,
 585         CLAMPTO_Y,
 586         CLAMPTO_Z,
 587 } eClampTo_Modes;
 588
 589 /* ClampTo Constraint ->flag2 */
 590 typedef enum eClampTo_Flags {
 591         CLAMPTO_CYCLIC  = (1<<0),
 592 } eClampTo_Flags;
 593
 594 /* bKinematicConstraint->flag */
 595 typedef enum eKinematic_Flags {
 596         CONSTRAINT_IK_TIP                       = (1<<0),
 597         CONSTRAINT_IK_ROT                       = (1<<1),
 598         /* targetless */
 599         CONSTRAINT_IK_AUTO                      = (1<<2),
 600         /* autoik */
 601         CONSTRAINT_IK_TEMP                      = (1<<3),
 602         CONSTRAINT_IK_STRETCH           = (1<<4),
 603         CONSTRAINT_IK_POS                       = (1<<5),
 604         CONSTRAINT_IK_SETANGLE          = (1<<6),
 605         CONSTRAINT_IK_GETANGLE          = (1<<7),
 606         /* limit axis */
 607         CONSTRAINT_IK_NO_POS_X          = (1<<8),
 608         CONSTRAINT_IK_NO_POS_Y          = (1<<9),
 609         CONSTRAINT_IK_NO_POS_Z          = (1<<10),
 610         CONSTRAINT_IK_NO_ROT_X          = (1<<11),
 611         CONSTRAINT_IK_NO_ROT_Y          = (1<<12),
 612         CONSTRAINT_IK_NO_ROT_Z          = (1<<13),
 613         /* axis relative to target */
 614         CONSTRAINT_IK_TARGETAXIS        = (1<<14),
 615 } eKinematic_Flags;
 616
 617 /* bSplineIKConstraint->flag */
 618 typedef enum eSplineIK_Flags {
 619         /* chain has been attached to spline */
 620         CONSTRAINT_SPLINEIK_BOUND                       = (1<<0),
 621         /* root of chain is not influenced by the constraint */
 622         CONSTRAINT_SPLINEIK_NO_ROOT                     = (1<<1),
 623         /* bones in the chain should not scale to fit the curve */
 624         CONSTRAINT_SPLINEIK_SCALE_LIMITED       = (1<<2),
 625         /* evenly distribute the bones along the path regardless of length */
 626         CONSTRAINT_SPLINEIK_EVENSPLITS          = (1<<3),
 627         /* don't adjust the x and z scaling of the bones by the curve radius */
 628         CONSTRAINT_SPLINEIK_NO_CURVERAD = (1<<4),
 629 } eSplineIK_Flags;
 630
 631 /* bSplineIKConstraint->xzScaleMode */
 632 typedef enum eSplineIK_XZScaleModes {
 633         /* no x/z scaling */
 634         CONSTRAINT_SPLINEIK_XZS_NONE                    = 0,
 635         /* bones in the chain should take their x/z scales from the original scaling */
 636         CONSTRAINT_SPLINEIK_XZS_ORIGINAL,
 637         /* x/z scales are the inverse of the y-scale */
 638         CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC,
 639 } eSplineIK_XZScaleModes;
 640
 641 /* MinMax (floor) flags */
 642 typedef enum eFloor_Flags {
 643         MINMAX_STICKY   = (1<<0),
 644         MINMAX_STUCK    = (1<<1),
 645         MINMAX_USEROT   = (1<<2),
 646 } eFloor_Flags;
 647
 648 /* transform limiting constraints -> flag2 */
 649 typedef enum eTransformLimits_Flags2 {
 650         /* not used anymore - for older Limit Location constraints only */
 651         LIMIT_NOPARENT  = (1<<0),
 652         /* for all Limit constraints - allow to be used during transform? */
 653         LIMIT_TRANSFORM = (1<<1),
 654 } eTransformLimits_Flags2;
 655
 656 /* transform limiting constraints -> flag (own flags)  */
 657 typedef enum eTransformLimits_Flags {
 658         LIMIT_XMIN = (1<<0),
 659         LIMIT_XMAX = (1<<1),
 660         LIMIT_YMIN = (1<<2),
 661         LIMIT_YMAX = (1<<3),
 662         LIMIT_ZMIN = (1<<4),
 663         LIMIT_ZMAX = (1<<5),
 664 } eTransformLimits_Flags;
 665
 666 /* limit rotation constraint -> flag (own flags) */
 667 typedef enum eRotLimit_Flags {
 668         LIMIT_XROT = (1<<0),
 669         LIMIT_YROT = (1<<1),
 670         LIMIT_ZROT = (1<<2),
 671 } eRotLimit_Flags;
 672
 673 /* distance limit constraint */
 674         /* bDistLimitConstraint->flag */
 675 typedef enum eDistLimit_Flag {
 676         LIMITDIST_USESOFT       = (1<<0),
 677 } eDistLimit_Flag;
 678
 679         /* bDistLimitConstraint->mode */
 680 typedef enum eDistLimit_Modes {
 681         LIMITDIST_INSIDE = 0,
 682         LIMITDIST_OUTSIDE,
 683         LIMITDIST_ONSURFACE,
 684 } eDistLimit_Modes;
 685
 686 /* python constraint -> flag */
 687 typedef enum ePyConstraint_Flags {
 688         PYCON_USETARGETS        = (1<<0),
 689         PYCON_SCRIPTERROR       = (1<<1),
 690 } ePyConstraint_Flags;
 691
 692 /* ChildOf Constraint -> flag */
 693 typedef enum eChildOf_Flags {
 694         CHILDOF_LOCX    = (1<<0),
 695         CHILDOF_LOCY    = (1<<1),
 696         CHILDOF_LOCZ    = (1<<2),
 697         CHILDOF_ROTX    = (1<<3),
 698         CHILDOF_ROTY    = (1<<4),
 699         CHILDOF_ROTZ    = (1<<5),
 700         CHILDOF_SIZEX   = (1<<6),
 701         CHILDOF_SIZEY   = (1<<7),
 702         CHILDOF_SIZEZ   = (1<<8),
 703 } eChildOf_Flags;
 704
 705 /* Pivot Constraint */
 706         /* Restrictions for Pivot Constraint axis to consider for enabling constraint */
 707 typedef enum ePivotConstraint_Axis {
 708         /* do not consider this activity-clamping */
 709         PIVOTCON_AXIS_NONE = -1,
 710
 711         /* consider -ve x-axis rotations */
 712         PIVOTCON_AXIS_X_NEG,
 713         /* consider -ve y-axis rotations */
 714         PIVOTCON_AXIS_Y_NEG,
 715         /* consider -ve z-axis rotations */
 716         PIVOTCON_AXIS_Z_NEG,
 717
 718         /* consider +ve x-axis rotations */
 719         PIVOTCON_AXIS_X,
 720         /* consider +ve y-axis rotations */
 721         PIVOTCON_AXIS_Y,
 722         /* consider +ve z-axis rotations */
 723         PIVOTCON_AXIS_Z,
 724 } ePivotConstraint_Axis;
 725
 726         /* settings for Pivot Constraint in general */
 727 typedef enum ePivotConstraint_Flag {
 728         /* offset is to be interpreted as being a fixed-point in space */
 729         PIVOTCON_FLAG_OFFSET_ABS        = (1<<0),
 730         /* rotation-based activation uses negative rotation to drive result */
 731         PIVOTCON_FLAG_ROTACT_NEG        = (1<<1),
 732 } ePivotConstraint_Flag;
 733
 734 /* Rigid-Body Constraint */
 735 #define CONSTRAINT_DRAW_PIVOT 0x40
 736 #define         CONSTRAINT_DISABLE_LINKED_COLLISION 0x80
 737
 738 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
 739 #define         CONSTRAINT_RB_BALL              1
 740 #define         CONSTRAINT_RB_HINGE             2
 741 #define         CONSTRAINT_RB_CONETWIST 4
 742 #define         CONSTRAINT_RB_VEHICLE   11
 743 #define         CONSTRAINT_RB_GENERIC6DOF 12
 744
 745 #endif