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