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