Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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_ipo_types.h"
36 #include "DNA_listBase.h"
37 #include "DNA_object_types.h"
38
39 struct Action;
40 struct Text;
41 struct Ipo;
42
43 /* channels reside in Object or Action (ListBase) constraintChannels */
44 typedef struct bConstraintChannel {
45         struct bConstraintChannel *next, *prev;
46         Ipo                     *ipo;
47         short           flag;
48         char            name[30];
49 } bConstraintChannel;
50
51 /* A Constraint */
52 typedef struct bConstraint {
53         struct bConstraint *next, *prev;
54         
55         void            *data;          /*      Constraint data (a valid constraint type) */
56         short           type;           /*      Constraint type */
57         short           flag;           /*      Flag - General Settings */
58         
59         char            ownspace;       /*      Space that owner should be evaluated in         */
60         char            tarspace;       /*      Space that target should be evaluated in (only used if 1 target) */
61         
62         char            name[30];       /*      Constraint name */
63         
64         float           enforce;        /*      Amount of influence exherted by constraint (0.0-1.0) */
65         float           headtail;       /*      Point along subtarget bone where the actual target is. 0=head (default for all), 1=tail*/
66         int                     pad;
67         
68         struct Ipo *ipo;                /* local influence ipo or driver */ // XXX depreceated for 2.5... old animation system hack
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         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_arithb.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         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         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         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 /* Single-target subobject constraints ---------------------  */
155 /* Track To Constraint */
156 typedef struct bTrackToConstraint {
157         Object          *tar;
158         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*/
159         int                     reserved2;
160         int                     flags;
161         int                     pad;
162         char            subtarget[32];
163 } bTrackToConstraint;
164
165 /* Copy Rotation Constraint */
166 typedef struct bRotateLikeConstraint {
167         Object          *tar;
168         int                     flag;
169         int                     reserved1;
170         char            subtarget[32];
171 } bRotateLikeConstraint;
172
173 /* Copy Location Constraint */
174 typedef struct bLocateLikeConstraint {
175         Object          *tar;
176         int                     flag;
177         int                     reserved1;
178         char            subtarget[32];
179 } bLocateLikeConstraint;
180
181 /* Floor Constraint */
182 typedef struct bMinMaxConstraint {
183         Object          *tar;
184         int                     minmaxflag;
185         float           offset;
186         int                     flag;
187         short           sticky, stuck, pad1, pad2; /* for backward compatability */
188         float           cache[3];
189         char            subtarget[32];
190 } bMinMaxConstraint;
191
192 /* Copy Scale Constraint */
193 typedef struct bSizeLikeConstraint {
194         Object          *tar;
195         int                     flag;
196         int                     reserved1;
197         char            subtarget[32];
198 } bSizeLikeConstraint;
199
200 /* Action Constraint */
201 typedef struct bActionConstraint {
202         Object          *tar;
203         short           type;   /* what transform 'channel' drives the result */
204         short           local;  /* was used in versions prior to the Constraints recode */
205         int                     start;
206         int                     end;
207         float           min;
208         float           max;
209         int         pad;
210         struct bAction  *act;
211         char            subtarget[32];
212 } bActionConstraint;
213
214 /* Locked Axis Tracking constraint */
215 typedef struct bLockTrackConstraint {
216         Object          *tar;
217         int                     trackflag;
218         int                     lockflag;
219         char            subtarget[32];
220 } bLockTrackConstraint;
221
222 /* Follow Path constraints */
223 typedef struct bFollowPathConstraint {
224         Object          *tar;   /* Must be path object */
225         float           offset; /* Offset in time on the path (in frame) */
226         int                     followflag;
227         int                     trackflag;
228         int                     upflag;
229 } bFollowPathConstraint;
230
231 /* Stretch to constraint */
232 typedef struct bStretchToConstraint {
233         Object          *tar;
234         int                     volmode; 
235         int         plane;
236         float           orglength;
237         float           bulge;
238         char            subtarget[32];
239 } bStretchToConstraint;
240
241 /* Rigid Body constraint */
242 typedef struct bRigidBodyJointConstraint {
243         Object          *tar;
244         Object          *child;
245         int         type;
246         float       pivX;
247         float       pivY;
248         float       pivZ;
249         float       axX;
250         float       axY;
251         float       axZ;
252         float       minLimit[6];
253         float       maxLimit[6];
254         float       extraFz;
255         short           flag;
256         short           pad;
257         short           pad1;
258         short           pad2;
259 } bRigidBodyJointConstraint;
260
261 /* Clamp-To Constraint */
262 typedef struct bClampToConstraint {
263         Object          *tar;                   /* 'target' must be a curve */
264         int                     flag;                   /* which axis/plane to compare owner's location on  */
265         int                     flag2;                  /* for legacy reasons, this is flag2. used for any extra settings */
266 } bClampToConstraint;
267
268 /* Child Of Constraint */
269 typedef struct bChildOfConstraint {
270         Object          *tar;                   /* object which will act as parent (or target comes from) */
271         int             flag;                   /* settings */
272         int                     pad;
273         float           invmat[4][4];   /* parent-inverse matrix to use */
274         char            subtarget[32];  /* string to specify a subobject target */
275 } bChildOfConstraint;
276
277 /* Generic Transform->Transform Constraint */
278 typedef struct bTransformConstraint {
279         Object          *tar;                   /* target (i.e. 'driver' object/bone) */
280         char            subtarget[32];  
281         
282         short           from, to;               /* can be loc(0) , rot(1),  or size(2) */
283         char            map[3];                 /* defines which target-axis deform is copied by each owner-axis */
284         char            expo;                   /* extrapolate motion? if 0, confine to ranges */
285         
286         float           from_min[3];    /* from_min/max defines range of target transform       */
287         float           from_max[3];    /*      to map on to to_min/max range.                  */
288         
289         float           to_min[3];              /* range of motion on owner caused by target  */
290         float           to_max[3];      
291 } bTransformConstraint;
292
293 /* transform limiting constraints - zero target ----------------------------  */
294 /* Limit Location Constraint */
295 typedef struct bLocLimitConstraint {
296         float           xmin, xmax;
297         float           ymin, ymax;
298         float           zmin, zmax;
299         short           flag;
300         short           flag2;
301 } bLocLimitConstraint;
302
303 /* Limit Rotation Constraint */
304 typedef struct bRotLimitConstraint {
305         float           xmin, xmax;
306         float           ymin, ymax;
307         float           zmin, zmax;
308         short           flag;
309         short           flag2;
310 } bRotLimitConstraint;
311
312 /* Limit Scaling Constraint */
313 typedef struct bSizeLimitConstraint {
314         float           xmin, xmax;
315         float           ymin, ymax;
316         float           zmin, zmax;
317         short           flag;
318         short           flag2;
319 } bSizeLimitConstraint;
320
321 /* Limit Distance Constraint */
322 typedef struct bDistLimitConstraint {
323         Object          *tar;
324         char            subtarget[32];
325         
326         float           dist;                   /* distance (radius of clamping sphere) from target */
327         float           soft;                   /* distance from clamping-sphere to start applying 'fade' */
328         
329         short           flag;                   /* settings */
330         short           mode;                   /* how to limit in relation to clamping sphere */
331         int             pad;
332 } bDistLimitConstraint;
333
334 typedef struct bShrinkwrapConstraint {
335         Object          *target;
336         float           dist;                   /* distance to kept from target */
337         short           shrinkType;             /* shrink type (look on MOD shrinkwrap for values) */
338         char            projAxis;               /* axis to project over UP_X, UP_Y, UP_Z */
339         char            pad[9];
340 } bShrinkwrapConstraint;
341
342
343 /* ------------------------------------------ */
344
345 /* bConstraint->type 
346  *      - Do not ever change the order of these, or else files could get
347  *        broken as their correct value cannot be resolved
348  */
349 typedef enum B_CONSTAINT_TYPES {
350         CONSTRAINT_TYPE_NULL = 0,                       /* Invalid/legacy constraint */
351         CONSTRAINT_TYPE_CHILDOF,                        /* Unimplemented non longer :) - during constraints recode, Aligorith */
352         CONSTRAINT_TYPE_TRACKTO,
353         CONSTRAINT_TYPE_KINEMATIC,
354         CONSTRAINT_TYPE_FOLLOWPATH,
355         CONSTRAINT_TYPE_ROTLIMIT,                       /* Unimplemented no longer :) - Aligorith */
356         CONSTRAINT_TYPE_LOCLIMIT,                       /* Unimplemented no longer :) - Aligorith */
357         CONSTRAINT_TYPE_SIZELIMIT,                      /* Unimplemented no longer :) - Aligorith */
358         CONSTRAINT_TYPE_ROTLIKE,        
359         CONSTRAINT_TYPE_LOCLIKE,        
360         CONSTRAINT_TYPE_SIZELIKE,
361         CONSTRAINT_TYPE_PYTHON,                         /* Unimplemented no longer :) - Aligorith. Scripts */
362         CONSTRAINT_TYPE_ACTION,
363         CONSTRAINT_TYPE_LOCKTRACK,                      /* New Tracking constraint that locks an axis in place - theeth */
364         CONSTRAINT_TYPE_DISTLIMIT,                      /* limit distance */
365         CONSTRAINT_TYPE_STRETCHTO,                      /* claiming this to be mine :) is in tuhopuu bjornmose */ 
366         CONSTRAINT_TYPE_MINMAX,                         /* floor constraint */
367         CONSTRAINT_TYPE_RIGIDBODYJOINT,         /* rigidbody constraint */
368         CONSTRAINT_TYPE_CLAMPTO,                        /* clampto constraint */        
369         CONSTRAINT_TYPE_TRANSFORM,                      /* transformation (loc/rot/size -> loc/rot/size) constraint */  
370         CONSTRAINT_TYPE_SHRINKWRAP,                     /* shrinkwrap (loc/rot) constraint */
371         
372         
373         /* NOTE: everytime a new constraint is added, update this */
374         NUM_CONSTRAINT_TYPES= CONSTRAINT_TYPE_SHRINKWRAP
375 } B_CONSTRAINT_TYPES; 
376
377 /* bConstraint->flag */
378 /* flags 0x2 (1<<1) and 0x8 (1<<3) were used in past */
379 /* flag 0x20 (1<<5) was used to indicate that a constraint was evaluated using a 'local' hack for posebones only  */
380 typedef enum B_CONSTRAINT_FLAG {
381                 /* expand for UI */
382         CONSTRAINT_EXPAND =             (1<<0), 
383                 /* pre-check for illegal object name or bone name */
384         CONSTRAINT_DISABLE =    (1<<2), 
385                 /* to indicate which Ipo should be shown, maybe for 3d access later too */      
386         CONSTRAINT_ACTIVE =     (1<<4), 
387                 /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
388         CONSTRAINT_SPACEONCE =  (1<<6),
389                 /* influence ipo is on constraint itself, not in action channel */
390         CONSTRAINT_OWN_IPO      = (1<<7),
391                 /* indicates that constraint was added locally (i.e.  didn't come from the proxy-lib) */
392         CONSTRAINT_PROXY_LOCAL = (1<<8),
393                 /* indicates that constraint is temporarily disabled (only used in GE) */
394         CONSTRAINT_OFF = (1<<9)
395 } B_CONSTRAINT_FLAG;
396
397 /* bConstraint->ownspace/tarspace */
398 typedef enum B_CONSTRAINT_SPACETYPES {
399                 /* default for all - worldspace */
400         CONSTRAINT_SPACE_WORLD = 0,
401                 /* for objects (relative to parent/without parent influence), 
402                  * for bones (along normals of bone, without parent/restpositions) 
403                  */
404         CONSTRAINT_SPACE_LOCAL, /* = 1 */
405                 /* for posechannels - pose space  */
406         CONSTRAINT_SPACE_POSE, /* = 2 */
407                 /* for posechannels - local with parent  */
408         CONSTRAINT_SPACE_PARLOCAL, /* = 3 */
409                 /* for files from between 2.43-2.46 (should have been parlocal) */
410         CONSTRAINT_SPACE_INVALID, /* = 4. do not exchange for anything! */
411 } B_CONSTRAINT_SPACETYPES;
412
413 /* bConstraintChannel.flag */
414 typedef enum B_CONSTRAINTCHANNEL_FLAG {
415         CONSTRAINT_CHANNEL_SELECT =             (1<<0),
416         CONSTRAINT_CHANNEL_PROTECTED =  (1<<1)
417 } B_CONSTRAINTCHANNEL_FLAG;
418
419 /* -------------------------------------- */
420
421 /**
422  * The flags for ROTLIKE, LOCLIKE and SIZELIKE should be kept identical
423  * (that is, same effect, different name). It simplifies the Python API access a lot.
424  */
425
426 /* bRotateLikeConstraint.flag */
427 #define ROTLIKE_X               0x01
428 #define ROTLIKE_Y               0x02
429 #define ROTLIKE_Z               0x04
430 #define ROTLIKE_X_INVERT        0x10
431 #define ROTLIKE_Y_INVERT        0x20
432 #define ROTLIKE_Z_INVERT        0x40
433 #define ROTLIKE_OFFSET  0x80
434
435 /* bLocateLikeConstraint.flag */
436 #define LOCLIKE_X                       0x01
437 #define LOCLIKE_Y                       0x02
438 #define LOCLIKE_Z                       0x04
439         /* LOCLIKE_TIP is a depreceated option... use headtail=1.0f instead */
440 #define LOCLIKE_TIP                     0x08
441 #define LOCLIKE_X_INVERT        0x10
442 #define LOCLIKE_Y_INVERT        0x20
443 #define LOCLIKE_Z_INVERT        0x40
444 #define LOCLIKE_OFFSET          0x80
445  
446 /* bSizeLikeConstraint.flag */
447 #define SIZELIKE_X              0x01
448 #define SIZELIKE_Y              0x02
449 #define SIZELIKE_Z              0x04
450 #define SIZELIKE_OFFSET 0x80
451
452 /* Axis flags */
453 #define LOCK_X          0x00
454 #define LOCK_Y          0x01
455 #define LOCK_Z          0x02
456
457 #define UP_X            0x00
458 #define UP_Y            0x01
459 #define UP_Z            0x02
460
461 #define TRACK_X         0x00
462 #define TRACK_Y         0x01
463 #define TRACK_Z         0x02
464 #define TRACK_nX        0x03
465 #define TRACK_nY        0x04
466 #define TRACK_nZ        0x05
467
468 /* FollowPath flags */
469 #define FOLLOWPATH_FOLLOW       0x01
470 #define FOLLOWPATH_STATIC       0x02
471 #define FOLLOWPATH_RADIUS       0x04
472
473 /* bTrackToConstraint->flags */
474 #define TARGET_Z_UP 0x01
475
476 #define VOLUME_XZ       0x00
477 #define VOLUME_X        0x01
478 #define VOLUME_Z        0x02
479 #define NO_VOLUME       0x03
480
481 #define PLANE_X         0x00
482 #define PLANE_Y         0x01
483 #define PLANE_Z         0x02
484
485 /* Clamp-To Constraint ->flag */
486 #define CLAMPTO_AUTO    0
487 #define CLAMPTO_X               1
488 #define CLAMPTO_Y               2
489 #define CLAMPTO_Z               3
490
491 /* ClampTo Constraint ->flag2 */
492 #define CLAMPTO_CYCLIC  1
493
494 /* bKinematicConstraint->flag */
495 #define CONSTRAINT_IK_TIP               1
496 #define CONSTRAINT_IK_ROT               2
497         /* targetless */
498 #define CONSTRAINT_IK_AUTO              4
499         /* autoik */
500 #define CONSTRAINT_IK_TEMP              8
501 #define CONSTRAINT_IK_STRETCH   16
502 #define CONSTRAINT_IK_POS               32
503 #define CONSTRAINT_IK_SETANGLE  64
504 #define CONSTRAINT_IK_GETANGLE  128
505
506 /* MinMax (floor) flags */
507 #define MINMAX_STICKY   0x01
508 #define MINMAX_STUCK    0x02
509 #define MINMAX_USEROT   0x04
510
511 /* transform limiting constraints -> flag  */
512 #define LIMIT_XMIN 0x01
513 #define LIMIT_XMAX 0x02
514 #define LIMIT_YMIN 0x04
515 #define LIMIT_YMAX 0x08
516 #define LIMIT_ZMIN 0x10
517 #define LIMIT_ZMAX 0x20
518
519 #define LIMIT_XROT 0x01
520 #define LIMIT_YROT 0x02
521 #define LIMIT_ZROT 0x04
522
523         /* not used anymore - for older Limit Location constraints only */
524 #define LIMIT_NOPARENT 0x01
525         /* for all Limit constraints - allow to be used during transform? */
526 #define LIMIT_TRANSFORM 0x02
527
528 /* distance limit constraint */
529         /* bDistLimitConstraint->flag */
530 #define LIMITDIST_USESOFT               (1<<0)
531
532         /* bDistLimitConstraint->mode */
533 #define LIMITDIST_INSIDE                0
534 #define LIMITDIST_OUTSIDE               1
535 #define LIMITDIST_ONSURFACE             2
536         
537 /* python constraint -> flag */
538 #define PYCON_USETARGETS        0x01
539 #define PYCON_SCRIPTERROR       0x02
540
541 /* ChildOf Constraint -> flag */
542 #define CHILDOF_LOCX    0x001
543 #define CHILDOF_LOCY    0x002
544 #define CHILDOF_LOCZ    0x004
545 #define CHILDOF_ROTX    0x008
546 #define CHILDOF_ROTY    0x010
547 #define CHILDOF_ROTZ    0x020
548 #define CHILDOF_SIZEX   0x040
549 #define CHILDOF_SIZEY   0x080
550 #define CHILDOF_SIZEZ   0x100
551
552 /* Rigid-Body Constraint */
553 #define CONSTRAINT_DRAW_PIVOT 0x40
554 #define CONSTRAINT_DISABLE_LINKED_COLLISION 0x80
555
556 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
557 #define CONSTRAINT_RB_BALL              1
558 #define CONSTRAINT_RB_HINGE             2
559 #define CONSTRAINT_RB_CONETWIST 4
560 #define CONSTRAINT_RB_VEHICLE   11
561 #define CONSTRAINT_RB_GENERIC6DOF 12
562
563 #endif