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