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