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