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