99b9b4ce3618fd19646a43d9ff4f380f17dda197
[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         struct Subdiv *subdiv;
958         void *_pad3;
959 } MultiresModifierData;
960
961 typedef enum {
962         eMultiresModifierFlag_ControlEdges = (1 << 0),
963         /* DEPRECATED, only used for versioning. */
964         eMultiresModifierFlag_PlainUv_DEPRECATED      = (1 << 1),
965 } MultiresModifierFlag;
966
967 typedef struct FluidsimModifierData {
968         ModifierData modifier;
969
970         /** Definition is in DNA_object_fluidsim_types.h. */
971         struct FluidsimSettings *fss;
972 } FluidsimModifierData;
973
974 typedef struct ShrinkwrapModifierData {
975         ModifierData modifier;
976
977         /** Shrink target. */
978         struct Object *target;
979         /** Additional shrink target. */
980         struct Object *auxTarget;
981         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
982         char vgroup_name[64];
983         /** Distance offset to keep from mesh/projection point. */
984         float keepDist;
985         /** Shrink type projection. */
986         short shrinkType;
987         /** Shrink options. */
988         char  shrinkOpts;
989         /** Shrink to surface mode. */
990         char  shrinkMode;
991         /** Limit the projection ray cast. */
992         float projLimit;
993         /** Axis to project over. */
994         char  projAxis;
995
996         /** If using projection over vertex normal this controls the level of subsurface that must be
997          * done before getting the vertex coordinates and normal
998          */
999         char subsurfLevels;
1000
1001         char _pad[2];
1002 } ShrinkwrapModifierData;
1003
1004 /* Shrinkwrap->shrinkType */
1005 enum {
1006         MOD_SHRINKWRAP_NEAREST_SURFACE = 0,
1007         MOD_SHRINKWRAP_PROJECT         = 1,
1008         MOD_SHRINKWRAP_NEAREST_VERTEX  = 2,
1009         MOD_SHRINKWRAP_TARGET_PROJECT  = 3,
1010 };
1011
1012 /* Shrinkwrap->shrinkMode */
1013 enum {
1014         /** Move vertex to the surface of the target object (keepDist towards original position) */
1015         MOD_SHRINKWRAP_ON_SURFACE      = 0,
1016         /** Move the vertex inside the target object; don't change if already inside */
1017         MOD_SHRINKWRAP_INSIDE          = 1,
1018         /** Move the vertex outside the target object; don't change if already outside */
1019         MOD_SHRINKWRAP_OUTSIDE         = 2,
1020         /** Move vertex to the surface of the target object, with keepDist towards the outside */
1021         MOD_SHRINKWRAP_OUTSIDE_SURFACE = 3,
1022         /** Move vertex to the surface of the target object, with keepDist along the normal */
1023         MOD_SHRINKWRAP_ABOVE_SURFACE   = 4,
1024 };
1025
1026 /* Shrinkwrap->shrinkOpts */
1027 enum {
1028         /** allow shrinkwrap to move the vertex in the positive direction of axis */
1029         MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR = (1 << 0),
1030         /** allow shrinkwrap to move the vertex in the negative direction of axis */
1031         MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR = (1 << 1),
1032
1033         /** ignore vertex moves if a vertex ends projected on a front face of the target */
1034         MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE = (1 << 3),
1035         /** ignore vertex moves if a vertex ends projected on a back face of the target */
1036         MOD_SHRINKWRAP_CULL_TARGET_BACKFACE  = (1 << 4),
1037
1038 #ifdef DNA_DEPRECATED_ALLOW
1039         /** distance is measure to the front face of the target */
1040         MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE    = (1 << 5),
1041 #endif
1042
1043         MOD_SHRINKWRAP_INVERT_VGROUP         = (1 << 6),
1044         MOD_SHRINKWRAP_INVERT_CULL_TARGET    = (1 << 7),
1045 };
1046
1047 #define MOD_SHRINKWRAP_CULL_TARGET_MASK (MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE | MOD_SHRINKWRAP_CULL_TARGET_BACKFACE)
1048
1049 /* Shrinkwrap->projAxis */
1050 enum {
1051         /** projection over normal is used if no axis is selected */
1052         MOD_SHRINKWRAP_PROJECT_OVER_NORMAL   = 0,
1053         MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS   = (1 << 0),
1054         MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS   = (1 << 1),
1055         MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS   = (1 << 2),
1056 };
1057
1058
1059 typedef struct SimpleDeformModifierData {
1060         ModifierData modifier;
1061
1062         /** Object to control the origin of modifier space coordinates. */
1063         struct Object *origin;
1064         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
1065         char vgroup_name[64];
1066         /** Factors to control simple deforms. */
1067         float factor;
1068         /** Lower and upper limit. */
1069         float limit[2];
1070
1071         /** Deform function. */
1072         char mode;
1073         /** Lock axis (for taper and stretch). */
1074         char axis;
1075         /** Axis to perform the deform on (default is X, but can be overridden by origin. */
1076         char deform_axis;
1077         char flag;
1078
1079 } SimpleDeformModifierData;
1080
1081 /* SimpleDeform->flag */
1082 enum {
1083         MOD_SIMPLEDEFORM_FLAG_INVERT_VGROUP = (1 << 0),
1084 };
1085
1086
1087 enum {
1088         MOD_SIMPLEDEFORM_MODE_TWIST   = 1,
1089         MOD_SIMPLEDEFORM_MODE_BEND    = 2,
1090         MOD_SIMPLEDEFORM_MODE_TAPER   = 3,
1091         MOD_SIMPLEDEFORM_MODE_STRETCH = 4,
1092 };
1093
1094 enum {
1095         MOD_SIMPLEDEFORM_LOCK_AXIS_X = (1 << 0),
1096         MOD_SIMPLEDEFORM_LOCK_AXIS_Y = (1 << 1),
1097         MOD_SIMPLEDEFORM_LOCK_AXIS_Z = (1 << 2),
1098 };
1099
1100 typedef struct ShapeKeyModifierData {
1101         ModifierData modifier;
1102 } ShapeKeyModifierData;
1103
1104 typedef struct SolidifyModifierData {
1105         ModifierData modifier;
1106
1107         /** Name of vertex group to use, MAX_VGROUP_NAME. */
1108         char defgrp_name[64];
1109         /** New surface offset leve.l*/
1110         float offset;
1111         /** Midpoint of the offset . */
1112         float offset_fac;
1113         /** factor for the minimum weight to use when vgroups are used,
1114          * avoids 0.0 weights giving duplicate geometry */
1115         float offset_fac_vg;
1116         /** Clamp offset based on surrounding geometry. */
1117         float offset_clamp;
1118         char _pad[4];
1119         float crease_inner;
1120         float crease_outer;
1121         float crease_rim;
1122         int flag;
1123         short mat_ofs;
1124         short mat_ofs_rim;
1125 } SolidifyModifierData;
1126
1127 enum {
1128         MOD_SOLIDIFY_RIM            = (1 << 0),
1129         MOD_SOLIDIFY_EVEN           = (1 << 1),
1130         MOD_SOLIDIFY_NORMAL_CALC    = (1 << 2),
1131         MOD_SOLIDIFY_VGROUP_INV     = (1 << 3),
1132 #ifdef DNA_DEPRECATED
1133         MOD_SOLIDIFY_RIM_MATERIAL   = (1 << 4),  /* deprecated, used in do_versions */
1134 #endif
1135         MOD_SOLIDIFY_FLIP           = (1 << 5),
1136         MOD_SOLIDIFY_NOSHELL        = (1 << 6),
1137 };
1138
1139 typedef struct ScrewModifierData {
1140         ModifierData modifier;
1141
1142         struct Object *ob_axis;
1143         unsigned int steps;
1144         unsigned int render_steps;
1145         unsigned int iter;
1146         float screw_ofs;
1147         float angle;
1148         float merge_dist;
1149         short flag;
1150         char axis;
1151         char _pad[5];
1152 } ScrewModifierData;
1153
1154 enum {
1155         MOD_SCREW_NORMAL_FLIP    = (1 << 0),
1156         MOD_SCREW_NORMAL_CALC    = (1 << 1),
1157         MOD_SCREW_OBJECT_OFFSET  = (1 << 2),
1158 /*      MOD_SCREW_OBJECT_ANGLE   = (1 << 4), */
1159         MOD_SCREW_SMOOTH_SHADING = (1 << 5),
1160         MOD_SCREW_UV_STRETCH_U   = (1 << 6),
1161         MOD_SCREW_UV_STRETCH_V   = (1 << 7),
1162         MOD_SCREW_MERGE          = (1 << 8),
1163 };
1164
1165 typedef struct OceanModifierData {
1166         ModifierData modifier;
1167
1168         struct Ocean *ocean;
1169         struct OceanCache *oceancache;
1170
1171         int resolution;
1172         int spatial_size;
1173
1174         float wind_velocity;
1175
1176         float damp;
1177         float smallest_wave;
1178         float depth;
1179
1180         float wave_alignment;
1181         float wave_direction;
1182         float wave_scale;
1183
1184         float chop_amount;
1185         float foam_coverage;
1186         float time;
1187
1188         int bakestart;
1189         int bakeend;
1190
1191         /** FILE_MAX. */
1192         char cachepath[1024];
1193         /** MAX_CUSTOMDATA_LAYER_NAME. */
1194         char foamlayername[64];
1195         char cached;
1196         char geometry_mode;
1197
1198         char flag;
1199         char _pad2;
1200
1201         short repeat_x;
1202         short repeat_y;
1203
1204         int seed;
1205
1206         float size;
1207
1208         float foam_fade;
1209
1210         char _pad[4];
1211 } OceanModifierData;
1212
1213 enum {
1214         MOD_OCEAN_GEOM_GENERATE = 0,
1215         MOD_OCEAN_GEOM_DISPLACE = 1,
1216         MOD_OCEAN_GEOM_SIM_ONLY = 2,
1217 };
1218
1219
1220 enum {
1221         MOD_OCEAN_GENERATE_FOAM     = (1 << 0),
1222         MOD_OCEAN_GENERATE_NORMALS  = (1 << 1),
1223 };
1224
1225 typedef struct WarpModifierData {
1226         ModifierData modifier;
1227         /* keep in sync with MappingInfoModifierData */
1228         struct Tex *texture;
1229         struct Object *map_object;
1230         /** MAX_CUSTOMDATA_LAYER_NAME. */
1231         char uvlayer_name[64];
1232         int uvlayer_tmp;
1233         int texmapping;
1234         /* end MappingInfoModifierData */
1235
1236         struct Object *object_from;
1237         struct Object *object_to;
1238         struct CurveMapping *curfalloff;
1239         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
1240         char defgrp_name[64];
1241         float strength;
1242         float falloff_radius;
1243         /** Not used yet. */
1244         char flag;
1245         char falloff_type;
1246         char _pad[6];
1247 } WarpModifierData;
1248
1249 #define MOD_WARP_VOLUME_PRESERVE 1
1250
1251 typedef enum {
1252         eWarp_Falloff_None   = 0,
1253         eWarp_Falloff_Curve  = 1,
1254         eWarp_Falloff_Sharp  = 2, /* PROP_SHARP */
1255         eWarp_Falloff_Smooth = 3, /* PROP_SMOOTH */
1256         eWarp_Falloff_Root   = 4, /* PROP_ROOT */
1257         eWarp_Falloff_Linear = 5, /* PROP_LIN */
1258         eWarp_Falloff_Const  = 6, /* PROP_CONST */
1259         eWarp_Falloff_Sphere = 7, /* PROP_SPHERE */
1260         eWarp_Falloff_InvSquare = 8, /* PROP_INVSQUARE */
1261         /* PROP_RANDOM not used */
1262 } WarpModifierFalloff;
1263
1264 typedef struct WeightVGEditModifierData {
1265         ModifierData modifier;
1266
1267         /** Name of vertex group to edit. MAX_VGROUP_NAME. */
1268         char defgrp_name[64];
1269
1270         /** Using MOD_WVG_EDIT_* flags. */
1271         short edit_flags;
1272         /** Using MOD_WVG_MAPPING_* defines. */
1273         short falloff_type;
1274         /** Weight for vertices not in vgroup. */
1275         float default_weight;
1276
1277         /* Mapping stuff. */
1278         /** The custom mapping curve!. */
1279         struct CurveMapping *cmap_curve;
1280
1281         /* The add/remove vertices weight thresholds. */
1282         float add_threshold, rem_threshold;
1283
1284         /* Masking options. */
1285         /** The global "influence", if no vgroup nor tex is used as mask. */
1286         float mask_constant;
1287         /** Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME. */
1288         char mask_defgrp_name[64];
1289
1290         /* Texture masking. */
1291         /** Which channel to use as weightf. */
1292         int mask_tex_use_channel;
1293         /** The texture. */
1294         struct Tex *mask_texture;
1295         /** Name of the map object. */
1296         struct Object *mask_tex_map_obj;
1297         /** How to map the texture (using MOD_DISP_MAP_* enums). */
1298         int mask_tex_mapping;
1299         /** Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */
1300         char mask_tex_uvlayer_name[64];
1301
1302         /* Padding... */
1303         char _pad0[4];
1304 } WeightVGEditModifierData;
1305
1306 /* WeightVGEdit flags. */
1307 enum {
1308         /* (1 << 0), (1 << 1) and (1 << 2) are free for future use! */
1309         /** Add vertices with higher weight than threshold to vgroup. */
1310         MOD_WVG_EDIT_ADD2VG  = (1 << 3),
1311         /** Remove vertices with lower weight than threshold from vgroup. */
1312         MOD_WVG_EDIT_REMFVG  = (1 << 4),
1313 };
1314
1315 typedef struct WeightVGMixModifierData {
1316         ModifierData modifier;
1317
1318         /** Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1319         char defgrp_name_a[64];
1320         /** Name of other vertex group to mix in. MAX_VGROUP_NAME. */
1321         char defgrp_name_b[64];
1322         /** Default weight value for first vgroup. */
1323         float default_weight_a;
1324         /** Default weight value to mix in. */
1325         float default_weight_b;
1326         /** How second vgroups weights affect first ones. */
1327         char mix_mode;
1328         /** What vertices to affect. */
1329         char mix_set;
1330
1331         char _pad0[6];
1332
1333         /* Masking options. */
1334         /** The global "influence", if no vgroup nor tex is used as mask. */
1335         float mask_constant;
1336         /** Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME. */
1337         char mask_defgrp_name[64];
1338
1339         /* Texture masking. */
1340         /** Which channel to use as weightf. */
1341         int mask_tex_use_channel;
1342         /** The texture. */
1343         struct Tex *mask_texture;
1344         /** Name of the map object. */
1345         struct Object *mask_tex_map_obj;
1346         /** How to map the texture!. */
1347         int mask_tex_mapping;
1348         /** Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */
1349         char mask_tex_uvlayer_name[64];
1350
1351         /* Padding... */
1352         char _pad1[4];
1353 } WeightVGMixModifierData;
1354
1355 /* How second vgroup's weights affect first ones. */
1356 enum {
1357         /** Second weights replace weights. */
1358         MOD_WVG_MIX_SET = 1,
1359         /** Second weights are added to weights. */
1360         MOD_WVG_MIX_ADD = 2,
1361         /** Second weights are subtracted from weights. */
1362         MOD_WVG_MIX_SUB = 3,
1363         /** Second weights are multiplied with weights. */
1364         MOD_WVG_MIX_MUL = 4,
1365         /** Second weights divide weights. */
1366         MOD_WVG_MIX_DIV = 5,
1367         /** Difference between second weights and weights. */
1368         MOD_WVG_MIX_DIF = 6,
1369         /** Average of both weights. */
1370         MOD_WVG_MIX_AVG = 7,
1371 };
1372
1373 /* What vertices to affect. */
1374 enum {
1375         /** Affect all vertices. */
1376         MOD_WVG_SET_ALL = 1,
1377         /** Affect only vertices in first vgroup. */
1378         MOD_WVG_SET_A   = 2,
1379         /** Affect only vertices in second vgroup. */
1380         MOD_WVG_SET_B   = 3,
1381         /** Affect only vertices in one vgroup or the other. */
1382         MOD_WVG_SET_OR  = 4,
1383         /** Affect only vertices in both vgroups. */
1384         MOD_WVG_SET_AND = 5,
1385 };
1386
1387 typedef struct WeightVGProximityModifierData {
1388         ModifierData modifier;
1389
1390         /** Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1391         char defgrp_name[64];
1392
1393         /* Proximity modes. */
1394         int proximity_mode;
1395         int proximity_flags;
1396
1397         /* Target object from which to calculate vertices distances. */
1398         struct Object *proximity_ob_target;
1399
1400         /* Masking options. */
1401         /** The global "influence", if no vgroup nor tex is used as mask. */
1402         float mask_constant;
1403         /** Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME. */
1404         char mask_defgrp_name[64];
1405
1406         /* Texture masking. */
1407         /** Which channel to use as weightf. */
1408         int mask_tex_use_channel;
1409         /** The texture. */
1410         struct Tex *mask_texture;
1411         /** Name of the map object. */
1412         struct Object *mask_tex_map_obj;
1413         /** How to map the texture!. */
1414         int mask_tex_mapping;
1415         /** Name of the UV Map. MAX_CUSTOMDATA_LAYER_NAME. */
1416         char mask_tex_uvlayer_name[64];
1417
1418         /** Distances mapping to 0.0/1.0 weights. */
1419         float min_dist, max_dist;
1420
1421         /* Put here to avoid breaking existing struct... */
1422         /** Using MOD_WVG_MAPPING_* enums. */
1423         short falloff_type;
1424
1425         /* Padding... */
1426         char _pad0[2];
1427 } WeightVGProximityModifierData;
1428
1429 /* Modes of proximity weighting. */
1430 enum {
1431         MOD_WVG_PROXIMITY_OBJECT    = 1,  /* source vertex to other location */
1432         MOD_WVG_PROXIMITY_GEOMETRY  = 2,  /* source vertex to other geometry */
1433 };
1434
1435 /* Flags options for proximity weighting. */
1436 enum {
1437         /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1438         MOD_WVG_PROXIMITY_GEOM_VERTS  = (1 << 0),
1439         /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1440         MOD_WVG_PROXIMITY_GEOM_EDGES  = (1 << 1),
1441         /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1442         MOD_WVG_PROXIMITY_GEOM_FACES  = (1 << 2),
1443 };
1444
1445 /* Defines common to all WeightVG modifiers. */
1446 /* Mapping modes. */
1447 enum {
1448         MOD_WVG_MAPPING_NONE    = 0,
1449         MOD_WVG_MAPPING_CURVE   = 1,
1450         MOD_WVG_MAPPING_SHARP   = 2,  /* PROP_SHARP */
1451         MOD_WVG_MAPPING_SMOOTH  = 3,  /* PROP_SMOOTH */
1452         MOD_WVG_MAPPING_ROOT    = 4,  /* PROP_ROOT */
1453         /* PROP_LIN not used (same as NONE, here...). */
1454         /* PROP_CONST not used. */
1455         MOD_WVG_MAPPING_SPHERE  = 7,  /* PROP_SPHERE */
1456         MOD_WVG_MAPPING_RANDOM  = 8,  /* PROP_RANDOM */
1457         MOD_WVG_MAPPING_STEP    = 9,  /* Median Step. */
1458 };
1459
1460 /* Tex channel to be used as mask. */
1461 enum {
1462         MOD_WVG_MASK_TEX_USE_INT    = 1,
1463         MOD_WVG_MASK_TEX_USE_RED    = 2,
1464         MOD_WVG_MASK_TEX_USE_GREEN  = 3,
1465         MOD_WVG_MASK_TEX_USE_BLUE   = 4,
1466         MOD_WVG_MASK_TEX_USE_HUE    = 5,
1467         MOD_WVG_MASK_TEX_USE_SAT    = 6,
1468         MOD_WVG_MASK_TEX_USE_VAL    = 7,
1469         MOD_WVG_MASK_TEX_USE_ALPHA  = 8,
1470 };
1471
1472 typedef struct DynamicPaintModifierData {
1473         ModifierData modifier;
1474
1475         struct DynamicPaintCanvasSettings *canvas;
1476         struct DynamicPaintBrushSettings *brush;
1477         /** UI display: canvas / brush. */
1478         int type;
1479         char _pad[4];
1480 } DynamicPaintModifierData;
1481
1482 /* Dynamic paint modifier flags */
1483 enum {
1484         MOD_DYNAMICPAINT_TYPE_CANVAS  = (1 << 0),
1485         MOD_DYNAMICPAINT_TYPE_BRUSH   = (1 << 1),
1486 };
1487
1488 /* Remesh modifier */
1489 typedef enum eRemeshModifierFlags {
1490         MOD_REMESH_FLOOD_FILL     = (1 << 0),
1491         MOD_REMESH_SMOOTH_SHADING = (1 << 1),
1492 } RemeshModifierFlags;
1493
1494 typedef enum eRemeshModifierMode {
1495         /* blocky */
1496         MOD_REMESH_CENTROID       = 0,
1497         /* smooth */
1498         MOD_REMESH_MASS_POINT     = 1,
1499         /* keeps sharp edges */
1500         MOD_REMESH_SHARP_FEATURES = 2,
1501 } eRemeshModifierMode;
1502
1503 typedef struct RemeshModifierData {
1504         ModifierData modifier;
1505
1506         /* floodfill option, controls how small components can be before they are removed */
1507         float threshold;
1508
1509         /* ratio between size of model and grid */
1510         float scale;
1511
1512         float hermite_num;
1513
1514         /* octree depth */
1515         char depth;
1516
1517         char flag;
1518         char mode;
1519         char _pad;
1520 } RemeshModifierData;
1521
1522 /* Skin modifier */
1523 typedef struct SkinModifierData {
1524         ModifierData modifier;
1525
1526         float branch_smoothing;
1527
1528         char flag;
1529
1530         char symmetry_axes;
1531
1532         char _pad[2];
1533 } SkinModifierData;
1534
1535 /* SkinModifierData.symmetry_axes */
1536 enum {
1537         MOD_SKIN_SYMM_X = (1 << 0),
1538         MOD_SKIN_SYMM_Y = (1 << 1),
1539         MOD_SKIN_SYMM_Z = (1 << 2),
1540 };
1541
1542 /* SkinModifierData.flag */
1543 enum {
1544         MOD_SKIN_SMOOTH_SHADING = 1,
1545 };
1546
1547 /* Triangulate modifier */
1548 typedef struct TriangulateModifierData {
1549         ModifierData modifier;
1550
1551         int flag;
1552         int quad_method;
1553         int ngon_method;
1554         char _pad[4];
1555 } TriangulateModifierData;
1556
1557 /* TriangulateModifierData.flag */
1558 enum {
1559 #ifdef DNA_DEPRECATED
1560         MOD_TRIANGULATE_BEAUTY = (1 << 0),  /* deprecated */
1561 #endif
1562         MOD_TRIANGULATE_KEEP_CUSTOMLOOP_NORMALS = 1 << 1,
1563 };
1564
1565 /* Triangulate methods - NGons */
1566 enum {
1567         MOD_TRIANGULATE_NGON_BEAUTY = 0,
1568         MOD_TRIANGULATE_NGON_EARCLIP,
1569 };
1570
1571 /* Triangulate methods - Quads */
1572 enum {
1573         MOD_TRIANGULATE_QUAD_BEAUTY = 0,
1574         MOD_TRIANGULATE_QUAD_FIXED,
1575         MOD_TRIANGULATE_QUAD_ALTERNATE,
1576         MOD_TRIANGULATE_QUAD_SHORTEDGE,
1577 };
1578
1579 typedef struct LaplacianSmoothModifierData {
1580         ModifierData modifier;
1581
1582         float lambda, lambda_border;
1583         char _pad1[4];
1584         /** MAX_VGROUP_NAME. */
1585         char defgrp_name[64];
1586         short flag, repeat;
1587 } LaplacianSmoothModifierData;
1588
1589 /* Smooth modifier flags */
1590 enum {
1591         MOD_LAPLACIANSMOOTH_X               = (1 << 1),
1592         MOD_LAPLACIANSMOOTH_Y               = (1 << 2),
1593         MOD_LAPLACIANSMOOTH_Z               = (1 << 3),
1594         MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME = (1 << 4),
1595         MOD_LAPLACIANSMOOTH_NORMALIZED      = (1 << 5),
1596 };
1597
1598
1599 typedef struct CorrectiveSmoothModifierData {
1600         ModifierData modifier;
1601
1602         /* positions set during 'bind' operator
1603          * use for MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND */
1604         float (*bind_coords)[3];
1605
1606         /* note: -1 is used to bind */
1607         unsigned int bind_coords_num;
1608
1609         float lambda;
1610         short repeat, flag;
1611         char smooth_type, rest_source;
1612         char _pad[2];
1613
1614         /** MAX_VGROUP_NAME. */
1615         char defgrp_name[64];
1616
1617         /* runtime-only cache (delta's between),
1618          * delta's between the original positions and the smoothed positions */
1619         float (*delta_cache)[3];
1620         unsigned int delta_cache_num;
1621         char _pad2[4];
1622 } CorrectiveSmoothModifierData;
1623
1624 enum {
1625         MOD_CORRECTIVESMOOTH_SMOOTH_SIMPLE         = 0,
1626         MOD_CORRECTIVESMOOTH_SMOOTH_LENGTH_WEIGHT    = 1,
1627 };
1628
1629 enum {
1630         MOD_CORRECTIVESMOOTH_RESTSOURCE_ORCO       = 0,
1631         MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND       = 1,
1632 };
1633
1634 /* Corrective Smooth modifier flags */
1635 enum {
1636         MOD_CORRECTIVESMOOTH_INVERT_VGROUP         = (1 << 0),
1637         MOD_CORRECTIVESMOOTH_ONLY_SMOOTH           = (1 << 1),
1638         MOD_CORRECTIVESMOOTH_PIN_BOUNDARY          = (1 << 2),
1639 };
1640
1641 typedef struct UVWarpModifierData {
1642         ModifierData modifier;
1643
1644         char axis_u, axis_v;
1645         char _pad[6];
1646         /** Used for rotate/scale. */
1647         float center[2];
1648
1649         /** Source. */
1650         struct Object *object_src;
1651         /** Optional name of bone target, MAX_ID_NAME-2. */
1652         char bone_src[64];
1653         /** Target. */
1654         struct Object *object_dst;
1655         /** Optional name of bone target, MAX_ID_NAME-2. */
1656         char bone_dst[64];
1657
1658         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
1659         char vgroup_name[64];
1660         /** MAX_CUSTOMDATA_LAYER_NAME. */
1661         char uvlayer_name[64];
1662 } UVWarpModifierData;
1663
1664 /* cache modifier */
1665 typedef struct MeshCacheModifierData {
1666         ModifierData modifier;
1667
1668         char flag;
1669         /** File format. */
1670         char type;
1671         char time_mode;
1672         char play_mode;
1673
1674         /* axis conversion */
1675         char forward_axis;
1676         char up_axis;
1677         char flip_axis;
1678
1679         char interp;
1680
1681         float factor;
1682         char deform_mode;
1683         char _pad[7];
1684
1685         /* play_mode == MOD_MESHCACHE_PLAY_CFEA */
1686         float frame_start;
1687         float frame_scale;
1688
1689         /* play_mode == MOD_MESHCACHE_PLAY_EVAL */
1690         /* we could use one float for all these but their purpose is very different */
1691         float eval_frame;
1692         float eval_time;
1693         float eval_factor;
1694
1695         /** FILE_MAX. */
1696         char filepath[1024];
1697 } MeshCacheModifierData;
1698
1699 enum {
1700         MOD_MESHCACHE_TYPE_MDD  = 1,
1701         MOD_MESHCACHE_TYPE_PC2  = 2,
1702 };
1703
1704 enum {
1705         MOD_MESHCACHE_DEFORM_OVERWRITE  = 0,
1706         MOD_MESHCACHE_DEFORM_INTEGRATE  = 1,
1707 };
1708
1709 enum {
1710         MOD_MESHCACHE_INTERP_NONE      = 0,
1711         MOD_MESHCACHE_INTERP_LINEAR    = 1,
1712 /*      MOD_MESHCACHE_INTERP_CARDINAL  = 2, */
1713 };
1714
1715 enum {
1716         MOD_MESHCACHE_TIME_FRAME   = 0,
1717         MOD_MESHCACHE_TIME_SECONDS = 1,
1718         MOD_MESHCACHE_TIME_FACTOR  = 2,
1719 };
1720
1721 enum {
1722         MOD_MESHCACHE_PLAY_CFEA = 0,
1723         MOD_MESHCACHE_PLAY_EVAL = 1,
1724 };
1725
1726
1727 typedef struct LaplacianDeformModifierData {
1728         ModifierData modifier;
1729         /** MAX_VGROUP_NAME. */
1730         char anchor_grp_name[64];
1731         int total_verts, repeat;
1732         float *vertexco;
1733         /** Runtime only. */
1734         void *cache_system;
1735         short flag;
1736         char _pad[6];
1737
1738 } LaplacianDeformModifierData;
1739
1740 /* Laplacian Deform modifier flags */
1741 enum {
1742         MOD_LAPLACIANDEFORM_BIND = 1 << 0,
1743 };
1744
1745 /* many of these options match 'solidify' */
1746 typedef struct WireframeModifierData {
1747         ModifierData modifier;
1748         /** MAX_VGROUP_NAME. */
1749         char defgrp_name[64];
1750         float offset;
1751         float offset_fac;
1752         float offset_fac_vg;
1753         float crease_weight;
1754         short flag, mat_ofs;
1755         char _pad[4];
1756 } WireframeModifierData;
1757
1758 enum {
1759         MOD_WIREFRAME_INVERT_VGROUP = (1 << 0),
1760         MOD_WIREFRAME_REPLACE       = (1 << 1),
1761         MOD_WIREFRAME_BOUNDARY      = (1 << 2),
1762         MOD_WIREFRAME_OFS_EVEN      = (1 << 3),
1763         MOD_WIREFRAME_OFS_RELATIVE  = (1 << 4),
1764         MOD_WIREFRAME_CREASE        = (1 << 5),
1765 };
1766
1767
1768 typedef struct DataTransferModifierData {
1769         ModifierData modifier;
1770
1771         struct Object *ob_source;
1772
1773         /** See DT_TYPE_ enum in ED_object.h. */
1774         int data_types;
1775
1776         /* See MREMAP_MODE_ enum in BKE_mesh_mapping.h */
1777         int vmap_mode;
1778         int emap_mode;
1779         int lmap_mode;
1780         int pmap_mode;
1781
1782         float map_max_distance;
1783         float map_ray_radius;
1784         float islands_precision;
1785
1786         char _pad1[4];
1787
1788         /** DT_MULTILAYER_INDEX_MAX; See DT_FROMLAYERS_ enum in ED_object.h. */
1789         int layers_select_src[4];
1790         /** DT_MULTILAYER_INDEX_MAX; See DT_TOLAYERS_ enum in ED_object.h. */
1791         int layers_select_dst[4];
1792
1793         /** See CDT_MIX_ enum in BKE_customdata.h. */
1794         int mix_mode;
1795         float mix_factor;
1796         /** MAX_VGROUP_NAME. */
1797         char defgrp_name[64];
1798
1799         int flags;
1800 } DataTransferModifierData;
1801
1802 /* DataTransferModifierData.flags */
1803 enum {
1804         MOD_DATATRANSFER_OBSRC_TRANSFORM  = 1 << 0,
1805         MOD_DATATRANSFER_MAP_MAXDIST      = 1 << 1,
1806         MOD_DATATRANSFER_INVERT_VGROUP    = 1 << 2,
1807
1808         /* Only for UI really. */
1809         MOD_DATATRANSFER_USE_VERT         = 1 << 28,
1810         MOD_DATATRANSFER_USE_EDGE         = 1 << 29,
1811         MOD_DATATRANSFER_USE_LOOP         = 1 << 30,
1812         MOD_DATATRANSFER_USE_POLY         = 1u << 31,
1813 };
1814
1815 /* Set Split Normals modifier */
1816 typedef struct NormalEditModifierData {
1817         ModifierData modifier;
1818         /** MAX_VGROUP_NAME. */
1819         char defgrp_name[64];
1820         /** Source of normals, or center of ellipsoid. */
1821         struct Object *target;
1822         short mode;
1823         short flag;
1824         short mix_mode;
1825         char _pad[2];
1826         float mix_factor;
1827         float mix_limit;
1828         float offset[3];
1829         char _pad0[4];
1830 } NormalEditModifierData;
1831
1832 /* NormalEditModifierData.mode */
1833 enum {
1834         MOD_NORMALEDIT_MODE_RADIAL        = 0,
1835         MOD_NORMALEDIT_MODE_DIRECTIONAL   = 1,
1836 };
1837
1838 /* NormalEditModifierData.flags */
1839 enum {
1840         MOD_NORMALEDIT_INVERT_VGROUP            = (1 << 0),
1841         MOD_NORMALEDIT_USE_DIRECTION_PARALLEL   = (1 << 1),
1842         MOD_NORMALEDIT_NO_POLYNORS_FIX             = (1 << 2),
1843 };
1844
1845 /* NormalEditModifierData.mix_mode */
1846 enum {
1847         MOD_NORMALEDIT_MIX_COPY = 0,
1848         MOD_NORMALEDIT_MIX_ADD  = 1,
1849         MOD_NORMALEDIT_MIX_SUB  = 2,
1850         MOD_NORMALEDIT_MIX_MUL  = 3,
1851 };
1852
1853 typedef struct MeshSeqCacheModifierData {
1854         ModifierData modifier;
1855
1856         struct CacheFile *cache_file;
1857         struct CacheReader *reader;
1858         /** 1024 = FILE_MAX. */
1859         char object_path[1024];
1860
1861         char read_flag;
1862         char _pad[7];
1863 } MeshSeqCacheModifierData;
1864
1865 /* MeshSeqCacheModifierData.read_flag */
1866 enum {
1867         MOD_MESHSEQ_READ_VERT  = (1 << 0),
1868         MOD_MESHSEQ_READ_POLY  = (1 << 1),
1869         MOD_MESHSEQ_READ_UV    = (1 << 2),
1870         MOD_MESHSEQ_READ_COLOR = (1 << 3),
1871 };
1872
1873 typedef struct SDefBind {
1874         unsigned int *vert_inds;
1875         unsigned int numverts;
1876         int mode;
1877         float *vert_weights;
1878         float normal_dist;
1879         float influence;
1880 } SDefBind;
1881
1882 typedef struct SDefVert {
1883         SDefBind *binds;
1884         unsigned int numbinds;
1885         char _pad[4];
1886 } SDefVert;
1887
1888 typedef struct SurfaceDeformModifierData {
1889         ModifierData modifier;
1890
1891         struct Depsgraph *depsgraph;
1892         /** Bind target object. */
1893         struct Object *target;
1894         /** Vertex bind data. */
1895         SDefVert *verts;
1896         float falloff;
1897         unsigned int numverts, numpoly;
1898         int flags;
1899         float mat[4][4];
1900 } SurfaceDeformModifierData;
1901
1902 /* Surface Deform modifier flags */
1903 enum {
1904         /* This indicates "do bind on next modifier evaluation" as well as "is bound". */
1905         MOD_SDEF_BIND = (1 << 0),
1906
1907         MOD_SDEF_USES_LOOPTRI = (1 << 1),
1908         MOD_SDEF_HAS_CONCAVE = (1 << 2),
1909 };
1910
1911 /* Surface Deform vertex bind modes */
1912 enum {
1913         MOD_SDEF_MODE_LOOPTRI = 0,
1914         MOD_SDEF_MODE_NGON = 1,
1915         MOD_SDEF_MODE_CENTROID = 2,
1916 };
1917
1918 typedef struct WeightedNormalModifierData {
1919         ModifierData modifier;
1920
1921         /** MAX_VGROUP_NAME. */
1922         char defgrp_name[64];
1923         char mode, flag;
1924         short weight;
1925         float thresh;
1926 } WeightedNormalModifierData;
1927
1928 /* Name/id of the generic PROP_INT cdlayer storing face weights. */
1929 #define MOD_WEIGHTEDNORMALS_FACEWEIGHT_CDLAYER_ID "__mod_weightednormals_faceweight"
1930
1931 /* WeightedNormalModifierData.mode */
1932 enum {
1933         MOD_WEIGHTEDNORMAL_MODE_FACE = 0,
1934         MOD_WEIGHTEDNORMAL_MODE_ANGLE = 1,
1935         MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE = 2,
1936 };
1937
1938 /* WeightedNormalModifierData.flag */
1939 enum {
1940         MOD_WEIGHTEDNORMAL_KEEP_SHARP = (1 << 0),
1941         MOD_WEIGHTEDNORMAL_INVERT_VGROUP = (1 << 1),
1942         MOD_WEIGHTEDNORMAL_FACE_INFLUENCE = (1 << 2),
1943 };
1944
1945 #define MOD_MESHSEQ_READ_ALL \
1946         (MOD_MESHSEQ_READ_VERT | MOD_MESHSEQ_READ_POLY | MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)
1947
1948 #endif  /* __DNA_MODIFIER_TYPES_H__ */