Comments
[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         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 };
844
845 #if (DNA_DEPRECATED_GCC_POISON == 1)
846 #pragma GCC poison MOD_SOLIDIFY_RIM_MATERIAL
847 #endif
848
849 typedef struct ScrewModifierData {
850         ModifierData modifier;
851
852         struct Object *ob_axis;
853         unsigned int steps;
854         unsigned int render_steps;
855         unsigned int iter;
856         float screw_ofs;
857         float angle;
858         char axis;
859         char pad;
860         short flag;
861 } ScrewModifierData;
862
863 enum {
864         MOD_SCREW_NORMAL_FLIP    = (1 << 0),
865         MOD_SCREW_NORMAL_CALC    = (1 << 1),
866         MOD_SCREW_OBJECT_OFFSET  = (1 << 2),
867 /*      MOD_SCREW_OBJECT_ANGLE   = (1 << 4), */
868         MOD_SCREW_SMOOTH_SHADING = (1 << 5),
869         MOD_SCREW_UV_STRETCH_U   = (1 << 6),
870         MOD_SCREW_UV_STRETCH_V   = (1 << 7),
871 };
872
873 typedef struct OceanModifierData {
874         ModifierData modifier;
875
876         struct Ocean *ocean;
877         struct OceanCache *oceancache;
878         
879         int resolution;
880         int spatial_size;
881
882         float wind_velocity;
883
884         float damp;
885         float smallest_wave;
886         float depth;
887
888         float wave_alignment;
889         float wave_direction;
890         float wave_scale;
891
892         float chop_amount;
893         float foam_coverage;
894         float time;
895
896         int bakestart;
897         int bakeend;
898
899         char cachepath[1024];    /* FILE_MAX */
900         char foamlayername[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
901         char cached;
902         char geometry_mode;
903
904         char flag;
905         char refresh;
906
907         short repeat_x;
908         short repeat_y;
909
910         int seed;
911
912         float size;
913
914         float foam_fade;
915
916         int pad;
917 } OceanModifierData;
918
919 enum {
920         MOD_OCEAN_GEOM_GENERATE = 0,
921         MOD_OCEAN_GEOM_DISPLACE = 1,
922         MOD_OCEAN_GEOM_SIM_ONLY = 2,
923 };
924
925 enum {
926         MOD_OCEAN_REFRESH_RESET        = (1 << 0),
927         MOD_OCEAN_REFRESH_SIM          = (1 << 1),
928         MOD_OCEAN_REFRESH_ADD          = (1 << 2),
929         MOD_OCEAN_REFRESH_CLEAR_CACHE  = (1 << 3),
930         MOD_OCEAN_REFRESH_TOPOLOGY     = (1 << 4),
931 };
932
933 enum {
934         MOD_OCEAN_GENERATE_FOAM     = (1 << 0),
935         MOD_OCEAN_GENERATE_NORMALS  = (1 << 1),
936 };
937
938 typedef struct WarpModifierData {
939         ModifierData modifier;
940         /* keep in sync with MappingInfoModifierData */
941         struct Tex *texture;
942         struct Object *map_object;
943         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
944         int uvlayer_tmp;
945         int texmapping;
946         /* end MappingInfoModifierData */
947
948         struct Object *object_from;
949         struct Object *object_to;
950         struct CurveMapping *curfalloff;
951         char defgrp_name[64];  /* optional vertexgroup name, MAX_VGROUP_NAME */
952         float strength;
953         float falloff_radius;
954         char flag; /* not used yet */
955         char falloff_type;
956         char pad[6];
957 } WarpModifierData;
958
959 #define MOD_WARP_VOLUME_PRESERVE 1
960
961 typedef enum {
962         eWarp_Falloff_None   = 0,
963         eWarp_Falloff_Curve  = 1,
964         eWarp_Falloff_Sharp  = 2, /* PROP_SHARP */
965         eWarp_Falloff_Smooth = 3, /* PROP_SMOOTH */
966         eWarp_Falloff_Root   = 4, /* PROP_ROOT */
967         eWarp_Falloff_Linear = 5, /* PROP_LIN */
968         eWarp_Falloff_Const  = 6, /* PROP_CONST */
969         eWarp_Falloff_Sphere = 7, /* PROP_SPHERE */
970         /* PROP_RANDOM not used */
971 } WarpModifierFalloff;
972
973 typedef struct WeightVGEditModifierData {
974         ModifierData modifier;
975
976         char defgrp_name[64]; /* Name of vertex group to edit. MAX_VGROUP_NAME. */
977
978         short edit_flags;     /* Using MOD_WVG_EDIT_* flags. */
979         short falloff_type;   /* Using MOD_WVG_MAPPING_* defines. */
980         float default_weight; /* Weight for vertices not in vgroup. */
981
982         /* Mapping stuff. */
983         struct CurveMapping *cmap_curve;  /* The custom mapping curve! */
984
985         /* The add/remove vertices weight thresholds. */
986         float add_threshold, rem_threshold;
987
988         /* Masking options. */
989         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
990         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
991
992         /* Texture masking. */
993         int mask_tex_use_channel;          /* Which channel to use as weightf. */
994         struct Tex *mask_texture;          /* The texture. */
995         struct Object *mask_tex_map_obj;   /* Name of the map object. */
996         int mask_tex_mapping;              /* How to map the texture (using MOD_DISP_MAP_* enums). */
997         char mask_tex_uvlayer_name[64];    /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME */
998
999         /* Padding... */
1000         int pad_i1;
1001 } WeightVGEditModifierData;
1002
1003 /* WeightVGEdit flags. */
1004 enum {
1005         /* (1 << 0), (1 << 1) and (1 << 2) are free for future use! */
1006         MOD_WVG_EDIT_ADD2VG  = (1 << 3),  /* Add vertices with higher weight than threshold to vgroup. */
1007         MOD_WVG_EDIT_REMFVG  = (1 << 4),  /* Remove vertices with lower weight than threshold from vgroup. */
1008 };
1009
1010 typedef struct WeightVGMixModifierData {
1011         ModifierData modifier;
1012
1013         char defgrp_name_a[64];    /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1014         char defgrp_name_b[64];    /* Name of other vertex group to mix in. MAX_VGROUP_NAME. */
1015         float default_weight_a;    /* Default weight value for first vgroup. */
1016         float default_weight_b;    /* Default weight value to mix in. */
1017         char mix_mode;             /* How second vgroups weights affect first ones */
1018         char mix_set;              /* What vertices to affect. */
1019
1020         char pad_c1[6];
1021
1022         /* Masking options. */
1023         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1024         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1025
1026         /* Texture masking. */
1027         int mask_tex_use_channel;         /* Which channel to use as weightf. */
1028         struct Tex *mask_texture;         /* The texture. */
1029         struct Object *mask_tex_map_obj;  /* Name of the map object. */
1030         int mask_tex_mapping;             /* How to map the texture! */
1031         char mask_tex_uvlayer_name[64];   /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */
1032
1033         /* Padding... */
1034         int pad_i1;
1035 } WeightVGMixModifierData;
1036
1037 /* How second vgroup's weights affect first ones. */
1038 enum {
1039         MOD_WVG_MIX_SET = 1,  /* Second weights replace weights. */
1040         MOD_WVG_MIX_ADD = 2,  /* Second weights are added to weights. */
1041         MOD_WVG_MIX_SUB = 3,  /* Second weights are subtracted from weights. */
1042         MOD_WVG_MIX_MUL = 4,  /* Second weights are multiplied with weights. */
1043         MOD_WVG_MIX_DIV = 5,  /* Second weights divide weights. */
1044         MOD_WVG_MIX_DIF = 6,  /* Difference between second weights and weights. */
1045         MOD_WVG_MIX_AVG = 7,  /* Average of both weights. */
1046 };
1047
1048 /* What vertices to affect. */
1049 enum {
1050         MOD_WVG_SET_ALL = 1,  /* Affect all vertices. */
1051         MOD_WVG_SET_A   = 2,  /* Affect only vertices in first vgroup. */
1052         MOD_WVG_SET_B   = 3,  /* Affect only vertices in second vgroup. */
1053         MOD_WVG_SET_OR  = 4,  /* Affect only vertices in one vgroup or the other. */
1054         MOD_WVG_SET_AND = 5,  /* Affect only vertices in both vgroups. */
1055 };
1056
1057 typedef struct WeightVGProximityModifierData {
1058         ModifierData modifier;
1059
1060         char defgrp_name[64];      /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1061
1062         /* Proximity modes. */
1063         int proximity_mode;
1064         int proximity_flags;
1065
1066         /* Target object from which to calculate vertices distances. */
1067         struct Object *proximity_ob_target;
1068
1069         /* Masking options. */
1070         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1071         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1072
1073         /* Texture masking. */
1074         int mask_tex_use_channel;        /* Which channel to use as weightf. */
1075         struct Tex *mask_texture;        /* The texture. */
1076         struct Object *mask_tex_map_obj; /* Name of the map object. */
1077         int mask_tex_mapping;            /* How to map the texture! */
1078         char mask_tex_uvlayer_name[64];  /* Name of the UV Map. MAX_CUSTOMDATA_LAYER_NAME. */
1079
1080         float min_dist, max_dist;        /* Distances mapping to 0.0/1.0 weights. */
1081
1082         /* Put here to avoid breaking existing struct... */
1083         short falloff_type;              /* Using MOD_WVG_MAPPING_* enums. */
1084
1085         /* Padding... */
1086         short pad_s1;
1087 } WeightVGProximityModifierData;
1088
1089 /* Modes of proximity weighting. */
1090 enum {
1091         MOD_WVG_PROXIMITY_OBJECT    = 1,  /* source vertex to other location */
1092         MOD_WVG_PROXIMITY_GEOMETRY  = 2,  /* source vertex to other geometry */
1093 };
1094
1095 /* Flags options for proximity weighting. */
1096 enum {
1097         /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1098         MOD_WVG_PROXIMITY_GEOM_VERTS  = (1 << 0),
1099         /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1100         MOD_WVG_PROXIMITY_GEOM_EDGES  = (1 << 1),
1101         /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1102         MOD_WVG_PROXIMITY_GEOM_FACES  = (1 << 2),
1103 };
1104
1105 /* Defines common to all WeightVG modifiers. */
1106 /* Mapping modes. */
1107 enum {
1108         MOD_WVG_MAPPING_NONE    = 0,
1109         MOD_WVG_MAPPING_CURVE   = 1,
1110         MOD_WVG_MAPPING_SHARP   = 2,  /* PROP_SHARP */
1111         MOD_WVG_MAPPING_SMOOTH  = 3,  /* PROP_SMOOTH */
1112         MOD_WVG_MAPPING_ROOT    = 4,  /* PROP_ROOT */
1113         /* PROP_LIN not used (same as NONE, here...). */
1114         /* PROP_CONST not used. */
1115         MOD_WVG_MAPPING_SPHERE  = 7,  /* PROP_SPHERE */
1116         MOD_WVG_MAPPING_RANDOM  = 8,  /* PROP_RANDOM */
1117         MOD_WVG_MAPPING_STEP    = 9,  /* Median Step. */
1118 };
1119
1120 /* Tex channel to be used as mask. */
1121 enum {
1122         MOD_WVG_MASK_TEX_USE_INT    = 1,
1123         MOD_WVG_MASK_TEX_USE_RED    = 2,
1124         MOD_WVG_MASK_TEX_USE_GREEN  = 3,
1125         MOD_WVG_MASK_TEX_USE_BLUE   = 4,
1126         MOD_WVG_MASK_TEX_USE_HUE    = 5,
1127         MOD_WVG_MASK_TEX_USE_SAT    = 6,
1128         MOD_WVG_MASK_TEX_USE_VAL    = 7,
1129         MOD_WVG_MASK_TEX_USE_ALPHA  = 8,
1130 };
1131
1132 typedef struct DynamicPaintModifierData {
1133         ModifierData modifier;
1134
1135         struct DynamicPaintCanvasSettings *canvas;
1136         struct DynamicPaintBrushSettings *brush;
1137         int type;  /* ui display: canvas / brush */
1138         int pad;
1139 } DynamicPaintModifierData;
1140
1141 /* Dynamic paint modifier flags */
1142 enum {
1143         MOD_DYNAMICPAINT_TYPE_CANVAS  = (1 << 0),
1144         MOD_DYNAMICPAINT_TYPE_BRUSH   = (1 << 1),
1145 };
1146
1147 /* Remesh modifier */
1148 typedef enum RemeshModifierFlags {
1149         MOD_REMESH_FLOOD_FILL     = 1,
1150         MOD_REMESH_SMOOTH_SHADING = 2,
1151 } RemeshModifierFlags;
1152
1153 typedef enum RemeshModifierMode {
1154         /* blocky */
1155         MOD_REMESH_CENTROID       = 0,
1156         /* smooth */
1157         MOD_REMESH_MASS_POINT     = 1,
1158         /* keeps sharp edges */
1159         MOD_REMESH_SHARP_FEATURES = 2,
1160 } RemeshModifierMode;
1161
1162 typedef struct RemeshModifierData {
1163         ModifierData modifier;
1164
1165         /* floodfill option, controls how small components can be before they are removed */
1166         float threshold;
1167
1168         /* ratio between size of model and grid */
1169         float scale;
1170
1171         float hermite_num;
1172
1173         /* octree depth */
1174         char depth;
1175
1176         char flag;
1177         char mode;
1178         char pad;
1179 } RemeshModifierData;
1180
1181 /* Skin modifier */
1182 typedef struct SkinModifierData {
1183         ModifierData modifier;
1184
1185         float branch_smoothing;
1186
1187         char flag;
1188
1189         char symmetry_axes;
1190
1191         char pad[2];
1192 } SkinModifierData;
1193
1194 /* SkinModifierData.symmetry_axes */
1195 enum {
1196         MOD_SKIN_SYMM_X = (1 << 0),
1197         MOD_SKIN_SYMM_Y = (1 << 1),
1198         MOD_SKIN_SYMM_Z = (1 << 2),
1199 };
1200
1201 /* SkinModifierData.flag */
1202 enum {
1203         MOD_SKIN_SMOOTH_SHADING = 1,
1204 };
1205
1206 /* Triangulate modifier */
1207 typedef struct TriangulateModifierData {
1208         ModifierData modifier;
1209
1210         int flag;
1211         int quad_method;
1212         int ngon_method;
1213         int pad;
1214 } TriangulateModifierData;
1215
1216 enum {
1217         MOD_TRIANGULATE_BEAUTY = (1 << 0), /* deprecated */
1218 };
1219
1220 #if (DNA_DEPRECATED_GCC_POISON == 1)
1221 #pragma GCC poison MOD_TRIANGULATE_BEAUTY
1222 #endif
1223
1224 /* Triangulate methods - NGons */
1225 enum {
1226         MOD_TRIANGULATE_NGON_BEAUTY = 0,
1227         MOD_TRIANGULATE_NGON_EARCLIP,
1228 };
1229
1230 /* Triangulate methods - Quads */
1231 enum {
1232         MOD_TRIANGULATE_QUAD_BEAUTY = 0,
1233         MOD_TRIANGULATE_QUAD_FIXED,
1234         MOD_TRIANGULATE_QUAD_ALTERNATE,
1235         MOD_TRIANGULATE_QUAD_SHORTEDGE
1236 };
1237
1238 typedef struct LaplacianSmoothModifierData {
1239         ModifierData modifier;
1240
1241         float lambda, lambda_border, pad1;
1242         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1243         short flag, repeat;
1244 } LaplacianSmoothModifierData;
1245
1246 /* Smooth modifier flags */
1247 enum {
1248         MOD_LAPLACIANSMOOTH_X               = (1 << 1),
1249         MOD_LAPLACIANSMOOTH_Y               = (1 << 2),
1250         MOD_LAPLACIANSMOOTH_Z               = (1 << 3),
1251         MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME = (1 << 4),
1252         MOD_LAPLACIANSMOOTH_NORMALIZED      = (1 << 5),
1253 };
1254
1255 typedef struct UVWarpModifierData {
1256         ModifierData modifier;
1257
1258         char axis_u, axis_v;
1259         char pad[6];
1260         float center[2];            /* used for rotate/scale */
1261
1262         struct Object *object_src;  /* source */
1263         char bone_src[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1264         struct Object *object_dst;  /* target */
1265         char bone_dst[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1266
1267         char vgroup_name[64];       /* optional vertexgroup name, MAX_VGROUP_NAME */
1268         char uvlayer_name[64];      /* MAX_CUSTOMDATA_LAYER_NAME */
1269 } UVWarpModifierData;
1270
1271 /* cache modifier */
1272 typedef struct MeshCacheModifierData {
1273         ModifierData modifier;
1274
1275         char flag;
1276         char type;  /* file format */
1277         char time_mode;
1278         char play_mode;
1279
1280         /* axis conversion */
1281         char forward_axis;
1282         char up_axis;
1283         char flip_axis;
1284
1285         char interp;
1286
1287         float factor;
1288         char deform_mode;
1289         char pad[7];
1290
1291         /* play_mode == MOD_MESHCACHE_PLAY_CFEA */
1292         float frame_start;
1293         float frame_scale;
1294
1295         /* play_mode == MOD_MESHCACHE_PLAY_EVAL */
1296         /* we could use one float for all these but their purpose is very different */
1297         float eval_frame;
1298         float eval_time;
1299         float eval_factor;
1300
1301         char filepath[1024];  /* FILE_MAX */
1302 } MeshCacheModifierData;
1303
1304 enum {
1305         MOD_MESHCACHE_TYPE_MDD  = 1,
1306         MOD_MESHCACHE_TYPE_PC2  = 2,
1307 };
1308
1309 enum {
1310         MOD_MESHCACHE_DEFORM_OVERWRITE  = 0,
1311         MOD_MESHCACHE_DEFORM_INTEGRATE  = 1,
1312 };
1313
1314 enum {
1315         MOD_MESHCACHE_INTERP_NONE      = 0,
1316         MOD_MESHCACHE_INTERP_LINEAR    = 1,
1317 /*      MOD_MESHCACHE_INTERP_CARDINAL  = 2, */
1318 };
1319
1320 enum {
1321         MOD_MESHCACHE_TIME_FRAME   = 0,
1322         MOD_MESHCACHE_TIME_SECONDS = 1,
1323         MOD_MESHCACHE_TIME_FACTOR  = 2,
1324 };
1325
1326 enum {
1327         MOD_MESHCACHE_PLAY_CFEA = 0,
1328         MOD_MESHCACHE_PLAY_EVAL = 1,
1329 };
1330
1331
1332 typedef struct LaplacianDeformModifierData {
1333         ModifierData modifier;
1334         char anchor_grp_name[64];  /* MAX_VGROUP_NAME */
1335         int total_verts, repeat;
1336         float *vertexco;
1337         void *cache_system;  /* runtime only */
1338         short flag, pad[3];
1339
1340 } LaplacianDeformModifierData;
1341
1342 /* Smooth modifier flags */
1343 enum {
1344         MOD_LAPLACIANDEFORM_BIND = 1,
1345 };
1346
1347 /* many of these options match 'solidify' */
1348 typedef struct WireframeModifierData {
1349         ModifierData modifier;
1350         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1351         float offset;
1352         float offset_fac;
1353         float offset_fac_vg;
1354         float crease_weight;
1355         short flag, mat_ofs;
1356         short pad[2];
1357 } WireframeModifierData;
1358
1359 enum {
1360         MOD_WIREFRAME_INVERT_VGROUP = (1 << 0),
1361         MOD_WIREFRAME_REPLACE       = (1 << 1),
1362         MOD_WIREFRAME_BOUNDARY      = (1 << 2),
1363         MOD_WIREFRAME_OFS_EVEN      = (1 << 3),
1364         MOD_WIREFRAME_OFS_RELATIVE  = (1 << 4),
1365         MOD_WIREFRAME_CREASE        = (1 << 5),
1366 };
1367
1368
1369
1370 #endif  /* __DNA_MODIFIER_TYPES_H__ */