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