Build Modifier - Add "Reversed" Option
[blender.git] / source / blender / makesdna / DNA_modifier_types.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file DNA_modifier_types.h
22  *  \ingroup DNA
23  */
24
25 #ifndef __DNA_MODIFIER_TYPES_H__
26 #define __DNA_MODIFIER_TYPES_H__
27
28 #include "DNA_defs.h"
29 #include "DNA_listBase.h"
30
31 /* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE!
32  * (ONLY ADD NEW ITEMS AT THE END)
33  */
34
35 typedef enum ModifierType {
36         eModifierType_None              = 0,
37         eModifierType_Subsurf           = 1,
38         eModifierType_Lattice           = 2,
39         eModifierType_Curve             = 3,
40         eModifierType_Build             = 4,
41         eModifierType_Mirror            = 5,
42         eModifierType_Decimate          = 6,
43         eModifierType_Wave              = 7,
44         eModifierType_Armature          = 8,
45         eModifierType_Hook              = 9,
46         eModifierType_Softbody          = 10,
47         eModifierType_Boolean           = 11,
48         eModifierType_Array             = 12,
49         eModifierType_EdgeSplit         = 13,
50         eModifierType_Displace          = 14,
51         eModifierType_UVProject         = 15,
52         eModifierType_Smooth            = 16,
53         eModifierType_Cast              = 17,
54         eModifierType_MeshDeform        = 18,
55         eModifierType_ParticleSystem    = 19,
56         eModifierType_ParticleInstance  = 20,
57         eModifierType_Explode           = 21,
58         eModifierType_Cloth             = 22,
59         eModifierType_Collision         = 23,
60         eModifierType_Bevel             = 24,
61         eModifierType_Shrinkwrap        = 25,
62         eModifierType_Fluidsim          = 26,
63         eModifierType_Mask              = 27,
64         eModifierType_SimpleDeform      = 28,
65         eModifierType_Multires          = 29,
66         eModifierType_Surface           = 30,
67         eModifierType_Smoke             = 31,
68         eModifierType_ShapeKey          = 32,
69         eModifierType_Solidify          = 33,
70         eModifierType_Screw             = 34,
71         eModifierType_Warp              = 35,
72         eModifierType_WeightVGEdit      = 36,
73         eModifierType_WeightVGMix       = 37,
74         eModifierType_WeightVGProximity = 38,
75         eModifierType_Ocean             = 39,
76         eModifierType_DynamicPaint      = 40,
77         eModifierType_Remesh            = 41,
78         eModifierType_Skin              = 42,
79         eModifierType_LaplacianSmooth   = 43,
80         eModifierType_Triangulate       = 44,
81         eModifierType_UVWarp            = 45,
82         eModifierType_MeshCache         = 46,
83         eModifierType_LaplacianDeform   = 47,
84         eModifierType_Wireframe         = 48,
85         NUM_MODIFIER_TYPES
86 } ModifierType;
87
88 typedef enum ModifierMode {
89         eModifierMode_Realtime          = (1 << 0),
90         eModifierMode_Render            = (1 << 1),
91         eModifierMode_Editmode          = (1 << 2),
92         eModifierMode_OnCage            = (1 << 3),
93         eModifierMode_Expanded          = (1 << 4),
94         eModifierMode_Virtual           = (1 << 5),
95         eModifierMode_ApplyOnSpline     = (1 << 6),
96         eModifierMode_DisableTemporary  = (1 << 31)
97 } ModifierMode;
98
99 typedef struct ModifierData {
100         struct ModifierData *next, *prev;
101
102         int type, mode;
103         int stackindex, pad;
104         char name[64];  /* MAX_NAME */
105
106         /* XXX for timing info set by caller... solve later? (ton) */
107         struct Scene *scene;
108
109         char *error;
110 } ModifierData;
111
112 typedef enum {
113         eSubsurfModifierFlag_Incremental  = (1 << 0),
114         eSubsurfModifierFlag_DebugIncr    = (1 << 1),
115         eSubsurfModifierFlag_ControlEdges = (1 << 2),
116         eSubsurfModifierFlag_SubsurfUv    = (1 << 3),
117 } SubsurfModifierFlag;
118
119 /* not a real modifier */
120 typedef struct MappingInfoModifierData {
121         ModifierData modifier;
122
123         struct Tex *texture;
124         struct Object *map_object;
125         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
126         int uvlayer_tmp;
127         int texmapping;
128 } MappingInfoModifierData;
129
130 typedef struct SubsurfModifierData {
131         ModifierData modifier;
132
133         short subdivType, levels, renderLevels, flags;
134
135         void *emCache, *mCache;
136 } SubsurfModifierData;
137
138 typedef struct LatticeModifierData {
139         ModifierData modifier;
140
141         struct Object *object;
142         char name[64];          /* optional vertexgroup name, MAX_VGROUP_NAME */
143         float strength;
144         char pad[4];
145 } LatticeModifierData;
146
147 typedef struct CurveModifierData {
148         ModifierData modifier;
149
150         struct Object *object;
151         char name[64];          /* optional vertexgroup name, MAX_VGROUP_NAME */
152         short defaxis;          /* axis along which curve deforms */
153         char pad[6];
154 } CurveModifierData;
155
156 /* CurveModifierData->defaxis */
157 enum {
158         MOD_CURVE_POSX = 1,
159         MOD_CURVE_POSY = 2,
160         MOD_CURVE_POSZ = 3,
161         MOD_CURVE_NEGX = 4,
162         MOD_CURVE_NEGY = 5,
163         MOD_CURVE_NEGZ = 6,
164 };
165
166 typedef struct BuildModifierData {
167         ModifierData modifier;
168
169         float start, length;
170         short flag;
171         
172         short randomize;      /* (bool) whether order of vertices is randomized - legacy files (for readfile conversion) */
173         int seed;             /* (int) random seed */
174 } BuildModifierData;
175
176 /* Build Modifier -> flag */
177 enum {
178         MOD_BUILD_FLAG_RANDOMIZE = (1 << 0),  /* order of vertices is randomized */
179         MOD_BUILD_FLAG_REVERSE   = (1 << 1),  /* frame range is reversed, resulting in a deconstruction effect */
180 };
181
182 /* Mask Modifier */
183 typedef struct MaskModifierData {
184         ModifierData modifier;
185
186         struct Object *ob_arm;  /* armature to use to in place of hardcoded vgroup */
187         char vgroup[64];        /* name of vertex group to use to mask, MAX_VGROUP_NAME */
188
189         int mode;               /* using armature or hardcoded vgroup */
190         int flag;               /* flags for various things */
191 } MaskModifierData;
192
193 /* Mask Modifier -> mode */
194 enum {
195         MOD_MASK_MODE_VGROUP = 0,
196         MOD_MASK_MODE_ARM    = 1,
197 };
198
199 /* Mask Modifier -> flag */
200 enum {
201         MOD_MASK_INV         = (1 << 0),
202 };
203
204 typedef struct ArrayModifierData {
205         ModifierData modifier;
206
207         /* the object with which to cap the start of the array  */
208         struct Object *start_cap;
209         /* the object with which to cap the end of the array  */
210         struct Object *end_cap;
211         /* the curve object to use for MOD_ARR_FITCURVE */
212         struct Object *curve_ob;
213         /* the object to use for object offset */
214         struct Object *offset_ob;
215         /* a constant duplicate offset;
216          * 1 means the duplicates are 1 unit apart
217          */
218         float offset[3];
219         /* a scaled factor for duplicate offsets;
220          * 1 means the duplicates are 1 object-width apart
221          */
222         float scale[3];
223         /* the length over which to distribute the duplicates */
224         float length;
225         /* the limit below which to merge vertices in adjacent duplicates */
226         float merge_dist;
227         /* determines how duplicate count is calculated; one of:
228          * - MOD_ARR_FIXEDCOUNT -> fixed
229          * - MOD_ARR_FITLENGTH  -> calculated to fit a set length
230          * - MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
231          */
232         int fit_type;
233         /* flags specifying how total offset is calculated; binary OR of:
234          * - MOD_ARR_OFF_CONST    -> total offset += offset
235          * - MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
236          * - MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
237          * total offset is the sum of the individual enabled offsets
238          */
239         int offset_type;
240         /* general flags:
241          * MOD_ARR_MERGE -> merge vertices in adjacent duplicates
242          */
243         int flags;
244         /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */
245         int count;
246 } ArrayModifierData;
247
248 /* ArrayModifierData->fit_type */
249 enum {
250         MOD_ARR_FIXEDCOUNT = 0,
251         MOD_ARR_FITLENGTH  = 1,
252         MOD_ARR_FITCURVE   = 2,
253 };
254
255 /* ArrayModifierData->offset_type */
256 enum {
257         MOD_ARR_OFF_CONST    = (1 << 0),
258         MOD_ARR_OFF_RELATIVE = (1 << 1),
259         MOD_ARR_OFF_OBJ      = (1 << 2),
260 };
261
262 /* ArrayModifierData->flags */
263 enum {
264         MOD_ARR_MERGE      = (1 << 0),
265         MOD_ARR_MERGEFINAL = (1 << 1),
266 };
267
268 typedef struct MirrorModifierData {
269         ModifierData modifier;
270
271         short axis  DNA_DEPRECATED; /* deprecated, use flag instead */
272         short flag;
273         float tolerance;
274         struct Object *mirror_ob;
275 } MirrorModifierData;
276
277 /* MirrorModifierData->flag */
278 enum {
279         MOD_MIR_CLIPPING  = (1 << 0),
280         MOD_MIR_MIRROR_U  = (1 << 1),
281         MOD_MIR_MIRROR_V  = (1 << 2),
282         MOD_MIR_AXIS_X    = (1 << 3),
283         MOD_MIR_AXIS_Y    = (1 << 4),
284         MOD_MIR_AXIS_Z    = (1 << 5),
285         MOD_MIR_VGROUP    = (1 << 6),
286         MOD_MIR_NO_MERGE  = (1 << 7),
287 };
288
289 typedef struct EdgeSplitModifierData {
290         ModifierData modifier;
291
292         float split_angle;    /* angle above which edges should be split */
293         int flags;
294 } EdgeSplitModifierData;
295
296 /* EdgeSplitModifierData->flags */
297 enum {
298         MOD_EDGESPLIT_FROMANGLE  = (1 << 1),
299         MOD_EDGESPLIT_FROMFLAG   = (1 << 2),
300 };
301
302 typedef struct BevelModifierData {
303         ModifierData modifier;
304
305         float value;          /* the "raw" bevel value (distance/amount to bevel) */
306         int res;              /* the resolution (as originally coded, it is the number of recursive bevels) */
307         short flags;          /* general option flags */
308         short val_flags;      /* used to interpret the bevel value */
309         short lim_flags;      /* flags to tell the tool how to limit the bevel */
310         short e_flags;        /* flags to direct how edge weights are applied to verts */
311         float profile;        /* controls profile shape (0->1, .5 is round) */
312         /* if the MOD_BEVEL_ANGLE is set, this will be how "sharp" an edge must be before it gets beveled */
313         float bevel_angle;
314         /* if the MOD_BEVEL_VWEIGHT option is set, this will be the name of the vert group, MAX_VGROUP_NAME */
315         char defgrp_name[64];
316 } BevelModifierData;
317
318 /* BevelModifierData->flags and BevelModifierData->lim_flags */
319 enum {
320         MOD_BEVEL_VERT          = (1 << 1),
321 /*      MOD_BEVEL_RADIUS        = (1 << 2), */
322         MOD_BEVEL_ANGLE         = (1 << 3),
323         MOD_BEVEL_WEIGHT        = (1 << 4),
324         MOD_BEVEL_VGROUP        = (1 << 5),
325         MOD_BEVEL_EMIN          = (1 << 7),
326         MOD_BEVEL_EMAX          = (1 << 8),
327 /*      MOD_BEVEL_RUNNING       = (1 << 9), */
328 /*      MOD_BEVEL_RES           = (1 << 10), */
329         /* This is a new setting not related to old (trunk bmesh bevel code)
330          * but adding here because they are mixed - campbell
331          */
332 /*      MOD_BEVEL_EVEN          = (1 << 11), */
333 /*      MOD_BEVEL_DIST          = (1 << 12), */  /* same as above */
334         MOD_BEVEL_OVERLAP_OK    = (1 << 13),
335 };
336
337 /* BevelModifierData->val_flags (not used as flags any more) */
338 enum {
339         MOD_BEVEL_AMT_OFFSET = 0,
340         MOD_BEVEL_AMT_WIDTH = 1,
341         MOD_BEVEL_AMT_DEPTH = 2,
342         MOD_BEVEL_AMT_PERCENT = 3,
343 };
344
345 typedef struct SmokeModifierData {
346         ModifierData modifier;
347
348         struct SmokeDomainSettings *domain;
349         struct SmokeFlowSettings *flow; /* inflow, outflow, smoke objects */
350         struct SmokeCollSettings *coll; /* collision objects */
351         float time;
352         int type;  /* domain, inflow, outflow, ... */
353 } SmokeModifierData;
354
355 /* Smoke modifier flags */
356 enum {
357         MOD_SMOKE_TYPE_DOMAIN = (1 << 0),
358         MOD_SMOKE_TYPE_FLOW   = (1 << 1),
359         MOD_SMOKE_TYPE_COLL   = (1 << 2),
360 };
361
362 typedef struct DisplaceModifierData {
363         ModifierData modifier;
364
365         /* keep in sync with MappingInfoModifierData */
366         struct Tex *texture;
367         struct Object *map_object;
368         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
369         int uvlayer_tmp;
370         int texmapping;
371         /* end MappingInfoModifierData */
372
373         float strength;
374         int direction;
375         char defgrp_name[64];   /* MAX_VGROUP_NAME */
376         float midlevel;
377         int pad;
378 } DisplaceModifierData;
379
380 /* DisplaceModifierData->direction */
381 enum {
382         MOD_DISP_DIR_X       = 0,
383         MOD_DISP_DIR_Y       = 1,
384         MOD_DISP_DIR_Z       = 2,
385         MOD_DISP_DIR_NOR     = 3,
386         MOD_DISP_DIR_RGB_XYZ = 4,
387 };
388
389 /* DisplaceModifierData->texmapping */
390 enum {
391         MOD_DISP_MAP_LOCAL  = 0,
392         MOD_DISP_MAP_GLOBAL = 1,
393         MOD_DISP_MAP_OBJECT = 2,
394         MOD_DISP_MAP_UV     = 3,
395 };
396
397 typedef struct UVProjectModifierData {
398         ModifierData modifier;
399
400         /* the objects which do the projecting */
401         struct Object *projectors[10]; /* MOD_UVPROJECT_MAXPROJECTORS */
402         struct Image *image;           /* the image to project */
403         int flags;
404         int num_projectors;
405         float aspectx, aspecty;
406         float scalex, scaley;
407         char uvlayer_name[64];         /* MAX_CUSTOMDATA_LAYER_NAME */
408         int uvlayer_tmp, pad;
409 } UVProjectModifierData;
410
411 #define MOD_UVPROJECT_MAXPROJECTORS 10
412
413 /* UVProjectModifierData->flags */
414 enum {
415         MOD_UVPROJECT_OVERRIDEIMAGE = (1 << 0),
416 };
417
418 typedef struct DecimateModifierData {
419         ModifierData modifier;
420
421         float percent;  /* (mode == MOD_DECIM_MODE_COLLAPSE) */
422         short iter;     /* (mode == MOD_DECIM_MODE_UNSUBDIV) */
423         char delimit;   /* (mode == MOD_DECIM_MODE_DISSOLVE) */
424         char pad;
425         float angle;    /* (mode == MOD_DECIM_MODE_DISSOLVE) */
426
427         char defgrp_name[64];  /* MAX_VGROUP_NAME */
428         short flag, mode;
429
430         /* runtime only */
431         int face_count, pad2;
432 } DecimateModifierData;
433
434 enum {
435         MOD_DECIM_FLAG_INVERT_VGROUP       = (1 << 0),
436         MOD_DECIM_FLAG_TRIANGULATE         = (1 << 1),  /* for collapse only. dont convert tri pairs back to quads */
437         MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS  = (1 << 2),  /* for dissolve only. collapse all verts between 2 faces */
438 };
439
440 enum {
441         MOD_DECIM_MODE_COLLAPSE,
442         MOD_DECIM_MODE_UNSUBDIV,
443         MOD_DECIM_MODE_DISSOLVE,  /* called planar in the UI */
444 };
445
446 typedef struct SmoothModifierData {
447         ModifierData modifier;
448         float fac;
449         char defgrp_name[64];   /* MAX_VGROUP_NAME */
450         short flag, repeat;
451
452 } SmoothModifierData;
453
454 /* Smooth modifier flags */
455 enum {
456         MOD_SMOOTH_X = (1 << 1),
457         MOD_SMOOTH_Y = (1 << 2),
458         MOD_SMOOTH_Z = (1 << 3),
459 };
460
461 typedef struct CastModifierData {
462         ModifierData modifier;
463
464         struct Object *object;
465         float fac;
466         float radius;
467         float size;
468         char defgrp_name[64];  /* MAX_VGROUP_NAME */
469         short flag, type;
470 } CastModifierData;
471
472 /* Cast modifier flags */
473 enum {
474         /* And what bout (1 << 0) flag? ;) */
475         MOD_CAST_X                = (1 << 1),
476         MOD_CAST_Y                = (1 << 2),
477         MOD_CAST_Z                = (1 << 3),
478         MOD_CAST_USE_OB_TRANSFORM = (1 << 4),
479         MOD_CAST_SIZE_FROM_RADIUS = (1 << 5),
480 };
481
482 /* Cast modifier projection types */
483 enum {
484         MOD_CAST_TYPE_SPHERE   = 0,
485         MOD_CAST_TYPE_CYLINDER = 1,
486         MOD_CAST_TYPE_CUBOID   = 2,
487 };
488
489 typedef struct WaveModifierData {
490         ModifierData modifier;
491
492         /* keep in sync with MappingInfoModifierData */
493         struct Tex *texture;
494         struct Object *map_object;
495         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
496         int uvlayer_tmp;
497         int texmapping;
498         /* end MappingInfoModifierData */
499
500         struct Object *objectcenter;
501         char defgrp_name[64];   /* MAX_VGROUP_NAME */
502
503         short flag, pad;
504
505         float startx, starty, height, width;
506         float narrow, speed, damp, falloff;
507
508         float timeoffs, lifetime;
509         float pad1;
510 } WaveModifierData;
511
512 /* WaveModifierData.flag */
513 enum {
514         /* And what bout (1 << 0) flag? ;) */
515         MOD_WAVE_X      = (1 << 1),
516         MOD_WAVE_Y      = (1 << 2),
517         MOD_WAVE_CYCL   = (1 << 3),
518         MOD_WAVE_NORM   = (1 << 4),
519         MOD_WAVE_NORM_X = (1 << 5),
520         MOD_WAVE_NORM_Y = (1 << 6),
521         MOD_WAVE_NORM_Z = (1 << 7),
522 };
523
524 typedef struct ArmatureModifierData {
525         ModifierData modifier;
526
527         short deformflag, multi;  /* deformflag replaces armature->deformflag */
528         int pad2;
529         struct Object *object;
530         float *prevCos;           /* stored input of previous modifier, for vertexgroup blending */
531         char defgrp_name[64];     /* MAX_VGROUP_NAME */
532 } ArmatureModifierData;
533
534 typedef struct HookModifierData {
535         ModifierData modifier;
536
537         struct Object *object;
538         char subtarget[64];     /* optional name of bone target, MAX_ID_NAME-2 */
539
540         float parentinv[4][4];  /* matrix making current transform unmodified */
541         float cent[3];          /* visualization of hook */
542         float falloff;          /* if not zero, falloff is distance where influence zero */
543
544         int *indexar;           /* if NULL, it's using vertexgroup */
545         int totindex;
546         float force;
547         char name[64];          /* optional vertexgroup name, MAX_VGROUP_NAME */
548 } HookModifierData;
549
550 typedef struct SoftbodyModifierData {
551         ModifierData modifier;
552 } SoftbodyModifierData;
553
554 typedef struct ClothModifierData {
555         ModifierData modifier;
556
557         struct Scene *scene;                  /* the context, time etc is here */
558         struct Cloth *clothObject;            /* The internal data structure for cloth. */
559         struct ClothSimSettings *sim_parms;   /* definition is in DNA_cloth_types.h */
560         struct ClothCollSettings *coll_parms; /* definition is in DNA_cloth_types.h */
561         struct PointCache *point_cache;       /* definition is in DNA_object_force.h */
562         struct ListBase ptcaches;
563 } ClothModifierData;
564
565 typedef struct CollisionModifierData {
566         ModifierData modifier;
567
568         struct MVert *x;            /* position at the beginning of the frame */
569         struct MVert *xnew;         /* position at the end of the frame */
570         struct MVert *xold;         /* unused atm, but was discussed during sprint */
571         struct MVert *current_xnew; /* new position at the actual inter-frame step */
572         struct MVert *current_x;    /* position at the actual inter-frame step */
573         struct MVert *current_v;    /* (xnew - x) at the actual inter-frame step */
574
575         struct MFace *mfaces;       /* object face data */
576
577         unsigned int numverts;
578         unsigned int numfaces;
579         float time_x, time_xnew;    /* cfra time of modifier */
580         struct BVHTree *bvhtree;    /* bounding volume hierarchy for this cloth object */
581 } CollisionModifierData;
582
583 typedef struct SurfaceModifierData {
584         ModifierData modifier;
585
586         struct MVert *x; /* old position */
587         struct MVert *v; /* velocity */
588
589         struct DerivedMesh *dm;
590
591         struct BVHTreeFromMesh *bvhtree; /* bounding volume hierarchy of the mesh faces */
592
593         int cfra, numverts;
594 } SurfaceModifierData;
595
596 typedef struct BooleanModifierData {
597         ModifierData modifier;
598
599         struct Object *object;
600         int operation, pad;
601 } BooleanModifierData;
602
603 typedef enum {
604         eBooleanModifierOp_Intersect  = 0,
605         eBooleanModifierOp_Union      = 1,
606         eBooleanModifierOp_Difference = 2,
607 } BooleanModifierOp;
608
609 typedef struct MDefInfluence {
610         int vertex;
611         float weight;
612 } MDefInfluence;
613
614 typedef struct MDefCell {
615         int offset;
616         int totinfluence;
617 } MDefCell;
618
619 typedef struct MeshDeformModifierData {
620         ModifierData modifier;
621
622         struct Object *object;          /* mesh object */
623         char defgrp_name[64];           /* optional vertexgroup name, MAX_VGROUP_NAME */
624
625         short gridsize, flag, pad[2];
626
627         /* result of static binding */
628         MDefInfluence *bindinfluences;  /* influences */
629         int *bindoffsets;               /* offsets into influences array */
630         float *bindcagecos;             /* coordinates that cage was bound with */
631         int totvert, totcagevert;       /* total vertices in mesh and cage */
632
633         /* result of dynamic binding */
634         MDefCell *dyngrid;              /* grid with dynamic binding cell points */
635         MDefInfluence *dyninfluences;   /* dynamic binding vertex influences */
636         int *dynverts;                  /* is this vertex bound or not? */
637         int dyngridsize;                /* size of the dynamic bind grid */
638         int totinfluence;               /* total number of vertex influences */
639         float dyncellmin[3];            /* offset of the dynamic bind grid */
640         float dyncellwidth;             /* width of dynamic bind cell */
641         float bindmat[4][4];            /* matrix of cage at binding time */
642
643         /* deprecated storage */
644         float *bindweights;             /* deprecated inefficient storage */
645         float *bindcos;                 /* deprecated storage of cage coords */
646
647         /* runtime */
648         void (*bindfunc)(struct Scene *scene, struct MeshDeformModifierData *mmd,
649                          float *vertexcos, int totvert, float cagemat[4][4]);
650 } MeshDeformModifierData;
651
652 enum {
653         MOD_MDEF_INVERT_VGROUP = (1 << 0),
654         MOD_MDEF_DYNAMIC_BIND  = (1 << 1),
655 };
656
657 enum {
658         MOD_MDEF_VOLUME   = 0,
659         MOD_MDEF_SURFACE  = 1,
660 };
661
662 typedef struct ParticleSystemModifierData {
663         ModifierData modifier;
664
665         struct ParticleSystem *psys;
666         struct DerivedMesh *dm;
667         int totdmvert, totdmedge, totdmface;
668         short flag, pad;
669 } ParticleSystemModifierData;
670
671 typedef enum {
672         eParticleSystemFlag_Pars         = (1 << 0),
673         eParticleSystemFlag_psys_updated = (1 << 1),
674         eParticleSystemFlag_file_loaded  = (1 << 2),
675 } ParticleSystemModifierFlag;
676
677 typedef enum {
678         eParticleInstanceFlag_Parents   = (1 << 0),
679         eParticleInstanceFlag_Children  = (1 << 1),
680         eParticleInstanceFlag_Path      = (1 << 2),
681         eParticleInstanceFlag_Unborn    = (1 << 3),
682         eParticleInstanceFlag_Alive     = (1 << 4),
683         eParticleInstanceFlag_Dead      = (1 << 5),
684         eParticleInstanceFlag_KeepShape = (1 << 6),
685         eParticleInstanceFlag_UseSize   = (1 << 7),
686 } ParticleInstanceModifierFlag;
687
688 typedef struct ParticleInstanceModifierData {
689         ModifierData modifier;
690
691         struct Object *ob;
692         short psys, flag, axis, pad;
693         float position, random_position;
694 } ParticleInstanceModifierData;
695
696 typedef enum {
697         eExplodeFlag_CalcFaces = (1 << 0),
698         eExplodeFlag_PaSize    = (1 << 1),
699         eExplodeFlag_EdgeCut   = (1 << 2),
700         eExplodeFlag_Unborn    = (1 << 3),
701         eExplodeFlag_Alive     = (1 << 4),
702         eExplodeFlag_Dead      = (1 << 5),
703 } ExplodeModifierFlag;
704
705 typedef struct ExplodeModifierData {
706         ModifierData modifier;
707
708         int *facepa;
709         short flag, vgroup;
710         float protect;
711         char uvname[64]; /* MAX_CUSTOMDATA_LAYER_NAME */
712 } ExplodeModifierData;
713
714 typedef struct MultiresModifierData {
715         ModifierData modifier;
716
717         char lvl, sculptlvl, renderlvl, totlvl;
718         char simple, flags, pad[2];
719 } MultiresModifierData;
720
721 typedef enum {
722         eMultiresModifierFlag_ControlEdges = (1 << 0),
723         eMultiresModifierFlag_PlainUv      = (1 << 1),
724 } MultiresModifierFlag;
725
726 typedef struct FluidsimModifierData {
727         ModifierData modifier;
728
729         struct FluidsimSettings *fss;   /* definition is in DNA_object_fluidsim.h */
730         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
731 } FluidsimModifierData;
732
733 typedef struct ShrinkwrapModifierData {
734         ModifierData modifier;
735
736         struct Object *target;    /* shrink target */
737         struct Object *auxTarget; /* additional shrink target */
738         char vgroup_name[64];     /* optional vertexgroup name, MAX_VGROUP_NAME */
739         float keepDist;           /* distance offset to keep from mesh/projection point */
740         short shrinkType;         /* shrink type projection */
741         short shrinkOpts;         /* shrink options */
742         float projLimit;          /* limit the projection ray cast */
743         char  projAxis;           /* axis to project over */
744
745         /* If using projection over vertex normal this controls the level of subsurface that must be done
746          * before getting the vertex coordinates and normal
747          */
748         char subsurfLevels;
749
750         char pad[2];
751 } ShrinkwrapModifierData;
752
753 /* Shrinkwrap->shrinkType */
754 enum {
755         MOD_SHRINKWRAP_NEAREST_SURFACE = 0,
756         MOD_SHRINKWRAP_PROJECT         = 1,
757         MOD_SHRINKWRAP_NEAREST_VERTEX  = 2,
758 };
759
760 /* Shrinkwrap->shrinkOpts */
761 enum {
762         /* allow shrinkwrap to move the vertex in the positive direction of axis */
763         MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR = (1 << 0),
764         /* allow shrinkwrap to move the vertex in the negative direction of axis */
765         MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR = (1 << 1),
766
767         /* ignore vertex moves if a vertex ends projected on a front face of the target */
768         MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE = (1 << 3),
769         /* ignore vertex moves if a vertex ends projected on a back face of the target */
770         MOD_SHRINKWRAP_CULL_TARGET_BACKFACE  = (1 << 4),
771
772         MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE    = (1 << 5),  /* distance is measure to the front face of the target */
773 };
774
775 /* Shrinkwrap->projAxis */
776 enum {
777         MOD_SHRINKWRAP_PROJECT_OVER_NORMAL   = 0,        /* projection over normal is used if no axis is selected */
778         MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS   = (1 << 0),
779         MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS   = (1 << 1),
780         MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS   = (1 << 2),
781 };
782
783
784 typedef struct SimpleDeformModifierData {
785         ModifierData modifier;
786
787         struct Object *origin;  /* object to control the origin of modifier space coordinates */
788         char vgroup_name[64];   /* optional vertexgroup name, MAX_VGROUP_NAME */
789         float factor;           /* factors to control simple deforms */
790         float limit[2];         /* lower and upper limit */
791
792         char mode;              /* deform function */
793         char axis;              /* lock axis (for taper and strech) */
794         char pad[2];
795
796 } SimpleDeformModifierData;
797
798 enum {
799         MOD_SIMPLEDEFORM_MODE_TWIST   = 1,
800         MOD_SIMPLEDEFORM_MODE_BEND    = 2,
801         MOD_SIMPLEDEFORM_MODE_TAPER   = 3,
802         MOD_SIMPLEDEFORM_MODE_STRETCH = 4,
803 };
804
805 enum {
806         MOD_SIMPLEDEFORM_LOCK_AXIS_X = (1 << 0),
807         MOD_SIMPLEDEFORM_LOCK_AXIS_Y = (1 << 1),
808 };
809
810 typedef struct ShapeKeyModifierData {
811         ModifierData modifier;
812 } ShapeKeyModifierData;
813
814 typedef struct SolidifyModifierData {
815         ModifierData modifier;
816
817         char defgrp_name[64];   /* name of vertex group to use, MAX_VGROUP_NAME */
818         float offset;           /* new surface offset level*/
819         float offset_fac;       /* midpoint of the offset  */
820         /* factor for the minimum weight to use when vgroups are used, avoids 0.0 weights giving duplicate geometry */
821         float offset_fac_vg;
822         float offset_clamp;     /* clamp offset based on surrounding geometry */
823         float pad;
824         float crease_inner;
825         float crease_outer;
826         float crease_rim;
827         int flag;
828         short mat_ofs;
829         short mat_ofs_rim;
830 } SolidifyModifierData;
831
832 enum {
833         MOD_SOLIDIFY_RIM            = (1 << 0),
834         MOD_SOLIDIFY_EVEN           = (1 << 1),
835         MOD_SOLIDIFY_NORMAL_CALC    = (1 << 2),
836         MOD_SOLIDIFY_VGROUP_INV     = (1 << 3),
837         MOD_SOLIDIFY_RIM_MATERIAL   = (1 << 4),  /* deprecated, used in do_versions */
838         MOD_SOLIDIFY_FLIP           = (1 << 5),
839 };
840
841 #if (DNA_DEPRECATED_GCC_POISON == 1)
842 #pragma GCC poison MOD_SOLIDIFY_RIM_MATERIAL
843 #endif
844
845 typedef struct ScrewModifierData {
846         ModifierData modifier;
847
848         struct Object *ob_axis;
849         unsigned int steps;
850         unsigned int render_steps;
851         unsigned int iter;
852         float screw_ofs;
853         float angle;
854         char axis;
855         char pad;
856         short flag;
857 } ScrewModifierData;
858
859 enum {
860         MOD_SCREW_NORMAL_FLIP    = (1 << 0),
861         MOD_SCREW_NORMAL_CALC    = (1 << 1),
862         MOD_SCREW_OBJECT_OFFSET  = (1 << 2),
863 /*      MOD_SCREW_OBJECT_ANGLE   = (1 << 4), */
864         MOD_SCREW_SMOOTH_SHADING = (1 << 5),
865         MOD_SCREW_UV_STRETCH_U   = (1 << 6),
866         MOD_SCREW_UV_STRETCH_V   = (1 << 7),
867 };
868
869 typedef struct OceanModifierData {
870         ModifierData modifier;
871
872         struct Ocean *ocean;
873         struct OceanCache *oceancache;
874         
875         int resolution;
876         int spatial_size;
877
878         float wind_velocity;
879
880         float damp;
881         float smallest_wave;
882         float depth;
883
884         float wave_alignment;
885         float wave_direction;
886         float wave_scale;
887
888         float chop_amount;
889         float foam_coverage;
890         float time;
891
892         int bakestart;
893         int bakeend;
894
895         char cachepath[1024];    /* FILE_MAX */
896         char foamlayername[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
897         char cached;
898         char geometry_mode;
899
900         char flag;
901         char refresh;
902
903         short repeat_x;
904         short repeat_y;
905
906         int seed;
907
908         float size;
909
910         float foam_fade;
911
912         int pad;
913 } OceanModifierData;
914
915 enum {
916         MOD_OCEAN_GEOM_GENERATE = 0,
917         MOD_OCEAN_GEOM_DISPLACE = 1,
918         MOD_OCEAN_GEOM_SIM_ONLY = 2,
919 };
920
921 enum {
922         MOD_OCEAN_REFRESH_RESET        = (1 << 0),
923         MOD_OCEAN_REFRESH_SIM          = (1 << 1),
924         MOD_OCEAN_REFRESH_ADD          = (1 << 2),
925         MOD_OCEAN_REFRESH_CLEAR_CACHE  = (1 << 3),
926         MOD_OCEAN_REFRESH_TOPOLOGY     = (1 << 4),
927 };
928
929 enum {
930         MOD_OCEAN_GENERATE_FOAM     = (1 << 0),
931         MOD_OCEAN_GENERATE_NORMALS  = (1 << 1),
932 };
933
934 typedef struct WarpModifierData {
935         ModifierData modifier;
936         /* keep in sync with MappingInfoModifierData */
937         struct Tex *texture;
938         struct Object *map_object;
939         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
940         int uvlayer_tmp;
941         int texmapping;
942         /* end MappingInfoModifierData */
943
944         struct Object *object_from;
945         struct Object *object_to;
946         struct CurveMapping *curfalloff;
947         char defgrp_name[64];  /* optional vertexgroup name, MAX_VGROUP_NAME */
948         float strength;
949         float falloff_radius;
950         char flag; /* not used yet */
951         char falloff_type;
952         char pad[6];
953 } WarpModifierData;
954
955 #define MOD_WARP_VOLUME_PRESERVE 1
956
957 typedef enum {
958         eWarp_Falloff_None   = 0,
959         eWarp_Falloff_Curve  = 1,
960         eWarp_Falloff_Sharp  = 2, /* PROP_SHARP */
961         eWarp_Falloff_Smooth = 3, /* PROP_SMOOTH */
962         eWarp_Falloff_Root   = 4, /* PROP_ROOT */
963         eWarp_Falloff_Linear = 5, /* PROP_LIN */
964         eWarp_Falloff_Const  = 6, /* PROP_CONST */
965         eWarp_Falloff_Sphere = 7, /* PROP_SPHERE */
966         /* PROP_RANDOM not used */
967 } WarpModifierFalloff;
968
969 typedef struct WeightVGEditModifierData {
970         ModifierData modifier;
971
972         char defgrp_name[64]; /* Name of vertex group to edit. MAX_VGROUP_NAME. */
973
974         short edit_flags;     /* Using MOD_WVG_EDIT_* flags. */
975         short falloff_type;   /* Using MOD_WVG_MAPPING_* defines. */
976         float default_weight; /* Weight for vertices not in vgroup. */
977
978         /* Mapping stuff. */
979         struct CurveMapping *cmap_curve;  /* The custom mapping curve! */
980
981         /* The add/remove vertices weight thresholds. */
982         float add_threshold, rem_threshold;
983
984         /* Masking options. */
985         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
986         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
987
988         /* Texture masking. */
989         int mask_tex_use_channel;          /* Which channel to use as weightf. */
990         struct Tex *mask_texture;          /* The texture. */
991         struct Object *mask_tex_map_obj;   /* Name of the map object. */
992         int mask_tex_mapping;              /* How to map the texture (using MOD_DISP_MAP_* enums). */
993         char mask_tex_uvlayer_name[64];    /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME */
994
995         /* Padding... */
996         int pad_i1;
997 } WeightVGEditModifierData;
998
999 /* WeightVGEdit flags. */
1000 enum {
1001         /* (1 << 0), (1 << 1) and (1 << 2) are free for future use! */
1002         MOD_WVG_EDIT_ADD2VG  = (1 << 3),  /* Add vertices with higher weight than threshold to vgroup. */
1003         MOD_WVG_EDIT_REMFVG  = (1 << 4),  /* Remove vertices with lower weight than threshold from vgroup. */
1004 };
1005
1006 typedef struct WeightVGMixModifierData {
1007         ModifierData modifier;
1008
1009         char defgrp_name_a[64];    /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1010         char defgrp_name_b[64];    /* Name of other vertex group to mix in. MAX_VGROUP_NAME. */
1011         float default_weight_a;    /* Default weight value for first vgroup. */
1012         float default_weight_b;    /* Default weight value to mix in. */
1013         char mix_mode;             /* How second vgroups weights affect first ones */
1014         char mix_set;              /* What vertices to affect. */
1015
1016         char pad_c1[6];
1017
1018         /* Masking options. */
1019         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1020         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1021
1022         /* Texture masking. */
1023         int mask_tex_use_channel;         /* Which channel to use as weightf. */
1024         struct Tex *mask_texture;         /* The texture. */
1025         struct Object *mask_tex_map_obj;  /* Name of the map object. */
1026         int mask_tex_mapping;             /* How to map the texture! */
1027         char mask_tex_uvlayer_name[64];   /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */
1028
1029         /* Padding... */
1030         int pad_i1;
1031 } WeightVGMixModifierData;
1032
1033 /* How second vgroup's weights affect first ones. */
1034 enum {
1035         MOD_WVG_MIX_SET = 1,  /* Second weights replace weights. */
1036         MOD_WVG_MIX_ADD = 2,  /* Second weights are added to weights. */
1037         MOD_WVG_MIX_SUB = 3,  /* Second weights are subtracted from weights. */
1038         MOD_WVG_MIX_MUL = 4,  /* Second weights are multiplied with weights. */
1039         MOD_WVG_MIX_DIV = 5,  /* Second weights divide weights. */
1040         MOD_WVG_MIX_DIF = 6,  /* Difference between second weights and weights. */
1041         MOD_WVG_MIX_AVG = 7,  /* Average of both weights. */
1042 };
1043
1044 /* What vertices to affect. */
1045 enum {
1046         MOD_WVG_SET_ALL = 1,  /* Affect all vertices. */
1047         MOD_WVG_SET_A   = 2,  /* Affect only vertices in first vgroup. */
1048         MOD_WVG_SET_B   = 3,  /* Affect only vertices in second vgroup. */
1049         MOD_WVG_SET_OR  = 4,  /* Affect only vertices in one vgroup or the other. */
1050         MOD_WVG_SET_AND = 5,  /* Affect only vertices in both vgroups. */
1051 };
1052
1053 typedef struct WeightVGProximityModifierData {
1054         ModifierData modifier;
1055
1056         char defgrp_name[64];      /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1057
1058         /* Proximity modes. */
1059         int proximity_mode;
1060         int proximity_flags;
1061
1062         /* Target object from which to calculate vertices distances. */
1063         struct Object *proximity_ob_target;
1064
1065         /* Masking options. */
1066         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1067         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1068
1069         /* Texture masking. */
1070         int mask_tex_use_channel;        /* Which channel to use as weightf. */
1071         struct Tex *mask_texture;        /* The texture. */
1072         struct Object *mask_tex_map_obj; /* Name of the map object. */
1073         int mask_tex_mapping;            /* How to map the texture! */
1074         char mask_tex_uvlayer_name[64];  /* Name of the UV Map. MAX_CUSTOMDATA_LAYER_NAME. */
1075
1076         float min_dist, max_dist;        /* Distances mapping to 0.0/1.0 weights. */
1077
1078         /* Put here to avoid breaking existing struct... */
1079         short falloff_type;              /* Using MOD_WVG_MAPPING_* enums. */
1080
1081         /* Padding... */
1082         short pad_s1;
1083 } WeightVGProximityModifierData;
1084
1085 /* Modes of proximity weighting. */
1086 enum {
1087         MOD_WVG_PROXIMITY_OBJECT    = 1,  /* source vertex to other location */
1088         MOD_WVG_PROXIMITY_GEOMETRY  = 2,  /* source vertex to other geometry */
1089 };
1090
1091 /* Flags options for proximity weighting. */
1092 enum {
1093         /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1094         MOD_WVG_PROXIMITY_GEOM_VERTS  = (1 << 0),
1095         /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1096         MOD_WVG_PROXIMITY_GEOM_EDGES  = (1 << 1),
1097         /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1098         MOD_WVG_PROXIMITY_GEOM_FACES  = (1 << 2),
1099 };
1100
1101 /* Defines common to all WeightVG modifiers. */
1102 /* Mapping modes. */
1103 enum {
1104         MOD_WVG_MAPPING_NONE    = 0,
1105         MOD_WVG_MAPPING_CURVE   = 1,
1106         MOD_WVG_MAPPING_SHARP   = 2,  /* PROP_SHARP */
1107         MOD_WVG_MAPPING_SMOOTH  = 3,  /* PROP_SMOOTH */
1108         MOD_WVG_MAPPING_ROOT    = 4,  /* PROP_ROOT */
1109         /* PROP_LIN not used (same as NONE, here...). */
1110         /* PROP_CONST not used. */
1111         MOD_WVG_MAPPING_SPHERE  = 7,  /* PROP_SPHERE */
1112         MOD_WVG_MAPPING_RANDOM  = 8,  /* PROP_RANDOM */
1113         MOD_WVG_MAPPING_STEP    = 9,  /* Median Step. */
1114 };
1115
1116 /* Tex channel to be used as mask. */
1117 enum {
1118         MOD_WVG_MASK_TEX_USE_INT    = 1,
1119         MOD_WVG_MASK_TEX_USE_RED    = 2,
1120         MOD_WVG_MASK_TEX_USE_GREEN  = 3,
1121         MOD_WVG_MASK_TEX_USE_BLUE   = 4,
1122         MOD_WVG_MASK_TEX_USE_HUE    = 5,
1123         MOD_WVG_MASK_TEX_USE_SAT    = 6,
1124         MOD_WVG_MASK_TEX_USE_VAL    = 7,
1125         MOD_WVG_MASK_TEX_USE_ALPHA  = 8,
1126 };
1127
1128 typedef struct DynamicPaintModifierData {
1129         ModifierData modifier;
1130
1131         struct DynamicPaintCanvasSettings *canvas;
1132         struct DynamicPaintBrushSettings *brush;
1133         int type;  /* ui display: canvas / brush */
1134         int pad;
1135 } DynamicPaintModifierData;
1136
1137 /* Dynamic paint modifier flags */
1138 enum {
1139         MOD_DYNAMICPAINT_TYPE_CANVAS  = (1 << 0),
1140         MOD_DYNAMICPAINT_TYPE_BRUSH   = (1 << 1),
1141 };
1142
1143 /* Remesh modifier */
1144 typedef enum RemeshModifierFlags {
1145         MOD_REMESH_FLOOD_FILL     = 1,
1146         MOD_REMESH_SMOOTH_SHADING = 2,
1147 } RemeshModifierFlags;
1148
1149 typedef enum RemeshModifierMode {
1150         /* blocky */
1151         MOD_REMESH_CENTROID       = 0,
1152         /* smooth */
1153         MOD_REMESH_MASS_POINT     = 1,
1154         /* keeps sharp edges */
1155         MOD_REMESH_SHARP_FEATURES = 2,
1156 } RemeshModifierMode;
1157
1158 typedef struct RemeshModifierData {
1159         ModifierData modifier;
1160
1161         /* floodfill option, controls how small components can be before they are removed */
1162         float threshold;
1163
1164         /* ratio between size of model and grid */
1165         float scale;
1166
1167         float hermite_num;
1168
1169         /* octree depth */
1170         char depth;
1171
1172         char flag;
1173         char mode;
1174         char pad;
1175 } RemeshModifierData;
1176
1177 /* Skin modifier */
1178 typedef struct SkinModifierData {
1179         ModifierData modifier;
1180
1181         float branch_smoothing;
1182
1183         char flag;
1184
1185         char symmetry_axes;
1186
1187         char pad[2];
1188 } SkinModifierData;
1189
1190 /* SkinModifierData.symmetry_axes */
1191 enum {
1192         MOD_SKIN_SYMM_X = (1 << 0),
1193         MOD_SKIN_SYMM_Y = (1 << 1),
1194         MOD_SKIN_SYMM_Z = (1 << 2),
1195 };
1196
1197 /* SkinModifierData.flag */
1198 enum {
1199         MOD_SKIN_SMOOTH_SHADING = 1,
1200 };
1201
1202 /* Triangulate modifier */
1203 typedef struct TriangulateModifierData {
1204         ModifierData modifier;
1205
1206         int flag;
1207         int quad_method;
1208         int ngon_method;
1209         int pad;
1210 } TriangulateModifierData;
1211
1212 enum {
1213         MOD_TRIANGULATE_BEAUTY = (1 << 0), /* deprecated */
1214 };
1215
1216 #if (DNA_DEPRECATED_GCC_POISON == 1)
1217 #pragma GCC poison MOD_TRIANGULATE_BEAUTY
1218 #endif
1219
1220 /* Triangulate methods - NGons */
1221 enum {
1222         MOD_TRIANGULATE_NGON_BEAUTY = 0,
1223         MOD_TRIANGULATE_NGON_SCANFILL,
1224 };
1225
1226 /* Triangulate methods - Quads */
1227 enum {
1228         MOD_TRIANGULATE_QUAD_BEAUTY = 0,
1229         MOD_TRIANGULATE_QUAD_FIXED,
1230         MOD_TRIANGULATE_QUAD_ALTERNATE,
1231         MOD_TRIANGULATE_QUAD_SHORTEDGE
1232 };
1233
1234 typedef struct LaplacianSmoothModifierData {
1235         ModifierData modifier;
1236
1237         float lambda, lambda_border, pad1;
1238         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1239         short flag, repeat;
1240 } LaplacianSmoothModifierData;
1241
1242 /* Smooth modifier flags */
1243 enum {
1244         MOD_LAPLACIANSMOOTH_X               = (1 << 1),
1245         MOD_LAPLACIANSMOOTH_Y               = (1 << 2),
1246         MOD_LAPLACIANSMOOTH_Z               = (1 << 3),
1247         MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME = (1 << 4),
1248         MOD_LAPLACIANSMOOTH_NORMALIZED      = (1 << 5),
1249 };
1250
1251 typedef struct UVWarpModifierData {
1252         ModifierData modifier;
1253
1254         char axis_u, axis_v;
1255         char pad[6];
1256         float center[2];            /* used for rotate/scale */
1257
1258         struct Object *object_src;  /* source */
1259         char bone_src[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1260         struct Object *object_dst;  /* target */
1261         char bone_dst[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1262
1263         char vgroup_name[64];       /* optional vertexgroup name, MAX_VGROUP_NAME */
1264         char uvlayer_name[64];      /* MAX_CUSTOMDATA_LAYER_NAME */
1265 } UVWarpModifierData;
1266
1267 /* cache modifier */
1268 typedef struct MeshCacheModifierData {
1269         ModifierData modifier;
1270
1271         char flag;
1272         char type;  /* file format */
1273         char time_mode;
1274         char play_mode;
1275
1276         /* axis conversion */
1277         char forward_axis;
1278         char up_axis;
1279         char flip_axis;
1280
1281         char interp;
1282
1283         float factor;
1284         char deform_mode;
1285         char pad[7];
1286
1287         /* play_mode == MOD_MESHCACHE_PLAY_CFEA */
1288         float frame_start;
1289         float frame_scale;
1290
1291         /* play_mode == MOD_MESHCACHE_PLAY_EVAL */
1292         /* we could use one float for all these but their purpose is very different */
1293         float eval_frame;
1294         float eval_time;
1295         float eval_factor;
1296
1297         char filepath[1024];  /* FILE_MAX */
1298 } MeshCacheModifierData;
1299
1300 enum {
1301         MOD_MESHCACHE_TYPE_MDD  = 1,
1302         MOD_MESHCACHE_TYPE_PC2  = 2,
1303 };
1304
1305 enum {
1306         MOD_MESHCACHE_DEFORM_OVERWRITE  = 0,
1307         MOD_MESHCACHE_DEFORM_INTEGRATE  = 1,
1308 };
1309
1310 enum {
1311         MOD_MESHCACHE_INTERP_NONE      = 0,
1312         MOD_MESHCACHE_INTERP_LINEAR    = 1,
1313 /*      MOD_MESHCACHE_INTERP_CARDINAL  = 2, */
1314 };
1315
1316 enum {
1317         MOD_MESHCACHE_TIME_FRAME   = 0,
1318         MOD_MESHCACHE_TIME_SECONDS = 1,
1319         MOD_MESHCACHE_TIME_FACTOR  = 2,
1320 };
1321
1322 enum {
1323         MOD_MESHCACHE_PLAY_CFEA = 0,
1324         MOD_MESHCACHE_PLAY_EVAL = 1,
1325 };
1326
1327
1328 typedef struct LaplacianDeformModifierData {
1329         ModifierData modifier;
1330         char anchor_grp_name[64];  /* MAX_VGROUP_NAME */
1331         int total_verts, repeat;
1332         float *vertexco;
1333         void *cache_system;  /* runtime only */
1334         short flag, pad[3];
1335
1336 } LaplacianDeformModifierData;
1337
1338 /* Smooth modifier flags */
1339 enum {
1340         MOD_LAPLACIANDEFORM_BIND = 1,
1341 };
1342
1343 /* many of these options match 'solidify' */
1344 typedef struct WireframeModifierData {
1345         ModifierData modifier;
1346         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1347         float offset;
1348         float offset_fac;
1349         float offset_fac_vg;
1350         float crease_weight;
1351         short flag, mat_ofs;
1352         short pad[2];
1353 } WireframeModifierData;
1354
1355 enum {
1356         MOD_WIREFRAME_INVERT_VGROUP = (1 << 0),
1357         MOD_WIREFRAME_REPLACE       = (1 << 1),
1358         MOD_WIREFRAME_BOUNDARY      = (1 << 2),
1359         MOD_WIREFRAME_OFS_EVEN      = (1 << 3),
1360         MOD_WIREFRAME_OFS_RELATIVE  = (1 << 4),
1361         MOD_WIREFRAME_CREASE        = (1 << 5),
1362 };
1363
1364
1365
1366 #endif  /* __DNA_MODIFIER_TYPES_H__ */