Solidify Modifier "Rim Only" Option
[blender-staging.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         short mat;            /* material index if >= 0, else material inherited from surrounding faces */
312         short pad;
313         int pad2;
314         float profile;        /* controls profile shape (0->1, .5 is round) */
315         /* if the MOD_BEVEL_ANGLE is set, this will be how "sharp" an edge must be before it gets beveled */
316         float bevel_angle;
317         /* if the MOD_BEVEL_VWEIGHT option is set, this will be the name of the vert group, MAX_VGROUP_NAME */
318         char defgrp_name[64];
319 } BevelModifierData;
320
321 /* BevelModifierData->flags and BevelModifierData->lim_flags */
322 enum {
323         MOD_BEVEL_VERT          = (1 << 1),
324 /*      MOD_BEVEL_RADIUS        = (1 << 2), */
325         MOD_BEVEL_ANGLE         = (1 << 3),
326         MOD_BEVEL_WEIGHT        = (1 << 4),
327         MOD_BEVEL_VGROUP        = (1 << 5),
328         MOD_BEVEL_EMIN          = (1 << 7),
329         MOD_BEVEL_EMAX          = (1 << 8),
330 /*      MOD_BEVEL_RUNNING       = (1 << 9), */
331 /*      MOD_BEVEL_RES           = (1 << 10), */
332         /* This is a new setting not related to old (trunk bmesh bevel code)
333          * but adding here because they are mixed - campbell
334          */
335 /*      MOD_BEVEL_EVEN          = (1 << 11), */
336 /*      MOD_BEVEL_DIST          = (1 << 12), */  /* same as above */
337         MOD_BEVEL_OVERLAP_OK    = (1 << 13),
338 };
339
340 /* BevelModifierData->val_flags (not used as flags any more) */
341 enum {
342         MOD_BEVEL_AMT_OFFSET = 0,
343         MOD_BEVEL_AMT_WIDTH = 1,
344         MOD_BEVEL_AMT_DEPTH = 2,
345         MOD_BEVEL_AMT_PERCENT = 3,
346 };
347
348 typedef struct SmokeModifierData {
349         ModifierData modifier;
350
351         struct SmokeDomainSettings *domain;
352         struct SmokeFlowSettings *flow; /* inflow, outflow, smoke objects */
353         struct SmokeCollSettings *coll; /* collision objects */
354         float time;
355         int type;  /* domain, inflow, outflow, ... */
356 } SmokeModifierData;
357
358 /* Smoke modifier flags */
359 enum {
360         MOD_SMOKE_TYPE_DOMAIN = (1 << 0),
361         MOD_SMOKE_TYPE_FLOW   = (1 << 1),
362         MOD_SMOKE_TYPE_COLL   = (1 << 2),
363 };
364
365 typedef struct DisplaceModifierData {
366         ModifierData modifier;
367
368         /* keep in sync with MappingInfoModifierData */
369         struct Tex *texture;
370         struct Object *map_object;
371         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
372         int uvlayer_tmp;
373         int texmapping;
374         /* end MappingInfoModifierData */
375
376         float strength;
377         int direction;
378         char defgrp_name[64];   /* MAX_VGROUP_NAME */
379         float midlevel;
380         int pad;
381 } DisplaceModifierData;
382
383 /* DisplaceModifierData->direction */
384 enum {
385         MOD_DISP_DIR_X       = 0,
386         MOD_DISP_DIR_Y       = 1,
387         MOD_DISP_DIR_Z       = 2,
388         MOD_DISP_DIR_NOR     = 3,
389         MOD_DISP_DIR_RGB_XYZ = 4,
390 };
391
392 /* DisplaceModifierData->texmapping */
393 enum {
394         MOD_DISP_MAP_LOCAL  = 0,
395         MOD_DISP_MAP_GLOBAL = 1,
396         MOD_DISP_MAP_OBJECT = 2,
397         MOD_DISP_MAP_UV     = 3,
398 };
399
400 typedef struct UVProjectModifierData {
401         ModifierData modifier;
402
403         /* the objects which do the projecting */
404         struct Object *projectors[10]; /* MOD_UVPROJECT_MAXPROJECTORS */
405         struct Image *image;           /* the image to project */
406         int flags;
407         int num_projectors;
408         float aspectx, aspecty;
409         float scalex, scaley;
410         char uvlayer_name[64];         /* MAX_CUSTOMDATA_LAYER_NAME */
411         int uvlayer_tmp, pad;
412 } UVProjectModifierData;
413
414 #define MOD_UVPROJECT_MAXPROJECTORS 10
415
416 /* UVProjectModifierData->flags */
417 enum {
418         MOD_UVPROJECT_OVERRIDEIMAGE = (1 << 0),
419 };
420
421 typedef struct DecimateModifierData {
422         ModifierData modifier;
423
424         float percent;  /* (mode == MOD_DECIM_MODE_COLLAPSE) */
425         short iter;     /* (mode == MOD_DECIM_MODE_UNSUBDIV) */
426         char delimit;   /* (mode == MOD_DECIM_MODE_DISSOLVE) */
427         char pad;
428         float angle;    /* (mode == MOD_DECIM_MODE_DISSOLVE) */
429
430         char defgrp_name[64];  /* MAX_VGROUP_NAME */
431         short flag, mode;
432
433         /* runtime only */
434         int face_count, pad2;
435 } DecimateModifierData;
436
437 enum {
438         MOD_DECIM_FLAG_INVERT_VGROUP       = (1 << 0),
439         MOD_DECIM_FLAG_TRIANGULATE         = (1 << 1),  /* for collapse only. dont convert tri pairs back to quads */
440         MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS  = (1 << 2),  /* for dissolve only. collapse all verts between 2 faces */
441 };
442
443 enum {
444         MOD_DECIM_MODE_COLLAPSE,
445         MOD_DECIM_MODE_UNSUBDIV,
446         MOD_DECIM_MODE_DISSOLVE,  /* called planar in the UI */
447 };
448
449 typedef struct SmoothModifierData {
450         ModifierData modifier;
451         float fac;
452         char defgrp_name[64];   /* MAX_VGROUP_NAME */
453         short flag, repeat;
454
455 } SmoothModifierData;
456
457 /* Smooth modifier flags */
458 enum {
459         MOD_SMOOTH_X = (1 << 1),
460         MOD_SMOOTH_Y = (1 << 2),
461         MOD_SMOOTH_Z = (1 << 3),
462 };
463
464 typedef struct CastModifierData {
465         ModifierData modifier;
466
467         struct Object *object;
468         float fac;
469         float radius;
470         float size;
471         char defgrp_name[64];  /* MAX_VGROUP_NAME */
472         short flag, type;
473 } CastModifierData;
474
475 /* Cast modifier flags */
476 enum {
477         /* And what bout (1 << 0) flag? ;) */
478         MOD_CAST_X                = (1 << 1),
479         MOD_CAST_Y                = (1 << 2),
480         MOD_CAST_Z                = (1 << 3),
481         MOD_CAST_USE_OB_TRANSFORM = (1 << 4),
482         MOD_CAST_SIZE_FROM_RADIUS = (1 << 5),
483 };
484
485 /* Cast modifier projection types */
486 enum {
487         MOD_CAST_TYPE_SPHERE   = 0,
488         MOD_CAST_TYPE_CYLINDER = 1,
489         MOD_CAST_TYPE_CUBOID   = 2,
490 };
491
492 typedef struct WaveModifierData {
493         ModifierData modifier;
494
495         /* keep in sync with MappingInfoModifierData */
496         struct Tex *texture;
497         struct Object *map_object;
498         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
499         int uvlayer_tmp;
500         int texmapping;
501         /* end MappingInfoModifierData */
502
503         struct Object *objectcenter;
504         char defgrp_name[64];   /* MAX_VGROUP_NAME */
505
506         short flag, pad;
507
508         float startx, starty, height, width;
509         float narrow, speed, damp, falloff;
510
511         float timeoffs, lifetime;
512         float pad1;
513 } WaveModifierData;
514
515 /* WaveModifierData.flag */
516 enum {
517         /* And what bout (1 << 0) flag? ;) */
518         MOD_WAVE_X      = (1 << 1),
519         MOD_WAVE_Y      = (1 << 2),
520         MOD_WAVE_CYCL   = (1 << 3),
521         MOD_WAVE_NORM   = (1 << 4),
522         MOD_WAVE_NORM_X = (1 << 5),
523         MOD_WAVE_NORM_Y = (1 << 6),
524         MOD_WAVE_NORM_Z = (1 << 7),
525 };
526
527 typedef struct ArmatureModifierData {
528         ModifierData modifier;
529
530         short deformflag, multi;  /* deformflag replaces armature->deformflag */
531         int pad2;
532         struct Object *object;
533         float *prevCos;           /* stored input of previous modifier, for vertexgroup blending */
534         char defgrp_name[64];     /* MAX_VGROUP_NAME */
535 } ArmatureModifierData;
536
537 typedef struct HookModifierData {
538         ModifierData modifier;
539
540         struct Object *object;
541         char subtarget[64];     /* optional name of bone target, MAX_ID_NAME-2 */
542
543         float parentinv[4][4];  /* matrix making current transform unmodified */
544         float cent[3];          /* visualization of hook */
545         float falloff;          /* if not zero, falloff is distance where influence zero */
546
547         int *indexar;           /* if NULL, it's using vertexgroup */
548         int totindex;
549         float force;
550         char name[64];          /* optional vertexgroup name, MAX_VGROUP_NAME */
551 } HookModifierData;
552
553 typedef struct SoftbodyModifierData {
554         ModifierData modifier;
555 } SoftbodyModifierData;
556
557 typedef struct ClothModifierData {
558         ModifierData modifier;
559
560         struct Scene *scene;                  /* the context, time etc is here */
561         struct Cloth *clothObject;            /* The internal data structure for cloth. */
562         struct ClothSimSettings *sim_parms;   /* definition is in DNA_cloth_types.h */
563         struct ClothCollSettings *coll_parms; /* definition is in DNA_cloth_types.h */
564         struct PointCache *point_cache;       /* definition is in DNA_object_force.h */
565         struct ListBase ptcaches;
566 } ClothModifierData;
567
568 typedef struct CollisionModifierData {
569         ModifierData modifier;
570
571         struct MVert *x;            /* position at the beginning of the frame */
572         struct MVert *xnew;         /* position at the end of the frame */
573         struct MVert *xold;         /* unused atm, but was discussed during sprint */
574         struct MVert *current_xnew; /* new position at the actual inter-frame step */
575         struct MVert *current_x;    /* position at the actual inter-frame step */
576         struct MVert *current_v;    /* (xnew - x) at the actual inter-frame step */
577
578         struct MFace *mfaces;       /* object face data */
579
580         unsigned int numverts;
581         unsigned int numfaces;
582         float time_x, time_xnew;    /* cfra time of modifier */
583         struct BVHTree *bvhtree;    /* bounding volume hierarchy for this cloth object */
584 } CollisionModifierData;
585
586 typedef struct SurfaceModifierData {
587         ModifierData modifier;
588
589         struct MVert *x; /* old position */
590         struct MVert *v; /* velocity */
591
592         struct DerivedMesh *dm;
593
594         struct BVHTreeFromMesh *bvhtree; /* bounding volume hierarchy of the mesh faces */
595
596         int cfra, numverts;
597 } SurfaceModifierData;
598
599 typedef struct BooleanModifierData {
600         ModifierData modifier;
601
602         struct Object *object;
603         int operation, pad;
604 } BooleanModifierData;
605
606 typedef enum {
607         eBooleanModifierOp_Intersect  = 0,
608         eBooleanModifierOp_Union      = 1,
609         eBooleanModifierOp_Difference = 2,
610 } BooleanModifierOp;
611
612 typedef struct MDefInfluence {
613         int vertex;
614         float weight;
615 } MDefInfluence;
616
617 typedef struct MDefCell {
618         int offset;
619         int totinfluence;
620 } MDefCell;
621
622 typedef struct MeshDeformModifierData {
623         ModifierData modifier;
624
625         struct Object *object;          /* mesh object */
626         char defgrp_name[64];           /* optional vertexgroup name, MAX_VGROUP_NAME */
627
628         short gridsize, flag, pad[2];
629
630         /* result of static binding */
631         MDefInfluence *bindinfluences;  /* influences */
632         int *bindoffsets;               /* offsets into influences array */
633         float *bindcagecos;             /* coordinates that cage was bound with */
634         int totvert, totcagevert;       /* total vertices in mesh and cage */
635
636         /* result of dynamic binding */
637         MDefCell *dyngrid;              /* grid with dynamic binding cell points */
638         MDefInfluence *dyninfluences;   /* dynamic binding vertex influences */
639         int *dynverts;                  /* is this vertex bound or not? */
640         int dyngridsize;                /* size of the dynamic bind grid */
641         int totinfluence;               /* total number of vertex influences */
642         float dyncellmin[3];            /* offset of the dynamic bind grid */
643         float dyncellwidth;             /* width of dynamic bind cell */
644         float bindmat[4][4];            /* matrix of cage at binding time */
645
646         /* deprecated storage */
647         float *bindweights;             /* deprecated inefficient storage */
648         float *bindcos;                 /* deprecated storage of cage coords */
649
650         /* runtime */
651         void (*bindfunc)(struct Scene *scene, struct MeshDeformModifierData *mmd,
652                          float *vertexcos, int totvert, float cagemat[4][4]);
653 } MeshDeformModifierData;
654
655 enum {
656         MOD_MDEF_INVERT_VGROUP = (1 << 0),
657         MOD_MDEF_DYNAMIC_BIND  = (1 << 1),
658 };
659
660 enum {
661         MOD_MDEF_VOLUME   = 0,
662         MOD_MDEF_SURFACE  = 1,
663 };
664
665 typedef struct ParticleSystemModifierData {
666         ModifierData modifier;
667
668         struct ParticleSystem *psys;
669         struct DerivedMesh *dm;
670         int totdmvert, totdmedge, totdmface;
671         short flag, pad;
672 } ParticleSystemModifierData;
673
674 typedef enum {
675         eParticleSystemFlag_Pars         = (1 << 0),
676         eParticleSystemFlag_psys_updated = (1 << 1),
677         eParticleSystemFlag_file_loaded  = (1 << 2),
678 } ParticleSystemModifierFlag;
679
680 typedef enum {
681         eParticleInstanceFlag_Parents   = (1 << 0),
682         eParticleInstanceFlag_Children  = (1 << 1),
683         eParticleInstanceFlag_Path      = (1 << 2),
684         eParticleInstanceFlag_Unborn    = (1 << 3),
685         eParticleInstanceFlag_Alive     = (1 << 4),
686         eParticleInstanceFlag_Dead      = (1 << 5),
687         eParticleInstanceFlag_KeepShape = (1 << 6),
688         eParticleInstanceFlag_UseSize   = (1 << 7),
689 } ParticleInstanceModifierFlag;
690
691 typedef struct ParticleInstanceModifierData {
692         ModifierData modifier;
693
694         struct Object *ob;
695         short psys, flag, axis, pad;
696         float position, random_position;
697 } ParticleInstanceModifierData;
698
699 typedef enum {
700         eExplodeFlag_CalcFaces = (1 << 0),
701         eExplodeFlag_PaSize    = (1 << 1),
702         eExplodeFlag_EdgeCut   = (1 << 2),
703         eExplodeFlag_Unborn    = (1 << 3),
704         eExplodeFlag_Alive     = (1 << 4),
705         eExplodeFlag_Dead      = (1 << 5),
706 } ExplodeModifierFlag;
707
708 typedef struct ExplodeModifierData {
709         ModifierData modifier;
710
711         int *facepa;
712         short flag, vgroup;
713         float protect;
714         char uvname[64]; /* MAX_CUSTOMDATA_LAYER_NAME */
715 } ExplodeModifierData;
716
717 typedef struct MultiresModifierData {
718         ModifierData modifier;
719
720         char lvl, sculptlvl, renderlvl, totlvl;
721         char simple, flags, pad[2];
722 } MultiresModifierData;
723
724 typedef enum {
725         eMultiresModifierFlag_ControlEdges = (1 << 0),
726         eMultiresModifierFlag_PlainUv      = (1 << 1),
727 } MultiresModifierFlag;
728
729 typedef struct FluidsimModifierData {
730         ModifierData modifier;
731
732         struct FluidsimSettings *fss;   /* definition is in DNA_object_fluidsim.h */
733         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
734 } FluidsimModifierData;
735
736 typedef struct ShrinkwrapModifierData {
737         ModifierData modifier;
738
739         struct Object *target;    /* shrink target */
740         struct Object *auxTarget; /* additional shrink target */
741         char vgroup_name[64];     /* optional vertexgroup name, MAX_VGROUP_NAME */
742         float keepDist;           /* distance offset to keep from mesh/projection point */
743         short shrinkType;         /* shrink type projection */
744         char  shrinkOpts;         /* shrink options */
745         char  pad1;
746         float projLimit;          /* limit the projection ray cast */
747         char  projAxis;           /* axis to project over */
748
749         /* If using projection over vertex normal this controls the level of subsurface that must be done
750          * before getting the vertex coordinates and normal
751          */
752         char subsurfLevels;
753
754         char pad[2];
755 } ShrinkwrapModifierData;
756
757 /* Shrinkwrap->shrinkType */
758 enum {
759         MOD_SHRINKWRAP_NEAREST_SURFACE = 0,
760         MOD_SHRINKWRAP_PROJECT         = 1,
761         MOD_SHRINKWRAP_NEAREST_VERTEX  = 2,
762 };
763
764 /* Shrinkwrap->shrinkOpts */
765 enum {
766         /* allow shrinkwrap to move the vertex in the positive direction of axis */
767         MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR = (1 << 0),
768         /* allow shrinkwrap to move the vertex in the negative direction of axis */
769         MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR = (1 << 1),
770
771         /* ignore vertex moves if a vertex ends projected on a front face of the target */
772         MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE = (1 << 3),
773         /* ignore vertex moves if a vertex ends projected on a back face of the target */
774         MOD_SHRINKWRAP_CULL_TARGET_BACKFACE  = (1 << 4),
775
776         MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE    = (1 << 5),  /* distance is measure to the front face of the target */
777 };
778
779 /* Shrinkwrap->projAxis */
780 enum {
781         MOD_SHRINKWRAP_PROJECT_OVER_NORMAL   = 0,        /* projection over normal is used if no axis is selected */
782         MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS   = (1 << 0),
783         MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS   = (1 << 1),
784         MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS   = (1 << 2),
785 };
786
787
788 typedef struct SimpleDeformModifierData {
789         ModifierData modifier;
790
791         struct Object *origin;  /* object to control the origin of modifier space coordinates */
792         char vgroup_name[64];   /* optional vertexgroup name, MAX_VGROUP_NAME */
793         float factor;           /* factors to control simple deforms */
794         float limit[2];         /* lower and upper limit */
795
796         char mode;              /* deform function */
797         char axis;              /* lock axis (for taper and strech) */
798         char pad[2];
799
800 } SimpleDeformModifierData;
801
802 enum {
803         MOD_SIMPLEDEFORM_MODE_TWIST   = 1,
804         MOD_SIMPLEDEFORM_MODE_BEND    = 2,
805         MOD_SIMPLEDEFORM_MODE_TAPER   = 3,
806         MOD_SIMPLEDEFORM_MODE_STRETCH = 4,
807 };
808
809 enum {
810         MOD_SIMPLEDEFORM_LOCK_AXIS_X = (1 << 0),
811         MOD_SIMPLEDEFORM_LOCK_AXIS_Y = (1 << 1),
812 };
813
814 typedef struct ShapeKeyModifierData {
815         ModifierData modifier;
816 } ShapeKeyModifierData;
817
818 typedef struct SolidifyModifierData {
819         ModifierData modifier;
820
821         char defgrp_name[64];   /* name of vertex group to use, MAX_VGROUP_NAME */
822         float offset;           /* new surface offset level*/
823         float offset_fac;       /* midpoint of the offset  */
824         /* factor for the minimum weight to use when vgroups are used, avoids 0.0 weights giving duplicate geometry */
825         float offset_fac_vg;
826         float offset_clamp;     /* clamp offset based on surrounding geometry */
827         float pad;
828         float crease_inner;
829         float crease_outer;
830         float crease_rim;
831         int flag;
832         short mat_ofs;
833         short mat_ofs_rim;
834 } SolidifyModifierData;
835
836 enum {
837         MOD_SOLIDIFY_RIM            = (1 << 0),
838         MOD_SOLIDIFY_EVEN           = (1 << 1),
839         MOD_SOLIDIFY_NORMAL_CALC    = (1 << 2),
840         MOD_SOLIDIFY_VGROUP_INV     = (1 << 3),
841         MOD_SOLIDIFY_RIM_MATERIAL   = (1 << 4),  /* deprecated, used in do_versions */
842         MOD_SOLIDIFY_FLIP           = (1 << 5),
843         MOD_SOLIDIFY_NOSHELL        = (1 << 6),
844 };
845
846 #if (DNA_DEPRECATED_GCC_POISON == 1)
847 #pragma GCC poison MOD_SOLIDIFY_RIM_MATERIAL
848 #endif
849
850 typedef struct ScrewModifierData {
851         ModifierData modifier;
852
853         struct Object *ob_axis;
854         unsigned int steps;
855         unsigned int render_steps;
856         unsigned int iter;
857         float screw_ofs;
858         float angle;
859         char axis;
860         char pad;
861         short flag;
862 } ScrewModifierData;
863
864 enum {
865         MOD_SCREW_NORMAL_FLIP    = (1 << 0),
866         MOD_SCREW_NORMAL_CALC    = (1 << 1),
867         MOD_SCREW_OBJECT_OFFSET  = (1 << 2),
868 /*      MOD_SCREW_OBJECT_ANGLE   = (1 << 4), */
869         MOD_SCREW_SMOOTH_SHADING = (1 << 5),
870         MOD_SCREW_UV_STRETCH_U   = (1 << 6),
871         MOD_SCREW_UV_STRETCH_V   = (1 << 7),
872 };
873
874 typedef struct OceanModifierData {
875         ModifierData modifier;
876
877         struct Ocean *ocean;
878         struct OceanCache *oceancache;
879         
880         int resolution;
881         int spatial_size;
882
883         float wind_velocity;
884
885         float damp;
886         float smallest_wave;
887         float depth;
888
889         float wave_alignment;
890         float wave_direction;
891         float wave_scale;
892
893         float chop_amount;
894         float foam_coverage;
895         float time;
896
897         int bakestart;
898         int bakeend;
899
900         char cachepath[1024];    /* FILE_MAX */
901         char foamlayername[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
902         char cached;
903         char geometry_mode;
904
905         char flag;
906         char refresh;
907
908         short repeat_x;
909         short repeat_y;
910
911         int seed;
912
913         float size;
914
915         float foam_fade;
916
917         int pad;
918 } OceanModifierData;
919
920 enum {
921         MOD_OCEAN_GEOM_GENERATE = 0,
922         MOD_OCEAN_GEOM_DISPLACE = 1,
923         MOD_OCEAN_GEOM_SIM_ONLY = 2,
924 };
925
926 enum {
927         MOD_OCEAN_REFRESH_RESET        = (1 << 0),
928         MOD_OCEAN_REFRESH_SIM          = (1 << 1),
929         MOD_OCEAN_REFRESH_ADD          = (1 << 2),
930         MOD_OCEAN_REFRESH_CLEAR_CACHE  = (1 << 3),
931         MOD_OCEAN_REFRESH_TOPOLOGY     = (1 << 4),
932 };
933
934 enum {
935         MOD_OCEAN_GENERATE_FOAM     = (1 << 0),
936         MOD_OCEAN_GENERATE_NORMALS  = (1 << 1),
937 };
938
939 typedef struct WarpModifierData {
940         ModifierData modifier;
941         /* keep in sync with MappingInfoModifierData */
942         struct Tex *texture;
943         struct Object *map_object;
944         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
945         int uvlayer_tmp;
946         int texmapping;
947         /* end MappingInfoModifierData */
948
949         struct Object *object_from;
950         struct Object *object_to;
951         struct CurveMapping *curfalloff;
952         char defgrp_name[64];  /* optional vertexgroup name, MAX_VGROUP_NAME */
953         float strength;
954         float falloff_radius;
955         char flag; /* not used yet */
956         char falloff_type;
957         char pad[6];
958 } WarpModifierData;
959
960 #define MOD_WARP_VOLUME_PRESERVE 1
961
962 typedef enum {
963         eWarp_Falloff_None   = 0,
964         eWarp_Falloff_Curve  = 1,
965         eWarp_Falloff_Sharp  = 2, /* PROP_SHARP */
966         eWarp_Falloff_Smooth = 3, /* PROP_SMOOTH */
967         eWarp_Falloff_Root   = 4, /* PROP_ROOT */
968         eWarp_Falloff_Linear = 5, /* PROP_LIN */
969         eWarp_Falloff_Const  = 6, /* PROP_CONST */
970         eWarp_Falloff_Sphere = 7, /* PROP_SPHERE */
971         /* PROP_RANDOM not used */
972 } WarpModifierFalloff;
973
974 typedef struct WeightVGEditModifierData {
975         ModifierData modifier;
976
977         char defgrp_name[64]; /* Name of vertex group to edit. MAX_VGROUP_NAME. */
978
979         short edit_flags;     /* Using MOD_WVG_EDIT_* flags. */
980         short falloff_type;   /* Using MOD_WVG_MAPPING_* defines. */
981         float default_weight; /* Weight for vertices not in vgroup. */
982
983         /* Mapping stuff. */
984         struct CurveMapping *cmap_curve;  /* The custom mapping curve! */
985
986         /* The add/remove vertices weight thresholds. */
987         float add_threshold, rem_threshold;
988
989         /* Masking options. */
990         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
991         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
992
993         /* Texture masking. */
994         int mask_tex_use_channel;          /* Which channel to use as weightf. */
995         struct Tex *mask_texture;          /* The texture. */
996         struct Object *mask_tex_map_obj;   /* Name of the map object. */
997         int mask_tex_mapping;              /* How to map the texture (using MOD_DISP_MAP_* enums). */
998         char mask_tex_uvlayer_name[64];    /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME */
999
1000         /* Padding... */
1001         int pad_i1;
1002 } WeightVGEditModifierData;
1003
1004 /* WeightVGEdit flags. */
1005 enum {
1006         /* (1 << 0), (1 << 1) and (1 << 2) are free for future use! */
1007         MOD_WVG_EDIT_ADD2VG  = (1 << 3),  /* Add vertices with higher weight than threshold to vgroup. */
1008         MOD_WVG_EDIT_REMFVG  = (1 << 4),  /* Remove vertices with lower weight than threshold from vgroup. */
1009 };
1010
1011 typedef struct WeightVGMixModifierData {
1012         ModifierData modifier;
1013
1014         char defgrp_name_a[64];    /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1015         char defgrp_name_b[64];    /* Name of other vertex group to mix in. MAX_VGROUP_NAME. */
1016         float default_weight_a;    /* Default weight value for first vgroup. */
1017         float default_weight_b;    /* Default weight value to mix in. */
1018         char mix_mode;             /* How second vgroups weights affect first ones */
1019         char mix_set;              /* What vertices to affect. */
1020
1021         char pad_c1[6];
1022
1023         /* Masking options. */
1024         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1025         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1026
1027         /* Texture masking. */
1028         int mask_tex_use_channel;         /* Which channel to use as weightf. */
1029         struct Tex *mask_texture;         /* The texture. */
1030         struct Object *mask_tex_map_obj;  /* Name of the map object. */
1031         int mask_tex_mapping;             /* How to map the texture! */
1032         char mask_tex_uvlayer_name[64];   /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */
1033
1034         /* Padding... */
1035         int pad_i1;
1036 } WeightVGMixModifierData;
1037
1038 /* How second vgroup's weights affect first ones. */
1039 enum {
1040         MOD_WVG_MIX_SET = 1,  /* Second weights replace weights. */
1041         MOD_WVG_MIX_ADD = 2,  /* Second weights are added to weights. */
1042         MOD_WVG_MIX_SUB = 3,  /* Second weights are subtracted from weights. */
1043         MOD_WVG_MIX_MUL = 4,  /* Second weights are multiplied with weights. */
1044         MOD_WVG_MIX_DIV = 5,  /* Second weights divide weights. */
1045         MOD_WVG_MIX_DIF = 6,  /* Difference between second weights and weights. */
1046         MOD_WVG_MIX_AVG = 7,  /* Average of both weights. */
1047 };
1048
1049 /* What vertices to affect. */
1050 enum {
1051         MOD_WVG_SET_ALL = 1,  /* Affect all vertices. */
1052         MOD_WVG_SET_A   = 2,  /* Affect only vertices in first vgroup. */
1053         MOD_WVG_SET_B   = 3,  /* Affect only vertices in second vgroup. */
1054         MOD_WVG_SET_OR  = 4,  /* Affect only vertices in one vgroup or the other. */
1055         MOD_WVG_SET_AND = 5,  /* Affect only vertices in both vgroups. */
1056 };
1057
1058 typedef struct WeightVGProximityModifierData {
1059         ModifierData modifier;
1060
1061         char defgrp_name[64];      /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1062
1063         /* Proximity modes. */
1064         int proximity_mode;
1065         int proximity_flags;
1066
1067         /* Target object from which to calculate vertices distances. */
1068         struct Object *proximity_ob_target;
1069
1070         /* Masking options. */
1071         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1072         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1073
1074         /* Texture masking. */
1075         int mask_tex_use_channel;        /* Which channel to use as weightf. */
1076         struct Tex *mask_texture;        /* The texture. */
1077         struct Object *mask_tex_map_obj; /* Name of the map object. */
1078         int mask_tex_mapping;            /* How to map the texture! */
1079         char mask_tex_uvlayer_name[64];  /* Name of the UV Map. MAX_CUSTOMDATA_LAYER_NAME. */
1080
1081         float min_dist, max_dist;        /* Distances mapping to 0.0/1.0 weights. */
1082
1083         /* Put here to avoid breaking existing struct... */
1084         short falloff_type;              /* Using MOD_WVG_MAPPING_* enums. */
1085
1086         /* Padding... */
1087         short pad_s1;
1088 } WeightVGProximityModifierData;
1089
1090 /* Modes of proximity weighting. */
1091 enum {
1092         MOD_WVG_PROXIMITY_OBJECT    = 1,  /* source vertex to other location */
1093         MOD_WVG_PROXIMITY_GEOMETRY  = 2,  /* source vertex to other geometry */
1094 };
1095
1096 /* Flags options for proximity weighting. */
1097 enum {
1098         /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1099         MOD_WVG_PROXIMITY_GEOM_VERTS  = (1 << 0),
1100         /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1101         MOD_WVG_PROXIMITY_GEOM_EDGES  = (1 << 1),
1102         /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1103         MOD_WVG_PROXIMITY_GEOM_FACES  = (1 << 2),
1104 };
1105
1106 /* Defines common to all WeightVG modifiers. */
1107 /* Mapping modes. */
1108 enum {
1109         MOD_WVG_MAPPING_NONE    = 0,
1110         MOD_WVG_MAPPING_CURVE   = 1,
1111         MOD_WVG_MAPPING_SHARP   = 2,  /* PROP_SHARP */
1112         MOD_WVG_MAPPING_SMOOTH  = 3,  /* PROP_SMOOTH */
1113         MOD_WVG_MAPPING_ROOT    = 4,  /* PROP_ROOT */
1114         /* PROP_LIN not used (same as NONE, here...). */
1115         /* PROP_CONST not used. */
1116         MOD_WVG_MAPPING_SPHERE  = 7,  /* PROP_SPHERE */
1117         MOD_WVG_MAPPING_RANDOM  = 8,  /* PROP_RANDOM */
1118         MOD_WVG_MAPPING_STEP    = 9,  /* Median Step. */
1119 };
1120
1121 /* Tex channel to be used as mask. */
1122 enum {
1123         MOD_WVG_MASK_TEX_USE_INT    = 1,
1124         MOD_WVG_MASK_TEX_USE_RED    = 2,
1125         MOD_WVG_MASK_TEX_USE_GREEN  = 3,
1126         MOD_WVG_MASK_TEX_USE_BLUE   = 4,
1127         MOD_WVG_MASK_TEX_USE_HUE    = 5,
1128         MOD_WVG_MASK_TEX_USE_SAT    = 6,
1129         MOD_WVG_MASK_TEX_USE_VAL    = 7,
1130         MOD_WVG_MASK_TEX_USE_ALPHA  = 8,
1131 };
1132
1133 typedef struct DynamicPaintModifierData {
1134         ModifierData modifier;
1135
1136         struct DynamicPaintCanvasSettings *canvas;
1137         struct DynamicPaintBrushSettings *brush;
1138         int type;  /* ui display: canvas / brush */
1139         int pad;
1140 } DynamicPaintModifierData;
1141
1142 /* Dynamic paint modifier flags */
1143 enum {
1144         MOD_DYNAMICPAINT_TYPE_CANVAS  = (1 << 0),
1145         MOD_DYNAMICPAINT_TYPE_BRUSH   = (1 << 1),
1146 };
1147
1148 /* Remesh modifier */
1149 typedef enum RemeshModifierFlags {
1150         MOD_REMESH_FLOOD_FILL     = 1,
1151         MOD_REMESH_SMOOTH_SHADING = 2,
1152 } RemeshModifierFlags;
1153
1154 typedef enum RemeshModifierMode {
1155         /* blocky */
1156         MOD_REMESH_CENTROID       = 0,
1157         /* smooth */
1158         MOD_REMESH_MASS_POINT     = 1,
1159         /* keeps sharp edges */
1160         MOD_REMESH_SHARP_FEATURES = 2,
1161 } RemeshModifierMode;
1162
1163 typedef struct RemeshModifierData {
1164         ModifierData modifier;
1165
1166         /* floodfill option, controls how small components can be before they are removed */
1167         float threshold;
1168
1169         /* ratio between size of model and grid */
1170         float scale;
1171
1172         float hermite_num;
1173
1174         /* octree depth */
1175         char depth;
1176
1177         char flag;
1178         char mode;
1179         char pad;
1180 } RemeshModifierData;
1181
1182 /* Skin modifier */
1183 typedef struct SkinModifierData {
1184         ModifierData modifier;
1185
1186         float branch_smoothing;
1187
1188         char flag;
1189
1190         char symmetry_axes;
1191
1192         char pad[2];
1193 } SkinModifierData;
1194
1195 /* SkinModifierData.symmetry_axes */
1196 enum {
1197         MOD_SKIN_SYMM_X = (1 << 0),
1198         MOD_SKIN_SYMM_Y = (1 << 1),
1199         MOD_SKIN_SYMM_Z = (1 << 2),
1200 };
1201
1202 /* SkinModifierData.flag */
1203 enum {
1204         MOD_SKIN_SMOOTH_SHADING = 1,
1205 };
1206
1207 /* Triangulate modifier */
1208 typedef struct TriangulateModifierData {
1209         ModifierData modifier;
1210
1211         int flag;
1212         int quad_method;
1213         int ngon_method;
1214         int pad;
1215 } TriangulateModifierData;
1216
1217 enum {
1218         MOD_TRIANGULATE_BEAUTY = (1 << 0), /* deprecated */
1219 };
1220
1221 #if (DNA_DEPRECATED_GCC_POISON == 1)
1222 #pragma GCC poison MOD_TRIANGULATE_BEAUTY
1223 #endif
1224
1225 /* Triangulate methods - NGons */
1226 enum {
1227         MOD_TRIANGULATE_NGON_BEAUTY = 0,
1228         MOD_TRIANGULATE_NGON_EARCLIP,
1229 };
1230
1231 /* Triangulate methods - Quads */
1232 enum {
1233         MOD_TRIANGULATE_QUAD_BEAUTY = 0,
1234         MOD_TRIANGULATE_QUAD_FIXED,
1235         MOD_TRIANGULATE_QUAD_ALTERNATE,
1236         MOD_TRIANGULATE_QUAD_SHORTEDGE
1237 };
1238
1239 typedef struct LaplacianSmoothModifierData {
1240         ModifierData modifier;
1241
1242         float lambda, lambda_border, pad1;
1243         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1244         short flag, repeat;
1245 } LaplacianSmoothModifierData;
1246
1247 /* Smooth modifier flags */
1248 enum {
1249         MOD_LAPLACIANSMOOTH_X               = (1 << 1),
1250         MOD_LAPLACIANSMOOTH_Y               = (1 << 2),
1251         MOD_LAPLACIANSMOOTH_Z               = (1 << 3),
1252         MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME = (1 << 4),
1253         MOD_LAPLACIANSMOOTH_NORMALIZED      = (1 << 5),
1254 };
1255
1256 typedef struct UVWarpModifierData {
1257         ModifierData modifier;
1258
1259         char axis_u, axis_v;
1260         char pad[6];
1261         float center[2];            /* used for rotate/scale */
1262
1263         struct Object *object_src;  /* source */
1264         char bone_src[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1265         struct Object *object_dst;  /* target */
1266         char bone_dst[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1267
1268         char vgroup_name[64];       /* optional vertexgroup name, MAX_VGROUP_NAME */
1269         char uvlayer_name[64];      /* MAX_CUSTOMDATA_LAYER_NAME */
1270 } UVWarpModifierData;
1271
1272 /* cache modifier */
1273 typedef struct MeshCacheModifierData {
1274         ModifierData modifier;
1275
1276         char flag;
1277         char type;  /* file format */
1278         char time_mode;
1279         char play_mode;
1280
1281         /* axis conversion */
1282         char forward_axis;
1283         char up_axis;
1284         char flip_axis;
1285
1286         char interp;
1287
1288         float factor;
1289         char deform_mode;
1290         char pad[7];
1291
1292         /* play_mode == MOD_MESHCACHE_PLAY_CFEA */
1293         float frame_start;
1294         float frame_scale;
1295
1296         /* play_mode == MOD_MESHCACHE_PLAY_EVAL */
1297         /* we could use one float for all these but their purpose is very different */
1298         float eval_frame;
1299         float eval_time;
1300         float eval_factor;
1301
1302         char filepath[1024];  /* FILE_MAX */
1303 } MeshCacheModifierData;
1304
1305 enum {
1306         MOD_MESHCACHE_TYPE_MDD  = 1,
1307         MOD_MESHCACHE_TYPE_PC2  = 2,
1308 };
1309
1310 enum {
1311         MOD_MESHCACHE_DEFORM_OVERWRITE  = 0,
1312         MOD_MESHCACHE_DEFORM_INTEGRATE  = 1,
1313 };
1314
1315 enum {
1316         MOD_MESHCACHE_INTERP_NONE      = 0,
1317         MOD_MESHCACHE_INTERP_LINEAR    = 1,
1318 /*      MOD_MESHCACHE_INTERP_CARDINAL  = 2, */
1319 };
1320
1321 enum {
1322         MOD_MESHCACHE_TIME_FRAME   = 0,
1323         MOD_MESHCACHE_TIME_SECONDS = 1,
1324         MOD_MESHCACHE_TIME_FACTOR  = 2,
1325 };
1326
1327 enum {
1328         MOD_MESHCACHE_PLAY_CFEA = 0,
1329         MOD_MESHCACHE_PLAY_EVAL = 1,
1330 };
1331
1332
1333 typedef struct LaplacianDeformModifierData {
1334         ModifierData modifier;
1335         char anchor_grp_name[64];  /* MAX_VGROUP_NAME */
1336         int total_verts, repeat;
1337         float *vertexco;
1338         void *cache_system;  /* runtime only */
1339         short flag, pad[3];
1340
1341 } LaplacianDeformModifierData;
1342
1343 /* Smooth modifier flags */
1344 enum {
1345         MOD_LAPLACIANDEFORM_BIND = 1,
1346 };
1347
1348 /* many of these options match 'solidify' */
1349 typedef struct WireframeModifierData {
1350         ModifierData modifier;
1351         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1352         float offset;
1353         float offset_fac;
1354         float offset_fac_vg;
1355         float crease_weight;
1356         short flag, mat_ofs;
1357         short pad[2];
1358 } WireframeModifierData;
1359
1360 enum {
1361         MOD_WIREFRAME_INVERT_VGROUP = (1 << 0),
1362         MOD_WIREFRAME_REPLACE       = (1 << 1),
1363         MOD_WIREFRAME_BOUNDARY      = (1 << 2),
1364         MOD_WIREFRAME_OFS_EVEN      = (1 << 3),
1365         MOD_WIREFRAME_OFS_RELATIVE  = (1 << 4),
1366         MOD_WIREFRAME_CREASE        = (1 << 5),
1367 };
1368
1369
1370
1371 #endif  /* __DNA_MODIFIER_TYPES_H__ */