2.5
[blender-staging.git] / source / blender / makesdna / DNA_modifier_types.h
1 /**
2  * $Id$ 
3  */
4
5 #ifndef DNA_MODIFIER_TYPES_H
6 #define DNA_MODIFIER_TYPES_H
7
8 #define MODSTACK_DEBUG 1
9
10 /* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE! */
11
12 typedef enum ModifierType {
13         eModifierType_None = 0,
14         eModifierType_Subsurf,
15         eModifierType_Lattice,
16         eModifierType_Curve,
17         eModifierType_Build,
18         eModifierType_Mirror,
19         eModifierType_Decimate,
20         eModifierType_Wave,
21         eModifierType_Armature,
22         eModifierType_Hook,
23         eModifierType_Softbody,
24         eModifierType_Boolean,
25         eModifierType_Array,
26         eModifierType_EdgeSplit,
27         eModifierType_Displace,
28         eModifierType_UVProject,
29         eModifierType_Smooth,
30         eModifierType_Cast,
31         eModifierType_MeshDeform,
32         eModifierType_ParticleSystem,
33         eModifierType_ParticleInstance,
34         eModifierType_Explode,
35         eModifierType_Cloth,
36         eModifierType_Collision,
37         eModifierType_Bevel,
38         eModifierType_Shrinkwrap,
39         eModifierType_Fluidsim,
40         eModifierType_Mask,
41         eModifierType_SimpleDeform,
42         NUM_MODIFIER_TYPES
43 } ModifierType;
44
45 typedef enum ModifierMode {
46         eModifierMode_Realtime = (1<<0),
47         eModifierMode_Render = (1<<1),
48         eModifierMode_Editmode = (1<<2),
49         eModifierMode_OnCage = (1<<3),
50         eModifierMode_Expanded = (1<<4),
51         eModifierMode_Virtual = (1<<5),
52         eModifierMode_DisableTemporary = (1 << 31)
53 } ModifierMode;
54
55 typedef struct ModifierData {
56         struct ModifierData *next, *prev;
57
58         int type, mode;
59         char name[32];
60         
61         /* XXX for timing info set by caller... solve later? (ton) */
62         struct Scene *scene;
63         
64         char *error;
65 } ModifierData;
66
67 typedef enum {
68         eSubsurfModifierFlag_Incremental = (1<<0),
69         eSubsurfModifierFlag_DebugIncr = (1<<1),
70         eSubsurfModifierFlag_ControlEdges = (1<<2),
71         eSubsurfModifierFlag_SubsurfUv = (1<<3)
72 } SubsurfModifierFlag;
73
74 typedef struct SubsurfModifierData {
75         ModifierData modifier;
76
77         short subdivType, levels, renderLevels, flags;
78
79         void *emCache, *mCache;
80 } SubsurfModifierData;
81
82 typedef struct LatticeModifierData {
83         ModifierData modifier;
84
85         struct Object *object;
86         char name[32];                  /* optional vertexgroup name */
87 } LatticeModifierData;
88
89 typedef struct CurveModifierData {
90         ModifierData modifier;
91
92         struct Object *object;
93         char name[32];                  /* optional vertexgroup name */
94         short defaxis;                  /* axis along which curve deforms */
95         char pad[6];
96 } CurveModifierData;
97
98 /* CurveModifierData->defaxis */
99 #define MOD_CURVE_POSX  1
100 #define MOD_CURVE_POSY  2
101 #define MOD_CURVE_POSZ  3
102 #define MOD_CURVE_NEGX  4
103 #define MOD_CURVE_NEGY  5
104 #define MOD_CURVE_NEGZ  6
105
106 typedef struct BuildModifierData {
107         ModifierData modifier;
108
109         float start, length;
110         int randomize, seed;
111 } BuildModifierData;
112
113 /* Mask Modifier */
114 typedef struct MaskModifierData {
115         ModifierData modifier;
116         
117         struct Object *ob_arm;  /* armature to use to in place of hardcoded vgroup */
118         char vgroup[32];                /* name of vertex group to use to mask */
119         
120         int mode;                               /* using armature or hardcoded vgroup */
121         int flag;                               /* flags for various things */
122 } MaskModifierData;
123
124 /* Mask Modifier -> mode */
125 #define MOD_MASK_MODE_VGROUP            0
126 #define MOD_MASK_MODE_ARM                       1
127
128 /* Mask Modifier -> flag */
129 #define MOD_MASK_INV                    (1<<0)
130
131 typedef struct ArrayModifierData {
132         ModifierData modifier;
133
134         /* the object with which to cap the start of the array  */
135         struct Object *start_cap;
136         /* the object with which to cap the end of the array  */
137         struct Object *end_cap;
138         /* the curve object to use for MOD_ARR_FITCURVE */
139         struct Object *curve_ob;
140         /* the object to use for object offset */
141         struct Object *offset_ob;
142         /* a constant duplicate offset;
143            1 means the duplicates are 1 unit apart
144     */
145         float offset[3];
146         /* a scaled factor for duplicate offsets;
147            1 means the duplicates are 1 object-width apart
148     */
149         float scale[3];
150         /* the length over which to distribute the duplicates */
151         float length;
152         /* the limit below which to merge vertices in adjacent duplicates */
153         float merge_dist;
154         /* determines how duplicate count is calculated; one of:
155               MOD_ARR_FIXEDCOUNT -> fixed
156               MOD_ARR_FITLENGTH  -> calculated to fit a set length
157               MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
158     */
159         int fit_type;
160         /* flags specifying how total offset is calculated; binary OR of:
161              MOD_ARR_OFF_CONST    -> total offset += offset
162              MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
163              MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
164            total offset is the sum of the individual enabled offsets
165         */
166         int offset_type;
167         /* general flags:
168               MOD_ARR_MERGE -> merge vertices in adjacent duplicates
169         */
170         int flags;
171         /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */
172         int count;
173 } ArrayModifierData;
174
175 /* ArrayModifierData->fit_type */
176 #define MOD_ARR_FIXEDCOUNT 0
177 #define MOD_ARR_FITLENGTH  1
178 #define MOD_ARR_FITCURVE   2
179
180 /* ArrayModifierData->offset_type */
181 #define MOD_ARR_OFF_CONST    1<<0
182 #define MOD_ARR_OFF_RELATIVE 1<<1
183 #define MOD_ARR_OFF_OBJ      1<<2
184
185 /* ArrayModifierData->flags */
186 #define MOD_ARR_MERGE      1<<0
187 #define MOD_ARR_MERGEFINAL 1<<1
188
189 typedef struct MirrorModifierData {
190         ModifierData modifier;
191
192         short axis, flag;
193         float tolerance;
194         struct Object *mirror_ob;
195 } MirrorModifierData;
196
197 /* MirrorModifierData->flag */
198 #define MOD_MIR_CLIPPING        1<<0
199 #define MOD_MIR_MIRROR_U        1<<1
200 #define MOD_MIR_MIRROR_V        1<<2
201 #define MOD_MIR_AXIS_X          1<<3
202 #define MOD_MIR_AXIS_Y          1<<4
203 #define MOD_MIR_AXIS_Z          1<<5
204 #define MOD_MIR_VGROUP          1<<6
205
206 typedef struct EdgeSplitModifierData {
207         ModifierData modifier;
208
209         float split_angle;    /* angle above which edges should be split */
210         int flags;
211 } EdgeSplitModifierData;
212
213 /* EdgeSplitModifierData->flags */
214 #define MOD_EDGESPLIT_FROMANGLE   1<<1
215 #define MOD_EDGESPLIT_FROMFLAG    1<<2
216
217 typedef struct BevelModifierData {
218         ModifierData modifier;
219
220         float value;          /* the "raw" bevel value (distance/amount to bevel) */
221         int res;              /* the resolution (as originally coded, it is the number of recursive bevels) */
222         int pad;
223         short flags;          /* general option flags */
224         short val_flags;      /* flags used to interpret the bevel value */
225         short lim_flags;      /* flags to tell the tool how to limit the bevel */
226         short e_flags;        /* flags to direct how edge weights are applied to verts */
227         float bevel_angle;    /* if the BME_BEVEL_ANGLE is set, this will be how "sharp" an edge must be before it gets beveled */
228         char defgrp_name[32]; /* if the BME_BEVEL_VWEIGHT option is set, this will be the name of the vert group */
229 } BevelModifierData;
230
231 typedef struct BMeshModifierData {
232         ModifierData modifier;
233
234         float pad;
235         int type;
236 } BMeshModifierData;
237
238 typedef struct DisplaceModifierData {
239         ModifierData modifier;
240
241         struct Tex *texture;
242         float strength;
243         int direction;
244         char defgrp_name[32];
245         float midlevel;
246         int texmapping;
247         struct Object *map_object;
248         char uvlayer_name[32];
249         int uvlayer_tmp, pad;
250 } DisplaceModifierData;
251
252 /* DisplaceModifierData->direction */
253 enum {
254         MOD_DISP_DIR_X,
255         MOD_DISP_DIR_Y,
256         MOD_DISP_DIR_Z,
257         MOD_DISP_DIR_NOR,
258         MOD_DISP_DIR_RGB_XYZ,
259 };
260
261 /* DisplaceModifierData->texmapping */
262 enum {
263         MOD_DISP_MAP_LOCAL,
264         MOD_DISP_MAP_GLOBAL,
265         MOD_DISP_MAP_OBJECT,
266         MOD_DISP_MAP_UV,
267 };
268
269 typedef struct UVProjectModifierData {
270         ModifierData modifier;
271
272         /* the objects which do the projecting */
273         struct Object *projectors[10];
274         struct Image *image;      /* the image to project */
275         int flags;
276         int num_projectors;
277         float aspectx, aspecty;
278         char uvlayer_name[32];
279         int uvlayer_tmp, pad;
280 } UVProjectModifierData;
281
282 #define MOD_UVPROJECT_MAXPROJECTORS 10
283
284 /* UVProjectModifierData->flags */
285 #define MOD_UVPROJECT_OVERRIDEIMAGE 1<<0
286
287 typedef struct DecimateModifierData {
288         ModifierData modifier;
289
290         float percent;
291         int faceCount;
292 } DecimateModifierData;
293
294 /* Smooth modifier flags */
295 #define MOD_SMOOTH_X (1<<1)
296 #define MOD_SMOOTH_Y (1<<2)
297 #define MOD_SMOOTH_Z (1<<3)
298
299 typedef struct SmoothModifierData {
300         ModifierData modifier;
301         float fac;
302         char defgrp_name[32];
303         short flag, repeat;
304
305 } SmoothModifierData;
306
307 /* Cast modifier flags */
308 #define MOD_CAST_X (1<<1)
309 #define MOD_CAST_Y (1<<2)
310 #define MOD_CAST_Z (1<<3)
311 #define MOD_CAST_USE_OB_TRANSFORM (1<<4)
312 #define MOD_CAST_SIZE_FROM_RADIUS (1<<5)
313
314 /* Cast modifier projection types */
315 #define MOD_CAST_TYPE_SPHERE 0
316 #define MOD_CAST_TYPE_CYLINDER 1
317 #define MOD_CAST_TYPE_CUBOID 2
318
319 typedef struct CastModifierData {
320         ModifierData modifier;
321
322         struct Object *object;
323         float fac;
324         float radius;
325         float size;
326         char defgrp_name[32];
327         short flag, type;
328 } CastModifierData;
329
330 enum {
331         MOD_WAV_MAP_LOCAL,
332         MOD_WAV_MAP_GLOBAL,
333         MOD_WAV_MAP_OBJECT,
334         MOD_WAV_MAP_UV,
335 };
336
337 /* WaveModifierData.flag */
338 #define MOD_WAVE_X      1<<1
339 #define MOD_WAVE_Y      1<<2
340 #define MOD_WAVE_CYCL   1<<3
341 #define MOD_WAVE_NORM   1<<4
342 #define MOD_WAVE_NORM_X 1<<5
343 #define MOD_WAVE_NORM_Y 1<<6
344 #define MOD_WAVE_NORM_Z 1<<7
345
346 typedef struct WaveModifierData {
347         ModifierData modifier;
348
349         struct Object *objectcenter;
350         char defgrp_name[32];
351         struct Tex *texture;
352         struct Object *map_object;
353
354         short flag, pad;
355
356         float startx, starty, height, width;
357         float narrow, speed, damp, falloff;
358
359         int texmapping, uvlayer_tmp;
360
361         char uvlayer_name[32];
362
363         float timeoffs, lifetime;
364         float pad1;
365 } WaveModifierData;
366
367 typedef struct ArmatureModifierData {
368         ModifierData modifier;
369
370         short deformflag, multi;                /* deformflag replaces armature->deformflag */
371         int pad2;
372         struct Object *object;
373         float *prevCos;         /* stored input of previous modifier, for vertexgroup blending */
374         char defgrp_name[32];
375 } ArmatureModifierData;
376
377 typedef struct HookModifierData {
378         ModifierData modifier;
379
380         struct Object *object;
381         float parentinv[4][4];  /* matrix making current transform unmodified */
382         float cent[3];                  /* visualization of hook */
383         float falloff;                  /* if not zero, falloff is distance where influence zero */
384         
385         int *indexar;                   /* if NULL, it's using vertexgroup */
386         int totindex;
387         float force;
388         char name[32];                  /* optional vertexgroup name */
389 } HookModifierData;
390
391 typedef struct SoftbodyModifierData {
392         ModifierData modifier;
393 } SoftbodyModifierData;
394
395 typedef struct ClothModifierData {
396         ModifierData            modifier;
397
398         struct Scene *scene;                    /* the context, time etc is here */
399         struct Cloth *clothObject;              /* The internal data structure for cloth. */
400         struct ClothSimSettings *sim_parms; /* definition is in DNA_cloth_types.h */
401         struct ClothCollSettings *coll_parms; /* definition is in DNA_cloth_types.h */
402         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
403 } ClothModifierData;
404
405 typedef struct CollisionModifierData {
406         ModifierData    modifier;
407         
408         struct MVert *x; /* position at the beginning of the frame */
409         struct MVert *xnew; /* position at the end of the frame */
410         struct MVert *xold; /* unsued atm, but was discussed during sprint */
411         struct MVert *current_xnew; /* new position at the actual inter-frame step */
412         struct MVert *current_x; /* position at the actual inter-frame step */
413         struct MVert *current_v; /* (xnew - x) at the actual inter-frame step */
414         
415         struct MFace *mfaces; /* object face data */
416         
417         unsigned int numverts;
418         unsigned int numfaces;
419         short absorption; /* used for forces, in % */
420         short pad;
421         float time;             /* cfra time of modifier */
422         struct BVHTree *bvhtree; /* bounding volume hierarchy for this cloth object */
423 } CollisionModifierData;
424
425 typedef enum {
426         eBooleanModifierOp_Intersect,
427         eBooleanModifierOp_Union,
428         eBooleanModifierOp_Difference,
429 } BooleanModifierOp;
430 typedef struct BooleanModifierData {
431         ModifierData modifier;
432
433         struct Object *object;
434         int operation, pad;
435 } BooleanModifierData;
436
437 #define MOD_MDEF_INVERT_VGROUP (1<<0)
438 #define MOD_MDEF_DYNAMIC_BIND  (1<<1)
439
440 typedef struct MDefInfluence {
441         int vertex;
442         float weight;
443 } MDefInfluence;
444
445 typedef struct MDefCell {
446         int offset;
447         int totinfluence;
448 } MDefCell;
449
450 typedef struct MeshDeformModifierData {
451         ModifierData modifier;
452
453         struct Object *object;                  /* mesh object */
454         char defgrp_name[32];                   /* optional vertexgroup name */
455
456         short gridsize, needbind;
457         short flag, pad;
458
459         /* variables filled in when bound */
460         float *bindweights, *bindcos;   /* computed binding weights */
461         int totvert, totcagevert;               /* total vertices in mesh and cage */
462         MDefCell *dyngrid;                              /* grid with dynamic binding cell points */
463         MDefInfluence *dyninfluences;   /* dynamic binding vertex influences */
464         int *dynverts, *pad2;                   /* is this vertex bound or not? */
465         int dyngridsize;                                /* size of the dynamic bind grid */
466         int totinfluence;                               /* total number of vertex influences */
467         float dyncellmin[3];                    /* offset of the dynamic bind grid */
468         float dyncellwidth;                             /* width of dynamic bind cell */
469         float bindmat[4][4];                    /* matrix of cage at binding time */
470 } MeshDeformModifierData;
471
472 typedef enum {
473         eParticleSystemFlag_Loaded =            (1<<0),
474         eParticleSystemFlag_Pars =                      (1<<1),
475         eParticleSystemFlag_FromCurve =         (1<<2),
476         eParticleSystemFlag_DM_changed =        (1<<3),
477         eParticleSystemFlag_Disabled =          (1<<4),
478         eParticleSystemFlag_psys_updated =      (1<<5),
479 } ParticleSystemModifierFlag;
480
481 typedef struct ParticleSystemModifierData {
482         ModifierData modifier;
483         struct ParticleSystem *psys;
484         struct DerivedMesh *dm;
485         int totdmvert, totdmedge, totdmface;
486         short flag, rt;
487 } ParticleSystemModifierData;
488
489 typedef enum {
490         eParticleInstanceFlag_Parents =         (1<<0),
491         eParticleInstanceFlag_Children =        (1<<1),
492         eParticleInstanceFlag_Path =            (1<<2),
493         eParticleInstanceFlag_Unborn =          (1<<3),
494         eParticleInstanceFlag_Alive =           (1<<4),
495         eParticleInstanceFlag_Dead =            (1<<5),
496 } ParticleInstanceModifierFlag;
497
498 typedef struct ParticleInstanceModifierData {
499         ModifierData modifier;
500         struct Object *ob;
501         short psys, flag, rt[2];
502 } ParticleInstanceModifierData;
503
504 typedef enum {
505         eExplodeFlag_CalcFaces =        (1<<0),
506         //eExplodeFlag_PaSize =         (1<<1),
507         eExplodeFlag_EdgeSplit =        (1<<2),
508         eExplodeFlag_Unborn =           (1<<3),
509         eExplodeFlag_Alive =            (1<<4),
510         eExplodeFlag_Dead =                     (1<<5),
511 } ExplodeModifierFlag;
512
513 typedef struct ExplodeModifierData {
514         ModifierData modifier;
515         int *facepa;
516         short flag, vgroup;
517         float protect;
518 } ExplodeModifierData;
519
520 typedef struct FluidsimModifierData {
521         ModifierData modifier;
522         
523         struct FluidsimSettings *fss; /* definition is is DNA_object_fluidsim.h */
524         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
525 } FluidsimModifierData;
526
527 typedef struct ShrinkwrapModifierData {
528         ModifierData modifier;
529
530         struct Object *target;  /* shrink target */
531         struct Object *auxTarget; /* additional shrink target */
532         char vgroup_name[32];   /* optional vertexgroup name */
533         float keepDist;                 /* distance offset to keep from mesh/projection point */
534         short shrinkType;               /* shrink type projection */
535         short shrinkOpts;               /* shrink options */
536         char projAxis;                  /* axis to project over */
537
538         /*
539          * if using projection over vertex normal this controls the
540          * the level of subsurface that must be done before getting the
541          * vertex coordinates and normal
542          */
543         char subsurfLevels;
544
545         char pad[6];
546
547 } ShrinkwrapModifierData;
548
549 /* Shrinkwrap->shrinkType */
550 #define MOD_SHRINKWRAP_NEAREST_SURFACE  0
551 #define MOD_SHRINKWRAP_PROJECT                  1
552 #define MOD_SHRINKWRAP_NEAREST_VERTEX   2
553
554 /* Shrinkwrap->shrinkOpts */
555 #define MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR    (1<<0)  /* allow shrinkwrap to move the vertex in the positive direction of axis */
556 #define MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR    (1<<1)  /* allow shrinkwrap to move the vertex in the negative direction of axis */
557
558 #define MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE    (1<<3)  /* ignore vertex moves if a vertex ends projected on a front face of the target */
559 #define MOD_SHRINKWRAP_CULL_TARGET_BACKFACE             (1<<4)  /* ignore vertex moves if a vertex ends projected on a back face of the target */
560
561 #define MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE               (1<<5)  /* distance is measure to the front face of the target */
562
563 #define MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS              (1<<0)
564 #define MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS              (1<<1)
565 #define MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS              (1<<2)
566 #define MOD_SHRINKWRAP_PROJECT_OVER_NORMAL                      0       /* projection over normal is used if no axis is selected */
567
568
569 typedef struct SimpleDeformModifierData {
570         ModifierData modifier;
571
572         struct Object *origin;  /* object to control the origin of modifier space coordinates */
573         char vgroup_name[32];   /* optional vertexgroup name */
574         float factor;                   /* factors to control simple deforms */
575         float limit[2];                 /* lower and upper limit */             
576
577         char mode;                              /* deform function */
578         char axis;                              /* lock axis (for taper and strech) */
579         char originOpts;                /* originOptions */
580         char pad;
581
582 } SimpleDeformModifierData;
583
584 #define MOD_SIMPLEDEFORM_MODE_TWIST             1
585 #define MOD_SIMPLEDEFORM_MODE_BEND              2
586 #define MOD_SIMPLEDEFORM_MODE_TAPER             3
587 #define MOD_SIMPLEDEFORM_MODE_STRETCH   4
588
589 #define MOD_SIMPLEDEFORM_LOCK_AXIS_X                    (1<<0)
590 #define MOD_SIMPLEDEFORM_LOCK_AXIS_Y                    (1<<1)
591
592 /* indicates whether simple deform should use the local
593    coordinates or global coordinates of origin */
594 #define MOD_SIMPLEDEFORM_ORIGIN_LOCAL                   (1<<0)
595
596 #endif