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