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