source/blender/makesdna/DNA_constraint_types.h

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL/BL DUAL 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. The Blender
  10  * Foundation also sells licenses for use in proprietary software under
  11  * the Blender License.  See http://www.blender.org/BL/ for information
  12  * about this.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22  *
  23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  24  * All rights reserved.
  25  *
  26  * The Original Code is: all of this file.
  27  *
  28  * Contributor(s): 2007, Joshua Leung, major recode
  29  *
  30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  31  * Constraint DNA data
  32  */
  33
  34 #ifndef DNA_CONSTRAINT_TYPES_H
  35 #define DNA_CONSTRAINT_TYPES_H
  36
  37 #include "DNA_ID.h"
  38 #include "DNA_ipo_types.h"
  39 #include "DNA_object_types.h"
  40
  41 struct Action;
  42 struct Text;
  43 #ifndef __cplusplus
  44 struct PyObject;
  45 #endif
  46
  47 /* channels reside in Object or Action (ListBase) constraintChannels */
  48 typedef struct bConstraintChannel {
  49         struct bConstraintChannel *next, *prev;
  50         Ipo                     *ipo;
  51         short           flag;
  52         char            name[30];
  53 } bConstraintChannel;
  54
  55 /* A Constraint */
  56 typedef struct bConstraint {
  57         struct bConstraint *next, *prev;
  58         void            *data;          /*      Constraint data (a valid constraint type) */
  59         short           type;           /*      Constraint type */
  60         short           flag;           /*      Flag - General Settings */
  61
  62         char            ownspace;       /*      Space that owner should be evaluated in         */
  63         char            tarspace;       /*      Space that target should be evaluated in        */
  64
  65         char            name[30];       /*      Constraint name */
  66
  67         float           enforce;        /*      Amount of influence exherted by constraint (0.0-1.0) */
  68 } bConstraint;
  69
  70
  71 /* Python Script Constraint */
  72 typedef struct bPythonConstraint {
  73         Object *tar;                    /* object to use as target (if required) */
  74         char subtarget[32];     /* bone to use as subtarget (if required) */
  75
  76         struct Text *text;              /* text-buffer (containing script) to execute */
  77         IDProperty *prop;               /* 'id-properties' used to store custom properties for constraint */
  78
  79         int flag;                               /* general settings/state indicators accessed by bitmapping */
  80         int pad;
  81 } bPythonConstraint;
  82
  83 /* Single-target subobject constraints ---------------------  */
  84 /* Inverse-Kinematics (IK) constraint */
  85 typedef struct bKinematicConstraint {
  86         Object          *tar;
  87         short           iterations;             /* Maximum number of iterations to try */
  88         short           flag;                   /* Like CONSTRAINT_IK_TIP */
  89         int                     rootbone;       /* index to rootbone, if zero go all the way to mother bone */
  90         char            subtarget[32];  /* String to specify sub-object target */
  91
  92         float           weight;                 /* Weight of goal in IK tree */
  93         float           orientweight;   /* Amount of rotation a target applies on chain */
  94         float           grabtarget[3];  /* for target-less IK */
  95         int                     pad;
  96 } bKinematicConstraint;
  97
  98 /* Track To Constraint */
  99 typedef struct bTrackToConstraint {
 100         Object          *tar;
 101         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*/
 102         int                     reserved2;
 103         int                     flags;
 104         int                     pad;
 105         char            subtarget[32];
 106 } bTrackToConstraint;
 107
 108 /* Copy Rotation Constraint */
 109 typedef struct bRotateLikeConstraint {
 110         Object          *tar;
 111         int                     flag;
 112         int                     reserved1;
 113         char            subtarget[32];
 114 } bRotateLikeConstraint;
 115
 116 /* Copy Location Constraint */
 117 typedef struct bLocateLikeConstraint {
 118         Object          *tar;
 119         int                     flag;
 120         int                     reserved1;
 121         char            subtarget[32];
 122 } bLocateLikeConstraint;
 123
 124 /* Floor Constraint */
 125 typedef struct bMinMaxConstraint {
 126         Object          *tar;
 127         int                     minmaxflag;
 128         float                   offset;
 129         int                             flag;
 130         short                   sticky, stuck, pad1, pad2; /* for backward compatability */
 131         float                   cache[3];
 132         char            subtarget[32];
 133 } bMinMaxConstraint;
 134
 135 /* Copy Scale Constraint */
 136 typedef struct bSizeLikeConstraint {
 137         Object          *tar;
 138         int                     flag;
 139         int                     reserved1;
 140         char            subtarget[32];
 141 } bSizeLikeConstraint;
 142
 143 /* Action Constraint */
 144 typedef struct bActionConstraint {
 145         Object          *tar;
 146         short           type;
 147         short           local;  /* was used in versions prior to the Constraints recode */
 148         int             start;
 149         int             end;
 150         float           min;
 151         float           max;
 152         int             pad;
 153         struct bAction  *act;
 154         char            subtarget[32];
 155 } bActionConstraint;
 156
 157 /* Locked Axis Tracking constraint */
 158 typedef struct bLockTrackConstraint {
 159         Object          *tar;
 160         int                     trackflag;
 161         int                     lockflag;
 162         char            subtarget[32];
 163 } bLockTrackConstraint;
 164
 165 /* Follow Path constraints */
 166 typedef struct bFollowPathConstraint {
 167         Object          *tar;   /* Must be path object */
 168         float           offset; /* Offset in time on the path (in frame) */
 169         int                     followflag;
 170         int                     trackflag;
 171         int                     upflag;
 172 } bFollowPathConstraint;
 173
 174 /* Stretch to constraint */
 175 typedef struct bStretchToConstraint {
 176         Object          *tar;
 177         int                     volmode;
 178         int         plane;
 179         float           orglength;
 180         float           bulge;
 181         char            subtarget[32];
 182 } bStretchToConstraint;
 183
 184 /* Rigid Body constraint */
 185 typedef struct bRigidBodyJointConstraint {
 186         Object          *tar;
 187         Object          *child;
 188         int         type;
 189         float       pivX;
 190         float       pivY;
 191         float       pivZ;
 192         float       axX;
 193         float       axY;
 194         float       axZ;
 195         float       minLimit[6];
 196         float       maxLimit[6];
 197         float       extraFz;
 198         short           flag;
 199         short           pad;
 200         short           pad1;
 201         short           pad2;
 202 } bRigidBodyJointConstraint;
 203
 204 /* Clamp-To Constraint */
 205 typedef struct bClampToConstraint {
 206         Object          *tar;                   /* 'target' must be a curve */
 207         int                     flag;                   /* which axis/plane to compare owner's location on  */
 208         int                     flag2;                  /* for legacy reasons, this is flag2. used for any extra settings */
 209 } bClampToConstraint;
 210
 211 /* Child Of Constraint */
 212 typedef struct bChildOfConstraint {
 213         Object          *tar;                   /* object which will act as parent (or target comes from) */
 214         int             flag;                   /* settings */
 215         int                     pad;
 216         float           invmat[4][4];   /* parent-inverse matrix to use */
 217         char            subtarget[32];  /* string to specify a subobject target */
 218 } bChildOfConstraint;
 219
 220 /* Generic Transform->Transform Constraint */
 221 typedef struct bTransformConstraint {
 222         Object          *tar;                   /* target (i.e. 'driver' object/bone) */
 223         char            subtarget[32];
 224
 225         short           from, to;               /* can be loc(0) , rot(1),  or size(2) */
 226         char            map[3];                 /* defines which target-axis deform is copied by each owner-axis */
 227         char            expo;                   /* extrapolate motion? if 0, confine to ranges */
 228
 229         float           from_min[3];    /* from_min/max defines range of target transform       */
 230         float           from_max[3];    /*      to map on to to_min/max range.                  */
 231
 232         float           to_min[3];              /* range of motion on owner caused by target  */
 233         float           to_max[3];
 234 } bTransformConstraint;
 235
 236 /* transform limiting constraints - zero target ----------------------------  */
 237 /* Limit Location Constraint */
 238 typedef struct bLocLimitConstraint {
 239         float           xmin, xmax;
 240         float           ymin, ymax;
 241         float           zmin, zmax;
 242         short           flag;
 243         short           flag2;
 244 } bLocLimitConstraint;
 245
 246 /* Limit Rotation Constraint */
 247 typedef struct bRotLimitConstraint {
 248         float           xmin, xmax;
 249         float           ymin, ymax;
 250         float           zmin, zmax;
 251         short           flag;
 252         short           pad1;
 253 } bRotLimitConstraint;
 254
 255 /* Limit Scaling Constraint */
 256 typedef struct bSizeLimitConstraint {
 257         float           xmin, xmax;
 258         float           ymin, ymax;
 259         float           zmin, zmax;
 260         short           flag;
 261         short           pad1;
 262 } bSizeLimitConstraint;
 263
 264 /* bConstraint.type */
 265 #define CONSTRAINT_TYPE_NULL            0
 266 #define CONSTRAINT_TYPE_CHILDOF         1               /* Unimplemented non longer :) - during constraints recode, Aligorith */
 267 #define CONSTRAINT_TYPE_TRACKTO         2
 268 #define CONSTRAINT_TYPE_KINEMATIC       3
 269 #define CONSTRAINT_TYPE_FOLLOWPATH      4
 270 #define CONSTRAINT_TYPE_ROTLIMIT        5               /* Unimplemented no longer :) - Aligorith */
 271 #define CONSTRAINT_TYPE_LOCLIMIT        6               /* Unimplemented no longer :) - Aligorith */
 272 #define CONSTRAINT_TYPE_SIZELIMIT       7               /* Unimplemented no longer :) - Aligorith */
 273 #define CONSTRAINT_TYPE_ROTLIKE         8
 274 #define CONSTRAINT_TYPE_LOCLIKE         9
 275 #define CONSTRAINT_TYPE_SIZELIKE        10
 276 #define CONSTRAINT_TYPE_PYTHON          11              /* Unimplemented no longer :) - Aligorith. Scripts */
 277 #define CONSTRAINT_TYPE_ACTION          12
 278 #define CONSTRAINT_TYPE_LOCKTRACK       13              /* New Tracking constraint that locks an axis in place - theeth */
 279 #define CONSTRAINT_TYPE_DISTANCELIMIT 14        /* was never properly coded - removed! */
 280 #define CONSTRAINT_TYPE_STRETCHTO       15      /* claiming this to be mine :) is in tuhopuu bjornmose */
 281 #define CONSTRAINT_TYPE_MINMAX      16          /* floor constraint */
 282 #define CONSTRAINT_TYPE_RIGIDBODYJOINT 17       /* rigidbody constraint */
 283 #define CONSTRAINT_TYPE_CLAMPTO         18      /* clampto constraint */
 284 #define CONSTRAINT_TYPE_TRANSFORM       19              /* transformation constraint */
 285
 286 /* bConstraint->flag */
 287                 /* expand for UI */
 288 #define CONSTRAINT_EXPAND               0x01
 289                 /* pre-check for illegal object name or bone name */
 290 #define CONSTRAINT_DISABLE              0x04
 291                 /* flags 0x2 and 0x8 were used in past, skip this */
 292                 /* to indicate which Ipo should be shown, maybe for 3d access later too */
 293 #define CONSTRAINT_ACTIVE               0x10
 294                 /* flag 0x20 was used to indicate that a constraint was evaluated using a 'local' hack for posebones only  */
 295                 /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
 296 #define CONSTRAINT_SPACEONCE    0x40
 297
 298 /* bConstraint->ownspace/tarspace */
 299         /* default for all - worldspace */
 300 #define CONSTRAINT_SPACE_WORLD                  0
 301         /* for objects (relative to parent/without parent influence), for bones (along normals of bone, without parent/restposi) */
 302 #define CONSTRAINT_SPACE_LOCAL                  1
 303         /* for posechannels - pose space  */
 304 #define CONSTRAINT_SPACE_POSE                   2
 305         /* for posechannels - local with parent  */
 306 #define CONSTRAINT_SPACE_PARLOCAL               3
 307
 308 /* bConstraintChannel.flag */
 309 #define CONSTRAINT_CHANNEL_SELECT               0x01
 310 #define CONSTRAINT_CHANNEL_PROTECTED    0x02
 311
 312 /**
 313  * The flags for ROTLIKE, LOCLIKE and SIZELIKE should be kept identical
 314  * (that is, same effect, different name). It simplifies the Python API access a lot.
 315  */
 316
 317 /* bRotateLikeConstraint.flag */
 318 #define ROTLIKE_X               0x01
 319 #define ROTLIKE_Y               0x02
 320 #define ROTLIKE_Z               0x04
 321 #define ROTLIKE_X_INVERT        0x10
 322 #define ROTLIKE_Y_INVERT        0x20
 323 #define ROTLIKE_Z_INVERT        0x40
 324 #define ROTLIKE_OFFSET  0x80
 325
 326 /* bLocateLikeConstraint.flag */
 327 #define LOCLIKE_X                       0x01
 328 #define LOCLIKE_Y                       0x02
 329 #define LOCLIKE_Z                       0x04
 330 #define LOCLIKE_TIP                     0x08
 331 #define LOCLIKE_X_INVERT        0x10
 332 #define LOCLIKE_Y_INVERT        0x20
 333 #define LOCLIKE_Z_INVERT        0x40
 334 #define LOCLIKE_OFFSET          0x80
 335
 336 /* bSizeLikeConstraint.flag */
 337 #define SIZELIKE_X              0x01
 338 #define SIZELIKE_Y              0x02
 339 #define SIZELIKE_Z              0x04
 340 #define SIZELIKE_OFFSET 0x80
 341
 342 /* Axis flags */
 343 #define LOCK_X          0x00
 344 #define LOCK_Y          0x01
 345 #define LOCK_Z          0x02
 346
 347 #define UP_X            0x00
 348 #define UP_Y            0x01
 349 #define UP_Z            0x02
 350
 351 #define TRACK_X         0x00
 352 #define TRACK_Y         0x01
 353 #define TRACK_Z         0x02
 354 #define TRACK_nX        0x03
 355 #define TRACK_nY        0x04
 356 #define TRACK_nZ        0x05
 357
 358 /* bTrackToConstraint->flags */
 359 #define TARGET_Z_UP 0x01
 360
 361 #define VOLUME_XZ       0x00
 362 #define VOLUME_X        0x01
 363 #define VOLUME_Z        0x02
 364 #define NO_VOLUME       0x03
 365
 366 #define PLANE_X         0x00
 367 #define PLANE_Y         0x01
 368 #define PLANE_Z         0x02
 369
 370 /* Clamp-To Constraint ->flag */
 371 #define CLAMPTO_AUTO    0
 372 #define CLAMPTO_X               1
 373 #define CLAMPTO_Y               2
 374 #define CLAMPTO_Z               3
 375
 376 /* ClampTo Constraint ->flag2 */
 377 #define CLAMPTO_CYCLIC  1
 378
 379 /* bKinematicConstraint->flag */
 380 #define CONSTRAINT_IK_TIP               1
 381 #define CONSTRAINT_IK_ROT               2
 382 #define CONSTRAINT_IK_AUTO              4
 383 #define CONSTRAINT_IK_TEMP              8
 384 #define CONSTRAINT_IK_STRETCH   16
 385 #define CONSTRAINT_IK_POS               32
 386
 387 /* MinMax (floor) flags */
 388 #define MINMAX_STICKY   0x01
 389 #define MINMAX_STUCK    0x02
 390 #define MINMAX_USEROT   0x04
 391
 392 /* transform limiting constraints -> flag  */
 393 #define LIMIT_XMIN 0x01
 394 #define LIMIT_XMAX 0x02
 395 #define LIMIT_YMIN 0x04
 396 #define LIMIT_YMAX 0x08
 397 #define LIMIT_ZMIN 0x10
 398 #define LIMIT_ZMAX 0x20
 399
 400 #define LIMIT_XROT 0x01
 401 #define LIMIT_YROT 0x02
 402 #define LIMIT_ZROT 0x04
 403
 404 /* not used anymore - for older Limit Location constraints only */
 405 #define LIMIT_NOPARENT 0x01
 406
 407 /* python constraint -> flag */
 408 #define PYCON_USETARGETS        0x01
 409 #define PYCON_SCRIPTERROR       0x02
 410
 411 /* ChildOf Constraint -> flag */
 412 #define CHILDOF_LOCX    0x001
 413 #define CHILDOF_LOCY    0x002
 414 #define CHILDOF_LOCZ    0x004
 415 #define CHILDOF_ROTX    0x008
 416 #define CHILDOF_ROTY    0x010
 417 #define CHILDOF_ROTZ    0x020
 418 #define CHILDOF_SIZEX   0x040
 419 #define CHILDOF_SIZEY   0x080
 420 #define CHILDOF_SIZEZ   0x100
 421
 422 /* Rigid-Body Constraint */
 423 #define CONSTRAINT_DRAW_PIVOT 0x40
 424
 425 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
 426 #define CONSTRAINT_RB_BALL              1
 427 #define CONSTRAINT_RB_HINGE             2
 428 #define CONSTRAINT_RB_CONETWIST 4
 429 #define CONSTRAINT_RB_VEHICLE   11
 430 #define CONSTRAINT_RB_GENERIC6DOF 12
 431
 432 #endif