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