move NavMesh draw code out of being a modifier and into DerivedMesh drawing hack...
[blender.git] / source / blender / makesdna / DNA_modifier_types.h
1 /*
2  * $Id$ 
3  *
4  * ***** BEGIN GPL 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.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 #ifndef DNA_MODIFIER_TYPES_H
24 #define DNA_MODIFIER_TYPES_H
25
26 /** \file DNA_modifier_types.h
27  *  \ingroup DNA
28  */
29
30 #include "DNA_listBase.h"
31
32
33 #define MODSTACK_DEBUG 1
34
35 /* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE! */
36
37 typedef enum ModifierType {
38         eModifierType_None = 0,
39         eModifierType_Subsurf,
40         eModifierType_Lattice,
41         eModifierType_Curve,
42         eModifierType_Build,
43         eModifierType_Mirror,
44         eModifierType_Decimate,
45         eModifierType_Wave,
46         eModifierType_Armature,
47         eModifierType_Hook,
48         eModifierType_Softbody,
49         eModifierType_Boolean,
50         eModifierType_Array,
51         eModifierType_EdgeSplit,
52         eModifierType_Displace,
53         eModifierType_UVProject,
54         eModifierType_Smooth,
55         eModifierType_Cast,
56         eModifierType_MeshDeform,
57         eModifierType_ParticleSystem,
58         eModifierType_ParticleInstance,
59         eModifierType_Explode,
60         eModifierType_Cloth,
61         eModifierType_Collision,
62         eModifierType_Bevel,
63         eModifierType_Shrinkwrap,
64         eModifierType_Fluidsim,
65         eModifierType_Mask,
66         eModifierType_SimpleDeform,
67         eModifierType_Multires,
68         eModifierType_Surface,
69         eModifierType_Smoke,
70         eModifierType_ShapeKey,
71         eModifierType_Solidify,
72         eModifierType_Screw,
73         eModifierType_Warp,
74         eModifierType_WeightVGEdit,
75         eModifierType_WeightVGMix,
76         eModifierType_WeightVGProximity,
77         eModifierType_DynamicPaint, /* reserve slot */
78         NUM_MODIFIER_TYPES
79 } ModifierType;
80
81 typedef enum ModifierMode {
82         eModifierMode_Realtime = (1<<0),
83         eModifierMode_Render = (1<<1),
84         eModifierMode_Editmode = (1<<2),
85         eModifierMode_OnCage = (1<<3),
86         eModifierMode_Expanded = (1<<4),
87         eModifierMode_Virtual = (1<<5),
88         eModifierMode_ApplyOnSpline = (1<<6),
89         eModifierMode_DisableTemporary = (1 << 31)
90 } ModifierMode;
91
92 typedef struct ModifierData {
93         struct ModifierData *next, *prev;
94
95         int type, mode;
96         int stackindex, pad;
97         char name[32];
98         
99         /* XXX for timing info set by caller... solve later? (ton) */
100         struct Scene *scene;
101         
102         char *error;
103 } ModifierData;
104
105 typedef enum {
106         eSubsurfModifierFlag_Incremental = (1<<0),
107         eSubsurfModifierFlag_DebugIncr = (1<<1),
108         eSubsurfModifierFlag_ControlEdges = (1<<2),
109         eSubsurfModifierFlag_SubsurfUv = (1<<3)
110 } SubsurfModifierFlag;
111
112 /* not a real modifier */
113 typedef struct MappingInfoModifierData {
114         ModifierData modifier;
115
116         struct Tex *texture;
117         struct Object *map_object;
118         char uvlayer_name[32];
119         int uvlayer_tmp;
120         int texmapping;
121 } MappingInfoModifierData;
122
123 typedef struct SubsurfModifierData {
124         ModifierData modifier;
125
126         short subdivType, levels, renderLevels, flags;
127
128         void *emCache, *mCache;
129 } SubsurfModifierData;
130
131 typedef struct LatticeModifierData {
132         ModifierData modifier;
133
134         struct Object *object;
135         char name[32];                  /* optional vertexgroup name */
136 } LatticeModifierData;
137
138 typedef struct CurveModifierData {
139         ModifierData modifier;
140
141         struct Object *object;
142         char name[32];                  /* optional vertexgroup name */
143         short defaxis;                  /* axis along which curve deforms */
144         char pad[6];
145 } CurveModifierData;
146
147 /* CurveModifierData->defaxis */
148 #define MOD_CURVE_POSX  1
149 #define MOD_CURVE_POSY  2
150 #define MOD_CURVE_POSZ  3
151 #define MOD_CURVE_NEGX  4
152 #define MOD_CURVE_NEGY  5
153 #define MOD_CURVE_NEGZ  6
154
155 typedef struct BuildModifierData {
156         ModifierData modifier;
157
158         float start, length;
159         int randomize, seed;
160 } BuildModifierData;
161
162 /* Mask Modifier */
163 typedef struct MaskModifierData {
164         ModifierData modifier;
165         
166         struct Object *ob_arm;  /* armature to use to in place of hardcoded vgroup */
167         char vgroup[32];                /* name of vertex group to use to mask */
168         
169         int mode;                               /* using armature or hardcoded vgroup */
170         int flag;                               /* flags for various things */
171 } MaskModifierData;
172
173 /* Mask Modifier -> mode */
174 #define MOD_MASK_MODE_VGROUP            0
175 #define MOD_MASK_MODE_ARM                       1
176
177 /* Mask Modifier -> flag */
178 #define MOD_MASK_INV                    (1<<0)
179
180 typedef struct ArrayModifierData {
181         ModifierData modifier;
182
183         /* the object with which to cap the start of the array  */
184         struct Object *start_cap;
185         /* the object with which to cap the end of the array  */
186         struct Object *end_cap;
187         /* the curve object to use for MOD_ARR_FITCURVE */
188         struct Object *curve_ob;
189         /* the object to use for object offset */
190         struct Object *offset_ob;
191         /* a constant duplicate offset;
192            1 means the duplicates are 1 unit apart
193         */
194         float offset[3];
195         /* a scaled factor for duplicate offsets;
196            1 means the duplicates are 1 object-width apart
197         */
198         float scale[3];
199         /* the length over which to distribute the duplicates */
200         float length;
201         /* the limit below which to merge vertices in adjacent duplicates */
202         float merge_dist;
203         /* determines how duplicate count is calculated; one of:
204                   MOD_ARR_FIXEDCOUNT -> fixed
205                   MOD_ARR_FITLENGTH  -> calculated to fit a set length
206                   MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
207         */
208         int fit_type;
209         /* flags specifying how total offset is calculated; binary OR of:
210                  MOD_ARR_OFF_CONST    -> total offset += offset
211                  MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
212                  MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
213            total offset is the sum of the individual enabled offsets
214         */
215         int offset_type;
216         /* general flags:
217                   MOD_ARR_MERGE -> merge vertices in adjacent duplicates
218         */
219         int flags;
220         /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */
221         int count;
222 } ArrayModifierData;
223
224 /* ArrayModifierData->fit_type */
225 #define MOD_ARR_FIXEDCOUNT 0
226 #define MOD_ARR_FITLENGTH  1
227 #define MOD_ARR_FITCURVE   2
228
229 /* ArrayModifierData->offset_type */
230 #define MOD_ARR_OFF_CONST    (1<<0)
231 #define MOD_ARR_OFF_RELATIVE (1<<1)
232 #define MOD_ARR_OFF_OBJ      (1<<2)
233
234 /* ArrayModifierData->flags */
235 #define MOD_ARR_MERGE      (1<<0)
236 #define MOD_ARR_MERGEFINAL (1<<1)
237
238 typedef struct MirrorModifierData {
239         ModifierData modifier;
240
241         short axis; /* deprecated, use flag instead */
242         short flag;
243         float tolerance;
244         struct Object *mirror_ob;
245 } MirrorModifierData;
246
247 /* MirrorModifierData->flag */
248 #define MOD_MIR_CLIPPING        (1<<0)
249 #define MOD_MIR_MIRROR_U        (1<<1)
250 #define MOD_MIR_MIRROR_V        (1<<2)
251 #define MOD_MIR_AXIS_X          (1<<3)
252 #define MOD_MIR_AXIS_Y          (1<<4)
253 #define MOD_MIR_AXIS_Z          (1<<5)
254 #define MOD_MIR_VGROUP          (1<<6)
255 #define MOD_MIR_NO_MERGE        (1<<7)
256
257 typedef struct EdgeSplitModifierData {
258         ModifierData modifier;
259
260         float split_angle;    /* angle above which edges should be split */
261         int flags;
262 } EdgeSplitModifierData;
263
264 /* EdgeSplitModifierData->flags */
265 #define MOD_EDGESPLIT_FROMANGLE   (1<<1)
266 #define MOD_EDGESPLIT_FROMFLAG    (1<<2)
267
268 typedef struct BevelModifierData {
269         ModifierData modifier;
270
271         float value;          /* the "raw" bevel value (distance/amount to bevel) */
272         int res;              /* the resolution (as originally coded, it is the number of recursive bevels) */
273         int pad;
274         short flags;          /* general option flags */
275         short val_flags;      /* flags used to interpret the bevel value */
276         short lim_flags;      /* flags to tell the tool how to limit the bevel */
277         short e_flags;        /* flags to direct how edge weights are applied to verts */
278         float bevel_angle;    /* if the BME_BEVEL_ANGLE is set, this will be how "sharp" an edge must be before it gets beveled */
279         char defgrp_name[32]; /* if the BME_BEVEL_VWEIGHT option is set, this will be the name of the vert group */
280 } BevelModifierData;
281
282 typedef struct BMeshModifierData {
283         ModifierData modifier;
284
285         float pad;
286         int type;
287 } BMeshModifierData;
288
289
290 /* Smoke modifier flags */
291 #define MOD_SMOKE_TYPE_DOMAIN (1 << 0)
292 #define MOD_SMOKE_TYPE_FLOW (1 << 1)
293 #define MOD_SMOKE_TYPE_COLL (1 << 2)
294
295 typedef struct SmokeModifierData {
296         ModifierData modifier;
297
298         struct SmokeDomainSettings *domain;
299         struct SmokeFlowSettings *flow; /* inflow, outflow, smoke objects */
300         struct SmokeCollSettings *coll; /* collision objects */
301         float time;
302         int type;  /* domain, inflow, outflow, ... */
303 } SmokeModifierData;
304
305 typedef struct DisplaceModifierData {
306         ModifierData modifier;
307
308         /* keep in sync with MappingInfoModifierData */
309         struct Tex *texture;
310         struct Object *map_object;
311         char uvlayer_name[32];
312         int uvlayer_tmp;
313         int texmapping;
314         int pad10;
315         /* end MappingInfoModifierData */
316
317         float strength;
318         int direction;
319         char defgrp_name[32];
320         float midlevel;
321 } DisplaceModifierData;
322
323 /* DisplaceModifierData->direction */
324 enum {
325         MOD_DISP_DIR_X,
326         MOD_DISP_DIR_Y,
327         MOD_DISP_DIR_Z,
328         MOD_DISP_DIR_NOR,
329         MOD_DISP_DIR_RGB_XYZ,
330 };
331
332 /* DisplaceModifierData->texmapping */
333 enum {
334         MOD_DISP_MAP_LOCAL,
335         MOD_DISP_MAP_GLOBAL,
336         MOD_DISP_MAP_OBJECT,
337         MOD_DISP_MAP_UV,
338 };
339
340 typedef struct UVProjectModifierData {
341         ModifierData modifier;
342
343         /* the objects which do the projecting */
344         struct Object *projectors[10]; /* MOD_UVPROJECT_MAX */
345         struct Image *image;      /* the image to project */
346         int flags;
347         int num_projectors;
348         float aspectx, aspecty;
349         float scalex, scaley;                                                                                           
350         char uvlayer_name[32];
351         int uvlayer_tmp, pad;
352 } UVProjectModifierData;
353
354 #define MOD_UVPROJECT_MAXPROJECTORS 10
355
356 /* UVProjectModifierData->flags */
357 #define MOD_UVPROJECT_OVERRIDEIMAGE (1<<0)
358
359 typedef struct DecimateModifierData {
360         ModifierData modifier;
361
362         float percent;
363         int faceCount;
364 } DecimateModifierData;
365
366 /* Smooth modifier flags */
367 #define MOD_SMOOTH_X (1<<1)
368 #define MOD_SMOOTH_Y (1<<2)
369 #define MOD_SMOOTH_Z (1<<3)
370
371 typedef struct SmoothModifierData {
372         ModifierData modifier;
373         float fac;
374         char defgrp_name[32];
375         short flag, repeat;
376
377 } SmoothModifierData;
378
379 /* Cast modifier flags */
380 #define MOD_CAST_X (1<<1)
381 #define MOD_CAST_Y (1<<2)
382 #define MOD_CAST_Z (1<<3)
383 #define MOD_CAST_USE_OB_TRANSFORM (1<<4)
384 #define MOD_CAST_SIZE_FROM_RADIUS (1<<5)
385
386 /* Cast modifier projection types */
387 #define MOD_CAST_TYPE_SPHERE 0
388 #define MOD_CAST_TYPE_CYLINDER 1
389 #define MOD_CAST_TYPE_CUBOID 2
390
391 typedef struct CastModifierData {
392         ModifierData modifier;
393
394         struct Object *object;
395         float fac;
396         float radius;
397         float size;
398         char defgrp_name[32];
399         short flag, type;
400 } CastModifierData;
401
402 enum {
403         MOD_WAV_MAP_LOCAL,
404         MOD_WAV_MAP_GLOBAL,
405         MOD_WAV_MAP_OBJECT,
406         MOD_WAV_MAP_UV,
407 };
408
409 /* WaveModifierData.flag */
410 #define MOD_WAVE_X      (1<<1)
411 #define MOD_WAVE_Y      (1<<2)
412 #define MOD_WAVE_CYCL   (1<<3)
413 #define MOD_WAVE_NORM   (1<<4)
414 #define MOD_WAVE_NORM_X (1<<5)
415 #define MOD_WAVE_NORM_Y (1<<6)
416 #define MOD_WAVE_NORM_Z (1<<7)
417
418 typedef struct WaveModifierData {
419         ModifierData modifier;
420
421         struct Object *objectcenter;
422         char defgrp_name[32];
423         struct Tex *texture;
424         struct Object *map_object;
425
426         short flag, pad;
427
428         float startx, starty, height, width;
429         float narrow, speed, damp, falloff;
430
431         int texmapping, uvlayer_tmp;
432
433         char uvlayer_name[32];
434
435         float timeoffs, lifetime;
436         float pad1;
437 } WaveModifierData;
438
439 typedef struct ArmatureModifierData {
440         ModifierData modifier;
441
442         short deformflag, multi;                /* deformflag replaces armature->deformflag */
443         int pad2;
444         struct Object *object;
445         float *prevCos;         /* stored input of previous modifier, for vertexgroup blending */
446         char defgrp_name[32];
447 } ArmatureModifierData;
448
449 typedef struct HookModifierData {
450         ModifierData modifier;
451
452         struct Object *object;
453         char subtarget[32];             /* optional name of bone target */
454         
455         float parentinv[4][4];  /* matrix making current transform unmodified */
456         float cent[3];                  /* visualization of hook */
457         float falloff;                  /* if not zero, falloff is distance where influence zero */
458         
459         int *indexar;                   /* if NULL, it's using vertexgroup */
460         int totindex;
461         float force;
462         char name[32];                  /* optional vertexgroup name */
463 } HookModifierData;
464
465 typedef struct SoftbodyModifierData {
466         ModifierData modifier;
467 } SoftbodyModifierData;
468
469 typedef struct ClothModifierData {
470         ModifierData            modifier;
471
472         struct Scene *scene;                    /* the context, time etc is here */
473         struct Cloth *clothObject;              /* The internal data structure for cloth. */
474         struct ClothSimSettings *sim_parms; /* definition is in DNA_cloth_types.h */
475         struct ClothCollSettings *coll_parms; /* definition is in DNA_cloth_types.h */
476         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
477         struct ListBase ptcaches;
478 } ClothModifierData;
479
480 typedef struct CollisionModifierData {
481         ModifierData    modifier;
482         
483         struct MVert *x; /* position at the beginning of the frame */
484         struct MVert *xnew; /* position at the end of the frame */
485         struct MVert *xold; /* unsued atm, but was discussed during sprint */
486         struct MVert *current_xnew; /* new position at the actual inter-frame step */
487         struct MVert *current_x; /* position at the actual inter-frame step */
488         struct MVert *current_v; /* (xnew - x) at the actual inter-frame step */
489         
490         struct MFace *mfaces; /* object face data */
491         
492         unsigned int numverts;
493         unsigned int numfaces;
494         float time_x, time_xnew;                /* cfra time of modifier */
495         struct BVHTree *bvhtree; /* bounding volume hierarchy for this cloth object */
496 } CollisionModifierData;
497
498 typedef struct SurfaceModifierData {
499         ModifierData    modifier;
500
501         struct MVert *x; /* old position */
502         struct MVert *v; /* velocity */
503
504         struct DerivedMesh *dm;
505
506         struct BVHTreeFromMesh *bvhtree; /* bounding volume hierarchy of the mesh faces */
507
508         int cfra, numverts;
509 } SurfaceModifierData;
510
511 typedef enum {
512         eBooleanModifierOp_Intersect,
513         eBooleanModifierOp_Union,
514         eBooleanModifierOp_Difference,
515 } BooleanModifierOp;
516 typedef struct BooleanModifierData {
517         ModifierData modifier;
518
519         struct Object *object;
520         int operation, pad;
521 } BooleanModifierData;
522
523 #define MOD_MDEF_INVERT_VGROUP  (1<<0)
524 #define MOD_MDEF_DYNAMIC_BIND   (1<<1)
525
526 #define MOD_MDEF_VOLUME                 0
527 #define MOD_MDEF_SURFACE                1
528
529 typedef struct MDefInfluence {
530         int vertex;
531         float weight;
532 } MDefInfluence;
533
534 typedef struct MDefCell {
535         int offset;
536         int totinfluence;
537 } MDefCell;
538
539 typedef struct MeshDeformModifierData {
540         ModifierData modifier;
541
542         struct Object *object;                  /* mesh object */
543         char defgrp_name[32];                   /* optional vertexgroup name */
544
545         short gridsize, flag, mode, pad;
546
547         /* result of static binding */
548         MDefInfluence *bindinfluences;  /* influences */
549         int *bindoffsets;                               /* offsets into influences array */
550         float *bindcagecos;                             /* coordinates that cage was bound with */
551         int totvert, totcagevert;               /* total vertices in mesh and cage */
552
553         /* result of dynamic binding */
554         MDefCell *dyngrid;                              /* grid with dynamic binding cell points */
555         MDefInfluence *dyninfluences;   /* dynamic binding vertex influences */
556         int *dynverts, *pad2;                   /* is this vertex bound or not? */
557         int dyngridsize;                                /* size of the dynamic bind grid */
558         int totinfluence;                               /* total number of vertex influences */
559         float dyncellmin[3];                    /* offset of the dynamic bind grid */
560         float dyncellwidth;                             /* width of dynamic bind cell */
561         float bindmat[4][4];                    /* matrix of cage at binding time */
562
563         /* deprecated storage */
564         float *bindweights;                             /* deprecated inefficient storage */
565         float *bindcos;                                 /* deprecated storage of cage coords */
566
567         /* runtime */
568         void (*bindfunc)(struct Scene *scene,
569                 struct MeshDeformModifierData *mmd,
570                 float *vertexcos, int totvert, float cagemat[][4]);
571 } MeshDeformModifierData;
572
573 typedef enum {
574         eParticleSystemFlag_Pars =                      (1<<0),
575         eParticleSystemFlag_psys_updated =      (1<<1),
576         eParticleSystemFlag_file_loaded =       (1<<2),
577 } ParticleSystemModifierFlag;
578
579 typedef struct ParticleSystemModifierData {
580         ModifierData modifier;
581         struct ParticleSystem *psys;
582         struct DerivedMesh *dm;
583         int totdmvert, totdmedge, totdmface;
584         short flag, rt;
585 } ParticleSystemModifierData;
586
587 typedef enum {
588         eParticleInstanceFlag_Parents =         (1<<0),
589         eParticleInstanceFlag_Children =        (1<<1),
590         eParticleInstanceFlag_Path =            (1<<2),
591         eParticleInstanceFlag_Unborn =          (1<<3),
592         eParticleInstanceFlag_Alive =           (1<<4),
593         eParticleInstanceFlag_Dead =            (1<<5),
594         eParticleInstanceFlag_KeepShape =       (1<<6),
595         eParticleInstanceFlag_UseSize =         (1<<7),
596 } ParticleInstanceModifierFlag;
597
598 typedef struct ParticleInstanceModifierData {
599         ModifierData modifier;
600         struct Object *ob;
601         short psys, flag, axis, rt;
602         float position, random_position;
603 } ParticleInstanceModifierData;
604
605 typedef enum {
606         eExplodeFlag_CalcFaces =        (1<<0),
607         eExplodeFlag_PaSize =           (1<<1),
608         eExplodeFlag_EdgeCut =          (1<<2),
609         eExplodeFlag_Unborn =           (1<<3),
610         eExplodeFlag_Alive =            (1<<4),
611         eExplodeFlag_Dead =                     (1<<5),
612 } ExplodeModifierFlag;
613
614 typedef struct ExplodeModifierData {
615         ModifierData modifier;
616         int *facepa;
617         short flag, vgroup;
618         float protect;
619         char uvname[32];
620 } ExplodeModifierData;
621
622 typedef struct MultiresModifierData {
623         ModifierData modifier;
624
625         char lvl, sculptlvl, renderlvl, totlvl;
626         char simple, flags, pad[2];
627 } MultiresModifierData;
628
629 typedef enum {
630         eMultiresModifierFlag_ControlEdges = (1<<0),
631         eMultiresModifierFlag_PlainUv = (1<<1),
632 } MultiresModifierFlag;
633
634 typedef struct FluidsimModifierData {
635         ModifierData modifier;
636         
637         struct FluidsimSettings *fss; /* definition is in DNA_object_fluidsim.h */
638         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
639 } FluidsimModifierData;
640
641 typedef struct ShrinkwrapModifierData {
642         ModifierData modifier;
643
644         struct Object *target;  /* shrink target */
645         struct Object *auxTarget; /* additional shrink target */
646         char vgroup_name[32];   /* optional vertexgroup name */
647         float keepDist;                 /* distance offset to keep from mesh/projection point */
648         short shrinkType;               /* shrink type projection */
649         short shrinkOpts;               /* shrink options */
650         char projAxis;                  /* axis to project over */
651
652         /*
653          * if using projection over vertex normal this controls the
654          * the level of subsurface that must be done before getting the
655          * vertex coordinates and normal
656          */
657         char subsurfLevels;
658
659         char pad[6];
660
661 } ShrinkwrapModifierData;
662
663 /* Shrinkwrap->shrinkType */
664 #define MOD_SHRINKWRAP_NEAREST_SURFACE  0
665 #define MOD_SHRINKWRAP_PROJECT                  1
666 #define MOD_SHRINKWRAP_NEAREST_VERTEX   2
667
668 /* Shrinkwrap->shrinkOpts */
669 #define MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR    (1<<0)  /* allow shrinkwrap to move the vertex in the positive direction of axis */
670 #define MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR    (1<<1)  /* allow shrinkwrap to move the vertex in the negative direction of axis */
671
672 #define MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE    (1<<3)  /* ignore vertex moves if a vertex ends projected on a front face of the target */
673 #define MOD_SHRINKWRAP_CULL_TARGET_BACKFACE             (1<<4)  /* ignore vertex moves if a vertex ends projected on a back face of the target */
674
675 #define MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE               (1<<5)  /* distance is measure to the front face of the target */
676
677 #define MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS              (1<<0)
678 #define MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS              (1<<1)
679 #define MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS              (1<<2)
680 #define MOD_SHRINKWRAP_PROJECT_OVER_NORMAL                      0       /* projection over normal is used if no axis is selected */
681
682 typedef struct SimpleDeformModifierData {
683         ModifierData modifier;
684
685         struct Object *origin;  /* object to control the origin of modifier space coordinates */
686         char vgroup_name[32];   /* optional vertexgroup name */
687         float factor;                   /* factors to control simple deforms */
688         float limit[2];                 /* lower and upper limit */             
689
690         char mode;                              /* deform function */
691         char axis;                              /* lock axis (for taper and strech) */
692         char originOpts;                /* originOptions */
693         char pad;
694
695 } SimpleDeformModifierData;
696
697 #define MOD_SIMPLEDEFORM_MODE_TWIST             1
698 #define MOD_SIMPLEDEFORM_MODE_BEND              2
699 #define MOD_SIMPLEDEFORM_MODE_TAPER             3
700 #define MOD_SIMPLEDEFORM_MODE_STRETCH   4
701
702 #define MOD_SIMPLEDEFORM_LOCK_AXIS_X                    (1<<0)
703 #define MOD_SIMPLEDEFORM_LOCK_AXIS_Y                    (1<<1)
704
705 /* indicates whether simple deform should use the local
706    coordinates or global coordinates of origin */
707 #define MOD_SIMPLEDEFORM_ORIGIN_LOCAL                   (1<<0)
708
709 #define MOD_UVPROJECT_MAX                               10
710
711 typedef struct ShapeKeyModifierData {
712         ModifierData modifier;
713 } ShapeKeyModifierData;
714
715 typedef struct SolidifyModifierData {
716         ModifierData modifier;
717
718         char defgrp_name[32];   /* name of vertex group to use */
719         float offset;                   /* new surface offset level*/
720         float offset_fac;               /* midpoint of the offset  */
721         float offset_fac_vg;    /* factor for the minimum weight to use when vgroups are used, avoids 0.0 weights giving duplicate geometry */
722         float crease_inner;
723         float crease_outer;
724         float crease_rim;
725         int flag;
726         short mat_ofs;
727         short mat_ofs_rim;
728 } SolidifyModifierData;
729
730 #define MOD_SOLIDIFY_RIM                        (1<<0)
731 #define MOD_SOLIDIFY_EVEN                       (1<<1)
732 #define MOD_SOLIDIFY_NORMAL_CALC        (1<<2)
733 #define MOD_SOLIDIFY_VGROUP_INV         (1<<3)
734 #define MOD_SOLIDIFY_RIM_MATERIAL       (1<<4) /* deprecated, used in do_versions */
735
736 typedef struct ScrewModifierData {
737         ModifierData modifier;
738         struct Object *ob_axis;
739         int             steps;
740         int             render_steps;
741         int             iter;
742         float   screw_ofs;
743         float   angle;
744         short   axis;
745         short   flag;
746 } ScrewModifierData;
747
748 #define MOD_SCREW_NORMAL_FLIP   (1<<0)
749 #define MOD_SCREW_NORMAL_CALC   (1<<1)
750 #define MOD_SCREW_OBJECT_OFFSET (1<<2)
751 // #define MOD_SCREW_OBJECT_ANGLE       (1<<4)
752
753 typedef struct WarpModifierData {
754         ModifierData modifier;
755
756         /* keep in sync with MappingInfoModifierData */
757         struct Tex *texture;
758         struct Object *map_object;
759         char uvlayer_name[32];
760         int uvlayer_tmp;
761         int texmapping;
762         int pad10;
763         /* end MappingInfoModifierData */
764
765         float strength;
766
767         struct Object *object_from;
768         struct Object *object_to;
769         struct CurveMapping *curfalloff;
770         char defgrp_name[32];                   /* optional vertexgroup name */
771         float falloff_radius;
772         char flag; /* not used yet */
773         char falloff_type;
774         char pad[2];
775 } WarpModifierData;
776
777 #define MOD_WARP_VOLUME_PRESERVE 1
778
779 typedef enum {
780         eWarp_Falloff_None =            0,
781         eWarp_Falloff_Curve =           1,
782         eWarp_Falloff_Sharp =           2, /* PROP_SHARP */
783         eWarp_Falloff_Smooth =          3, /* PROP_SMOOTH */
784         eWarp_Falloff_Root =            4, /* PROP_ROOT */
785         eWarp_Falloff_Linear =          5, /* PROP_LIN */
786         eWarp_Falloff_Const =           6, /* PROP_CONST */
787         eWarp_Falloff_Sphere =          7, /* PROP_SPHERE */
788         /* PROP_RANDOM not used */
789 } WarpModifierFalloff;
790
791 typedef struct WeightVGEditModifierData {
792         ModifierData modifier;
793
794         /* Note: I tried to keep everything logically ordered - provided the
795          * alignment constraints... */
796
797         char    defgrp_name[32];      /* Name of vertex group to edit. */
798
799         short   edit_flags;     /* Using MOD_WVG_EDIT_* flags. */
800         short   falloff_type;   /* Using MOD_WVG_MAPPING_* defines. */
801         float   default_weight; /* Weight for vertices not in vgroup. */
802
803         /* Mapping stuff. */
804         struct CurveMapping *cmap_curve;  /* The custom mapping curve! */
805
806         /* The add/remove vertices weight thresholds. */
807         float   add_threshold, rem_threshold;
808
809         /* Masking options. */
810         float   mask_constant; /* The global "influence", if no vgroup nor tex is used as mask. */
811         /* Name of mask vertex group from which to get weight factors. */
812         char    mask_defgrp_name[32];
813
814         /* Texture masking. */
815         int             mask_tex_use_channel;      /* Which channel to use as weightf. */
816         struct Tex *mask_texture;          /* The texture. */
817         struct Object *mask_tex_map_obj;   /* Name of the map object. */
818         /* How to map the texture (using MOD_DISP_MAP_* constants). */
819         int             mask_tex_mapping;
820         char    mask_tex_uvlayer_name[32]; /* Name of the UV layer. */
821
822         /* Padding... */
823         int pad_i1;
824 } WeightVGEditModifierData;
825
826 /* WeightVGEdit flags. */
827 /* Use parametric mapping. */
828 //#define MOD_WVG_EDIT_MAP                                      (1 << 0)
829 /* Use curve mapping. */
830 //#define MOD_WVG_EDIT_CMAP                                     (1 << 1)
831 /* Reverse weights (in the [0.0, 1.0] standard range). */
832 //#define MOD_WVG_EDIT_REVERSE_WEIGHTS          (1 << 2)
833 /* Add vertices with higher weight than threshold to vgroup. */
834 #define MOD_WVG_EDIT_ADD2VG                                     (1 << 3)
835 /* Remove vertices with lower weight than threshold from vgroup. */
836 #define MOD_WVG_EDIT_REMFVG                                     (1 << 4)
837 /* Clamp weights. */
838 //#define MOD_WVG_EDIT_CLAMP                                    (1 << 5)
839
840 typedef struct WeightVGMixModifierData {
841         ModifierData modifier;
842
843         /* XXX Note: I tried to keep everything logically ordered – provided the
844          *           alignment constraints... */
845
846         char    defgrp_name_a[32];      /* Name of vertex group to modify/weight. */
847         char    defgrp_name_b[32];     /* Name of other vertex group to mix in. */
848         float   default_weight_a;       /* Default weight value for first vgroup. */
849         float   default_weight_b;      /* Default weight value to mix in. */
850         char    mix_mode;             /* How second vgroups weights affect first ones */
851         char    mix_set;              /* What vertices to affect. */
852
853         char    pad_c1[6];
854
855         /* Masking options. */
856         float   mask_constant; /* The global "influence", if no vgroup nor tex is used as mask. */
857         /* Name of mask vertex group from which to get weight factors. */
858         char    mask_defgrp_name[32];
859
860         /* Texture masking. */
861         int             mask_tex_use_channel;      /* Which channel to use as weightf. */
862         struct Tex *mask_texture;          /* The texture. */
863         struct Object *mask_tex_map_obj;   /* Name of the map object. */
864         int             mask_tex_mapping;          /* How to map the texture! */
865         char    mask_tex_uvlayer_name[32]; /* Name of the UV layer. */
866
867         /* Padding... */
868         int pad_i1;
869 } WeightVGMixModifierData;
870
871 /* How second vgroup's weights affect first ones. */
872 #define MOD_WVG_MIX_SET                 1 /* Second weights replace weights. */
873 #define MOD_WVG_MIX_ADD                 2 /* Second weights are added to weights. */
874 #define MOD_WVG_MIX_SUB                 3 /* Second weights are subtracted from weights. */
875 #define MOD_WVG_MIX_MUL                 4 /* Second weights are multiplied with weights. */
876 #define MOD_WVG_MIX_DIV                 5 /* Second weights divide weights. */
877 #define MOD_WVG_MIX_DIF                 6 /* Difference between second weights and weights. */
878 #define MOD_WVG_MIX_AVG                 7 /* Average of both weights. */
879
880 /* What vertices to affect. */
881 #define MOD_WVG_SET_ALL                 1 /* Affect all vertices. */
882 #define MOD_WVG_SET_A                   2 /* Affect only vertices in first vgroup. */
883 #define MOD_WVG_SET_B                   3 /* Affect only vertices in second vgroup. */
884 #define MOD_WVG_SET_OR                  4 /* Affect only vertices in one vgroup or the other. */
885 #define MOD_WVG_SET_AND                 5 /* Affect only vertices in both vgroups. */
886
887 typedef struct WeightVGProximityModifierData {
888         ModifierData modifier;
889
890         /* Note: I tried to keep everything logically ordered - provided the
891          * alignment constraints... */
892
893         char    defgrp_name[32];      /* Name of vertex group to modify/weight. */
894
895         /* Proximity modes. */
896         int             proximity_mode;
897         int             proximity_flags;
898
899         /* Target object from which to calculate vertices distances. */
900         struct Object *proximity_ob_target;
901
902         /* Masking options. */
903         float   mask_constant; /* The global "influence", if no vgroup nor tex is used as mask. */
904         /* Name of mask vertex group from which to get weight factors. */
905         char    mask_defgrp_name[32];
906
907         /* Texture masking. */
908         int             mask_tex_use_channel;      /* Which channel to use as weightf. */
909         struct Tex *mask_texture;          /* The texture. */
910         struct Object *mask_tex_map_obj;   /* Name of the map object. */
911         int             mask_tex_mapping;          /* How to map the texture! */
912         char    mask_tex_uvlayer_name[32]; /* Name of the UV layer. */
913
914         float   min_dist, max_dist;        /* Distances mapping to 0.0/1.0 weights. */
915
916         /* Put here to avoid breaking existing struct... */
917         short   falloff_type;              /* Using MOD_WVG_MAPPING_* defines. */
918
919         /* Padding... */
920         short pad_s1;
921 } WeightVGProximityModifierData;
922
923 /* Modes of proximity weighting. */
924 /* Dist from target object to affected object. */
925 #define MOD_WVG_PROXIMITY_OBJECT                        1 /* source vertex to other location */
926 /* Dist from target object to vertex. */
927 #define MOD_WVG_PROXIMITY_GEOMETRY                      2 /* source vertex to other geometry */
928
929 /* Flags options for proximity weighting. */
930 /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
931 #define MOD_WVG_PROXIMITY_GEOM_VERTS            (1 << 0)
932 /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
933 #define MOD_WVG_PROXIMITY_GEOM_EDGES            (1 << 1)
934 /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
935 #define MOD_WVG_PROXIMITY_GEOM_FACES            (1 << 2)
936
937 /* Defines common to all WeightVG modifiers. */
938 /* Mapping modes. */
939 #define MOD_WVG_MAPPING_NONE                            0
940 #define MOD_WVG_MAPPING_CURVE                           1
941 #define MOD_WVG_MAPPING_SHARP                           2 /* PROP_SHARP */
942 #define MOD_WVG_MAPPING_SMOOTH                          3 /* PROP_SMOOTH */
943 #define MOD_WVG_MAPPING_ROOT                            4 /* PROP_ROOT */
944 /* PROP_LIN not used (same as NONE, here...). */
945 /* PROP_CONST not used. */
946 #define MOD_WVG_MAPPING_SPHERE                          7 /* PROP_SPHERE */
947 #define MOD_WVG_MAPPING_RANDOM                          8 /* PROP_RANDOM */
948 #define MOD_WVG_MAPPING_STEP                            9 /* Median Step. */
949
950 /* Tex channel to be used as mask. */
951 #define MOD_WVG_MASK_TEX_USE_INT                        1
952 #define MOD_WVG_MASK_TEX_USE_RED                        2
953 #define MOD_WVG_MASK_TEX_USE_GREEN                      3
954 #define MOD_WVG_MASK_TEX_USE_BLUE                       4
955 #define MOD_WVG_MASK_TEX_USE_HUE                        5
956 #define MOD_WVG_MASK_TEX_USE_SAT                        6
957 #define MOD_WVG_MASK_TEX_USE_VAL                        7
958 #define MOD_WVG_MASK_TEX_USE_ALPHA                      8
959
960 #endif