Pole Target for IK
[blender-staging.git] / 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_listBase.h"
40 #include "DNA_object_types.h"
41
42 struct Action;
43 struct Text;
44
45 /* channels reside in Object or Action (ListBase) constraintChannels */
46 typedef struct bConstraintChannel {
47         struct bConstraintChannel *next, *prev;
48         Ipo                     *ipo;
49         short           flag;
50         char            name[30];
51 } bConstraintChannel;
52
53 /* A Constraint */
54 typedef struct bConstraint {
55         struct bConstraint *next, *prev;
56         
57         void            *data;          /*      Constraint data (a valid constraint type) */
58         short           type;           /*      Constraint type */
59         short           flag;           /*      Flag - General Settings */
60         
61         char            ownspace;       /*      Space that owner should be evaluated in         */
62         char            tarspace;       /*      Space that target should be evaluated in (only used if 1 target) */
63         
64         char            name[30];       /*      Constraint name */
65         
66         float           enforce;        /*      Amount of influence exherted by constraint (0.0-1.0) */
67 } bConstraint;
68
69
70 /* Multiple-target constraints ---------------------  */
71
72 /* This struct defines a constraint target.
73  * It is used during constraint solving regardless of how many targets the
74  * constraint has.
75  */
76 typedef struct bConstraintTarget {
77         struct bConstraintTarget *next, *prev;
78
79         Object *tar;                    /* object to use as target */
80         char subtarget[32];             /* subtarget - pchan or vgroup name */
81         
82         float matrix[4][4];             /* matrix used during constraint solving - should be cleared before each use */
83         
84         short space;                    /* space that target should be evaluated in (overrides bConstraint->tarspace) */
85         short flag;                             /* runtime settings (for editor, etc.) */
86         short type;                             /* type of target (B_CONSTRAINT_OB_TYPE) */
87         short pad;
88 } bConstraintTarget;
89
90 /* bConstraintTarget -> flag */
91 typedef enum B_CONSTRAINT_TARGET_FLAG {
92         CONSTRAINT_TAR_TEMP = (1<<0),           /* temporary target-struct that needs to be freed after use */
93 } B_CONSTRAINT_TARGET_FLAG;
94
95 /* bConstraintTarget/bConstraintOb -> type */
96 typedef enum B_CONSTRAINT_OB_TYPE {
97         CONSTRAINT_OBTYPE_OBJECT = 1,   /*      string is ""                            */
98         CONSTRAINT_OBTYPE_BONE,                 /*      string is bone-name             */
99         CONSTRAINT_OBTYPE_VERT,                 /*      string is vertex-group name     */
100         CONSTRAINT_OBTYPE_CV                    /*      string is vertex-group name - is not available until curves get vgroups */
101 } B_CONSTRAINT_OB_TYPE;
102
103
104
105 /* Python Script Constraint */
106 typedef struct bPythonConstraint {      
107         struct Text *text;              /* text-buffer (containing script) to execute */
108         IDProperty *prop;               /* 'id-properties' used to store custom properties for constraint */
109         
110         int flag;                               /* general settings/state indicators accessed by bitmapping */
111         int tarnum;                             /* number of targets - usually only 1-3 are needed */
112         
113         ListBase targets;               /* a list of targets that this constraint has (bConstraintTarget-s) */
114         
115         Object *tar;                    /* target from previous implementation (version-patch sets this to NULL on file-load) */
116         char subtarget[32];             /* subtarger from previous implentation (version-patch sets this to "" on file-load) */
117 } bPythonConstraint;
118
119 /* Single-target subobject constraints ---------------------  */
120 /* Inverse-Kinematics (IK) constraint */
121 typedef struct bKinematicConstraint {
122         Object          *tar;
123         short           iterations;             /* Maximum number of iterations to try */
124         short           flag;                   /* Like CONSTRAINT_IK_TIP */
125         int                     rootbone;       /* index to rootbone, if zero go all the way to mother bone */
126         char            subtarget[32];  /* String to specify sub-object target */
127
128         Object          *poletar;                       /* Pole vector target */
129         char            polesubtarget[32];      /* Pole vector sub-object target */
130         float           poleangle;                      /* Pole vector rest angle */
131
132         float           weight;                 /* Weight of goal in IK tree */
133         float           orientweight;   /* Amount of rotation a target applies on chain */
134         float           grabtarget[3];  /* for target-less IK */
135 } bKinematicConstraint;
136
137 /* Track To Constraint */
138 typedef struct bTrackToConstraint {
139         Object          *tar;
140         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*/
141         int                     reserved2;
142         int                     flags;
143         int                     pad;
144         char            subtarget[32];
145 } bTrackToConstraint;
146
147 /* Copy Rotation Constraint */
148 typedef struct bRotateLikeConstraint {
149         Object          *tar;
150         int                     flag;
151         int                     reserved1;
152         char            subtarget[32];
153 } bRotateLikeConstraint;
154
155 /* Copy Location Constraint */
156 typedef struct bLocateLikeConstraint {
157         Object          *tar;
158         int                     flag;
159         int                     reserved1;
160         char            subtarget[32];
161 } bLocateLikeConstraint;
162
163 /* Floor Constraint */
164 typedef struct bMinMaxConstraint {
165         Object          *tar;
166         int                     minmaxflag;
167         float           offset;
168         int                     flag;
169         short           sticky, stuck, pad1, pad2; /* for backward compatability */
170         float           cache[3];
171         char            subtarget[32];
172 } bMinMaxConstraint;
173
174 /* Copy Scale Constraint */
175 typedef struct bSizeLikeConstraint {
176         Object          *tar;
177         int                     flag;
178         int                     reserved1;
179         char            subtarget[32];
180 } bSizeLikeConstraint;
181
182 /* Action Constraint */
183 typedef struct bActionConstraint {
184         Object          *tar;
185         short           type;   /* what transform 'channel' drives the result */
186         short           local;  /* was used in versions prior to the Constraints recode */
187         int                     start;
188         int                     end;
189         float           min;
190         float           max;
191         int         pad;
192         struct bAction  *act;
193         char            subtarget[32];
194 } bActionConstraint;
195
196 /* Locked Axis Tracking constraint */
197 typedef struct bLockTrackConstraint {
198         Object          *tar;
199         int                     trackflag;
200         int                     lockflag;
201         char            subtarget[32];
202 } bLockTrackConstraint;
203
204 /* Follow Path constraints */
205 typedef struct bFollowPathConstraint {
206         Object          *tar;   /* Must be path object */
207         float           offset; /* Offset in time on the path (in frame) */
208         int                     followflag;
209         int                     trackflag;
210         int                     upflag;
211 } bFollowPathConstraint;
212
213 /* Stretch to constraint */
214 typedef struct bStretchToConstraint {
215         Object          *tar;
216         int                     volmode; 
217         int         plane;
218         float           orglength;
219         float           bulge;
220         char            subtarget[32];
221 } bStretchToConstraint;
222
223 /* Rigid Body constraint */
224 typedef struct bRigidBodyJointConstraint {
225         Object          *tar;
226         Object          *child;
227         int         type;
228         float       pivX;
229         float       pivY;
230         float       pivZ;
231         float       axX;
232         float       axY;
233         float       axZ;
234         float       minLimit[6];
235         float       maxLimit[6];
236         float       extraFz;
237         short           flag;
238         short           pad;
239         short           pad1;
240         short           pad2;
241 } bRigidBodyJointConstraint;
242
243 /* Clamp-To Constraint */
244 typedef struct bClampToConstraint {
245         Object          *tar;                   /* 'target' must be a curve */
246         int                     flag;                   /* which axis/plane to compare owner's location on  */
247         int                     flag2;                  /* for legacy reasons, this is flag2. used for any extra settings */
248 } bClampToConstraint;
249
250 /* Child Of Constraint */
251 typedef struct bChildOfConstraint {
252         Object          *tar;                   /* object which will act as parent (or target comes from) */
253         int             flag;                   /* settings */
254         int                     pad;
255         float           invmat[4][4];   /* parent-inverse matrix to use */
256         char            subtarget[32];  /* string to specify a subobject target */
257 } bChildOfConstraint;
258
259 /* Generic Transform->Transform Constraint */
260 typedef struct bTransformConstraint {
261         Object          *tar;                   /* target (i.e. 'driver' object/bone) */
262         char            subtarget[32];  
263         
264         short           from, to;               /* can be loc(0) , rot(1),  or size(2) */
265         char            map[3];                 /* defines which target-axis deform is copied by each owner-axis */
266         char            expo;                   /* extrapolate motion? if 0, confine to ranges */
267         
268         float           from_min[3];    /* from_min/max defines range of target transform       */
269         float           from_max[3];    /*      to map on to to_min/max range.                  */
270         
271         float           to_min[3];              /* range of motion on owner caused by target  */
272         float           to_max[3];      
273 } bTransformConstraint;
274
275 /* transform limiting constraints - zero target ----------------------------  */
276 /* Limit Location Constraint */
277 typedef struct bLocLimitConstraint {
278         float           xmin, xmax;
279         float           ymin, ymax;
280         float           zmin, zmax;
281         short           flag;
282         short           flag2;
283 } bLocLimitConstraint;
284
285 /* Limit Rotation Constraint */
286 typedef struct bRotLimitConstraint {
287         float           xmin, xmax;
288         float           ymin, ymax;
289         float           zmin, zmax;
290         short           flag;
291         short           pad1;
292 } bRotLimitConstraint;
293
294 /* Limit Scaling Constraint */
295 typedef struct bSizeLimitConstraint {
296         float           xmin, xmax;
297         float           ymin, ymax;
298         float           zmin, zmax;
299         short           flag;
300         short           pad1;
301 } bSizeLimitConstraint;
302
303 /* ------------------------------------------ */
304
305 /* bConstraint->type 
306  *      - Do not ever change the order of these, or else files could get
307  *        broken as their correct value cannot be resolved
308  */
309 typedef enum B_CONSTAINT_TYPES {
310         CONSTRAINT_TYPE_NULL = 0,                       /* Invalid/legacy constraint */
311         CONSTRAINT_TYPE_CHILDOF,                        /* Unimplemented non longer :) - during constraints recode, Aligorith */
312         CONSTRAINT_TYPE_TRACKTO,
313         CONSTRAINT_TYPE_KINEMATIC,
314         CONSTRAINT_TYPE_FOLLOWPATH,
315         CONSTRAINT_TYPE_ROTLIMIT,                       /* Unimplemented no longer :) - Aligorith */
316         CONSTRAINT_TYPE_LOCLIMIT,                       /* Unimplemented no longer :) - Aligorith */
317         CONSTRAINT_TYPE_SIZELIMIT,                      /* Unimplemented no longer :) - Aligorith */
318         CONSTRAINT_TYPE_ROTLIKE,        
319         CONSTRAINT_TYPE_LOCLIKE,        
320         CONSTRAINT_TYPE_SIZELIKE,
321         CONSTRAINT_TYPE_PYTHON,                         /* Unimplemented no longer :) - Aligorith. Scripts */
322         CONSTRAINT_TYPE_ACTION,
323         CONSTRAINT_TYPE_LOCKTRACK,                      /* New Tracking constraint that locks an axis in place - theeth */
324         CONSTRAINT_TYPE_DISTANCELIMIT,          /* was never properly coded - removed! */
325         CONSTRAINT_TYPE_STRETCHTO,                      /* claiming this to be mine :) is in tuhopuu bjornmose */ 
326         CONSTRAINT_TYPE_MINMAX,                         /* floor constraint */
327         CONSTRAINT_TYPE_RIGIDBODYJOINT,         /* rigidbody constraint */
328         CONSTRAINT_TYPE_CLAMPTO,                        /* clampto constraint */        
329         CONSTRAINT_TYPE_TRANSFORM,                      /* transformation (loc/rot/size -> loc/rot/size) constraint */  
330         
331         /* NOTE: everytime a new constraint is added, update this */
332         NUM_CONSTRAINT_TYPES= CONSTRAINT_TYPE_TRANSFORM
333 } B_CONSTRAINT_TYPES; 
334
335 /* bConstraint->flag */
336 /* flags 0x2 (1<<1) and 0x8 (1<<3) were used in past */
337 /* flag 0x20 (1<<5) was used to indicate that a constraint was evaluated using a 'local' hack for posebones only  */
338 typedef enum B_CONSTRAINT_FLAG {
339                 /* expand for UI */
340         CONSTRAINT_EXPAND =             (1<<0), 
341                 /* pre-check for illegal object name or bone name */
342         CONSTRAINT_DISABLE =    (1<<2), 
343                 /* to indicate which Ipo should be shown, maybe for 3d access later too */      
344         CONSTRAINT_ACTIVE =     (1<<4), 
345                 /* to indicate that the owner's space should only be changed into ownspace, but not out of it */
346         CONSTRAINT_SPACEONCE =  (1<<6)  
347 } B_CONSTRAINT_FLAG;
348
349 /* bConstraint->ownspace/tarspace */
350 typedef enum B_CONSTRAINT_SPACETYPES {
351                 /* default for all - worldspace */
352         CONSTRAINT_SPACE_WORLD = 0,
353                 /* for objects (relative to parent/without parent influence), 
354                  * for bones (along normals of bone, without parent/restpositions) 
355                  */
356         CONSTRAINT_SPACE_LOCAL,
357                 /* for posechannels - pose space  */
358         CONSTRAINT_SPACE_POSE,
359                 /* for posechannels - local with parent  */
360         CONSTRAINT_SPACE_PARLOCAL,
361 } B_CONSTRAINT_SPACETYPES;
362
363 /* bConstraintChannel.flag */
364 typedef enum B_CONSTRAINTCHANNEL_FLAG {
365         CONSTRAINT_CHANNEL_SELECT =             (1<<0),
366         CONSTRAINT_CHANNEL_PROTECTED =  (1<<1)
367 } B_CONSTRAINTCHANNEL_FLAG;
368
369 /* -------------------------------------- */
370
371 /**
372  * The flags for ROTLIKE, LOCLIKE and SIZELIKE should be kept identical
373  * (that is, same effect, different name). It simplifies the Python API access a lot.
374  */
375
376 /* bRotateLikeConstraint.flag */
377 #define ROTLIKE_X               0x01
378 #define ROTLIKE_Y               0x02
379 #define ROTLIKE_Z               0x04
380 #define ROTLIKE_X_INVERT        0x10
381 #define ROTLIKE_Y_INVERT        0x20
382 #define ROTLIKE_Z_INVERT        0x40
383 #define ROTLIKE_OFFSET  0x80
384
385 /* bLocateLikeConstraint.flag */
386 #define LOCLIKE_X                       0x01
387 #define LOCLIKE_Y                       0x02
388 #define LOCLIKE_Z                       0x04
389 #define LOCLIKE_TIP                     0x08
390 #define LOCLIKE_X_INVERT        0x10
391 #define LOCLIKE_Y_INVERT        0x20
392 #define LOCLIKE_Z_INVERT        0x40
393 #define LOCLIKE_OFFSET          0x80
394  
395 /* bSizeLikeConstraint.flag */
396 #define SIZELIKE_X              0x01
397 #define SIZELIKE_Y              0x02
398 #define SIZELIKE_Z              0x04
399 #define SIZELIKE_OFFSET 0x80
400
401 /* Axis flags */
402 #define LOCK_X          0x00
403 #define LOCK_Y          0x01
404 #define LOCK_Z          0x02
405
406 #define UP_X            0x00
407 #define UP_Y            0x01
408 #define UP_Z            0x02
409
410 #define TRACK_X         0x00
411 #define TRACK_Y         0x01
412 #define TRACK_Z         0x02
413 #define TRACK_nX        0x03
414 #define TRACK_nY        0x04
415 #define TRACK_nZ        0x05
416
417 /* bTrackToConstraint->flags */
418 #define TARGET_Z_UP 0x01
419
420 #define VOLUME_XZ       0x00
421 #define VOLUME_X        0x01
422 #define VOLUME_Z        0x02
423 #define NO_VOLUME       0x03
424
425 #define PLANE_X         0x00
426 #define PLANE_Y         0x01
427 #define PLANE_Z         0x02
428
429 /* Clamp-To Constraint ->flag */
430 #define CLAMPTO_AUTO    0
431 #define CLAMPTO_X               1
432 #define CLAMPTO_Y               2
433 #define CLAMPTO_Z               3
434
435 /* ClampTo Constraint ->flag2 */
436 #define CLAMPTO_CYCLIC  1
437
438 /* bKinematicConstraint->flag */
439 #define CONSTRAINT_IK_TIP               1
440 #define CONSTRAINT_IK_ROT               2
441 #define CONSTRAINT_IK_AUTO              4
442 #define CONSTRAINT_IK_TEMP              8
443 #define CONSTRAINT_IK_STRETCH   16
444 #define CONSTRAINT_IK_POS               32
445 #define CONSTRAINT_IK_SETANGLE  64
446 #define CONSTRAINT_IK_GETANGLE  128
447
448 /* MinMax (floor) flags */
449 #define MINMAX_STICKY   0x01
450 #define MINMAX_STUCK    0x02
451 #define MINMAX_USEROT   0x04
452
453 /* transform limiting constraints -> flag  */
454 #define LIMIT_XMIN 0x01
455 #define LIMIT_XMAX 0x02
456 #define LIMIT_YMIN 0x04
457 #define LIMIT_YMAX 0x08
458 #define LIMIT_ZMIN 0x10
459 #define LIMIT_ZMAX 0x20
460
461 #define LIMIT_XROT 0x01
462 #define LIMIT_YROT 0x02
463 #define LIMIT_ZROT 0x04
464
465 /* not used anymore - for older Limit Location constraints only */
466 #define LIMIT_NOPARENT 0x01
467
468 /* python constraint -> flag */
469 #define PYCON_USETARGETS        0x01
470 #define PYCON_SCRIPTERROR       0x02
471
472 /* ChildOf Constraint -> flag */
473 #define CHILDOF_LOCX    0x001
474 #define CHILDOF_LOCY    0x002
475 #define CHILDOF_LOCZ    0x004
476 #define CHILDOF_ROTX    0x008
477 #define CHILDOF_ROTY    0x010
478 #define CHILDOF_ROTZ    0x020
479 #define CHILDOF_SIZEX   0x040
480 #define CHILDOF_SIZEY   0x080
481 #define CHILDOF_SIZEZ   0x100
482
483 /* Rigid-Body Constraint */
484 #define CONSTRAINT_DRAW_PIVOT 0x40
485
486 /* important: these defines need to match up with PHY_DynamicTypes headerfile */
487 #define CONSTRAINT_RB_BALL              1
488 #define CONSTRAINT_RB_HINGE             2
489 #define CONSTRAINT_RB_CONETWIST 4
490 #define CONSTRAINT_RB_VEHICLE   11
491 #define CONSTRAINT_RB_GENERIC6DOF 12
492
493 #endif