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