Fix T63283: Second subdivision modifier does not ignore crease
[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         eSubsurfModifierFlag_UseCrease   =  (1 << 4),
148 } SubsurfModifierFlag;
149
150 typedef enum {
151         SUBSURF_TYPE_CATMULL_CLARK = 0,
152         SUBSURF_TYPE_SIMPLE = 1,
153 } eSubsurfModifierType;
154
155 typedef enum {
156         SUBSURF_UV_SMOOTH_NONE = 0,
157         SUBSURF_UV_SMOOTH_PRESERVE_CORNERS = 1,
158         SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_AND_JUNCTIONS = 2,
159         SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE = 3,
160         SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES = 4,
161         SUBSURF_UV_SMOOTH_ALL = 5,
162 } eSubsurfUVSmooth;
163
164 typedef struct SubsurfModifierData {
165         ModifierData modifier;
166
167         short subdivType, levels, renderLevels, flags;
168         short uv_smooth;
169         short quality;
170         char _pad[4];
171
172         /* TODO(sergey): Get rid of those with the old CCG subdivision code. */
173         void *emCache, *mCache;
174 } SubsurfModifierData;
175
176 typedef struct LatticeModifierData {
177         ModifierData modifier;
178
179         struct Object *object;
180         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
181         char name[64];
182         float strength;
183         char _pad[4];
184 } LatticeModifierData;
185
186 typedef struct CurveModifierData {
187         ModifierData modifier;
188
189         struct Object *object;
190         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
191         char name[64];
192         /** Axis along which curve deforms. */
193         short defaxis;
194         char _pad[6];
195 } CurveModifierData;
196
197 /* CurveModifierData->defaxis */
198 enum {
199         MOD_CURVE_POSX = 1,
200         MOD_CURVE_POSY = 2,
201         MOD_CURVE_POSZ = 3,
202         MOD_CURVE_NEGX = 4,
203         MOD_CURVE_NEGY = 5,
204         MOD_CURVE_NEGZ = 6,
205 };
206
207 typedef struct BuildModifierData {
208         ModifierData modifier;
209
210         float start, length;
211         short flag;
212
213         /** (bool) whether order of vertices is randomized - legacy files (for readfile conversion). */
214         short randomize;
215         /** (int) random seed. */
216         int seed;
217 } BuildModifierData;
218
219 /* Build Modifier -> flag */
220 enum {
221         /** order of vertices is randomized */
222         MOD_BUILD_FLAG_RANDOMIZE = (1 << 0),
223         /** frame range is reversed, resulting in a deconstruction effect */
224         MOD_BUILD_FLAG_REVERSE   = (1 << 1),
225 };
226
227 /* Mask Modifier */
228 typedef struct MaskModifierData {
229         ModifierData modifier;
230
231         /** Armature to use to in place of hardcoded vgroup. */
232         struct Object *ob_arm;
233         /** Name of vertex group to use to mask, MAX_VGROUP_NAME. */
234         char vgroup[64];
235
236         /** Using armature or hardcoded vgroup. */
237         short mode;
238         /** Flags for various things. */
239         short flag;
240         float threshold;
241 } MaskModifierData;
242
243 /* Mask Modifier -> mode */
244 enum {
245         MOD_MASK_MODE_VGROUP = 0,
246         MOD_MASK_MODE_ARM    = 1,
247 };
248
249 /* Mask Modifier -> flag */
250 enum {
251         MOD_MASK_INV         = (1 << 0),
252 };
253
254 typedef struct ArrayModifierData {
255         ModifierData modifier;
256
257         /* the object with which to cap the start of the array  */
258         struct Object *start_cap;
259         /* the object with which to cap the end of the array  */
260         struct Object *end_cap;
261         /* the curve object to use for MOD_ARR_FITCURVE */
262         struct Object *curve_ob;
263         /* the object to use for object offset */
264         struct Object *offset_ob;
265         /* a constant duplicate offset;
266          * 1 means the duplicates are 1 unit apart
267          */
268         float offset[3];
269         /* a scaled factor for duplicate offsets;
270          * 1 means the duplicates are 1 object-width apart
271          */
272         float scale[3];
273         /* the length over which to distribute the duplicates */
274         float length;
275         /* the limit below which to merge vertices in adjacent duplicates */
276         float merge_dist;
277         /* determines how duplicate count is calculated; one of:
278          * - MOD_ARR_FIXEDCOUNT -> fixed
279          * - MOD_ARR_FITLENGTH  -> calculated to fit a set length
280          * - MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
281          */
282         int fit_type;
283         /* flags specifying how total offset is calculated; binary OR of:
284          * - MOD_ARR_OFF_CONST    -> total offset += offset
285          * - MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
286          * - MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
287          * total offset is the sum of the individual enabled offsets
288          */
289         int offset_type;
290         /* general flags:
291          * MOD_ARR_MERGE -> merge vertices in adjacent duplicates
292          */
293         int flags;
294         /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */
295         int count;
296         float uv_offset[2];
297 } ArrayModifierData;
298
299 /* ArrayModifierData->fit_type */
300 enum {
301         MOD_ARR_FIXEDCOUNT = 0,
302         MOD_ARR_FITLENGTH  = 1,
303         MOD_ARR_FITCURVE   = 2,
304 };
305
306 /* ArrayModifierData->offset_type */
307 enum {
308         MOD_ARR_OFF_CONST    = (1 << 0),
309         MOD_ARR_OFF_RELATIVE = (1 << 1),
310         MOD_ARR_OFF_OBJ      = (1 << 2),
311 };
312
313 /* ArrayModifierData->flags */
314 enum {
315         MOD_ARR_MERGE      = (1 << 0),
316         MOD_ARR_MERGEFINAL = (1 << 1),
317 };
318
319 typedef struct MirrorModifierData {
320         ModifierData modifier;
321
322         /** Deprecated, use flag instead. */
323         short axis  DNA_DEPRECATED;
324         short flag;
325         float tolerance;
326         float uv_offset[2];
327         float uv_offset_copy[2];
328         struct Object *mirror_ob;
329 } MirrorModifierData;
330
331 /* MirrorModifierData->flag */
332 enum {
333         MOD_MIR_CLIPPING      = (1 << 0),
334         MOD_MIR_MIRROR_U      = (1 << 1),
335         MOD_MIR_MIRROR_V      = (1 << 2),
336         MOD_MIR_AXIS_X        = (1 << 3),
337         MOD_MIR_AXIS_Y        = (1 << 4),
338         MOD_MIR_AXIS_Z        = (1 << 5),
339         MOD_MIR_VGROUP        = (1 << 6),
340         MOD_MIR_NO_MERGE      = (1 << 7),
341         MOD_MIR_BISECT_AXIS_X = (1 << 8),
342         MOD_MIR_BISECT_AXIS_Y = (1 << 9),
343         MOD_MIR_BISECT_AXIS_Z = (1 << 10),
344         MOD_MIR_BISECT_FLIP_AXIS_X = (1 << 11),
345         MOD_MIR_BISECT_FLIP_AXIS_Y = (1 << 12),
346         MOD_MIR_BISECT_FLIP_AXIS_Z = (1 << 13),
347 };
348
349 typedef struct EdgeSplitModifierData {
350         ModifierData modifier;
351
352         /** Angle above which edges should be split. */
353         float split_angle;
354         int flags;
355 } EdgeSplitModifierData;
356
357 /* EdgeSplitModifierData->flags */
358 enum {
359         MOD_EDGESPLIT_FROMANGLE  = (1 << 1),
360         MOD_EDGESPLIT_FROMFLAG   = (1 << 2),
361 };
362
363 typedef struct BevelModifierData {
364         ModifierData modifier;
365
366         /** The "raw" bevel value (distance/amount to bevel). */
367         float value;
368         /** The resolution (as originally coded, it is the number of recursive bevels). */
369         int res;
370         /** General option flags. */
371         short flags;
372         /** Used to interpret the bevel value. */
373         short val_flags;
374         /** Flags to tell the tool how to limit the bevel. */
375         short lim_flags;
376         /** Flags to direct how edge weights are applied to verts. */
377         short e_flags;
378         /** Material index if >= 0, else material inherited from surrounding faces. */
379         short mat;
380         short edge_flags;
381         short face_str_mode;
382         /* patterns to use for mitering non-reflex and reflex miter edges */
383         short miter_inner;
384         short miter_outer;
385         char _pad0[2];
386         /** Controls profile shape (0->1, .5 is round). */
387         float profile;
388         /** if the MOD_BEVEL_ANGLE is set,
389          * this will be how "sharp" an edge must be before it gets beveled */
390         float bevel_angle;
391         float spread;
392         /** if the MOD_BEVEL_VWEIGHT option is set,
393          * this will be the name of the vert group, MAX_VGROUP_NAME */
394         char defgrp_name[64];
395 } BevelModifierData;
396
397 /* BevelModifierData->flags and BevelModifierData->lim_flags */
398 enum {
399         MOD_BEVEL_VERT          = (1 << 1),
400 /*      unused                  = (1 << 2), */
401         MOD_BEVEL_ANGLE         = (1 << 3),
402         MOD_BEVEL_WEIGHT        = (1 << 4),
403         MOD_BEVEL_VGROUP        = (1 << 5),
404 /*      unused                  = (1 << 7), */
405 /*      unused                  = (1 << 8), */
406 /*      unused                  = (1 << 9), */
407 /*      unused                  = (1 << 10), */
408 /*      unused                  = (1 << 11), */
409 /*      unused                  = (1 << 12), */
410         MOD_BEVEL_OVERLAP_OK    = (1 << 13),
411         MOD_BEVEL_EVEN_WIDTHS   = (1 << 14),
412         MOD_BEVEL_HARDEN_NORMALS = (1 << 15),
413 };
414
415 /* BevelModifierData->val_flags (not used as flags any more) */
416 enum {
417         MOD_BEVEL_AMT_OFFSET = 0,
418         MOD_BEVEL_AMT_WIDTH = 1,
419         MOD_BEVEL_AMT_DEPTH = 2,
420         MOD_BEVEL_AMT_PERCENT = 3,
421 };
422
423 /* BevelModifierData->edge_flags */
424 enum {
425         MOD_BEVEL_MARK_SEAM      = (1 << 0),
426         MOD_BEVEL_MARK_SHARP = (1 << 1),
427 };
428
429 /* BevelModifierData->face_str_mode */
430 enum {
431         MOD_BEVEL_FACE_STRENGTH_NONE,
432         MOD_BEVEL_FACE_STRENGTH_NEW,
433         MOD_BEVEL_FACE_STRENGTH_AFFECTED,
434         MOD_BEVEL_FACE_STRENGTH_ALL,
435 };
436
437 /* BevelModifier->miter_inner and ->miter_outer */
438 enum {
439         MOD_BEVEL_MITER_SHARP,
440         MOD_BEVEL_MITER_PATCH,
441         MOD_BEVEL_MITER_ARC,
442 };
443
444 typedef struct SmokeModifierData {
445         ModifierData modifier;
446
447         struct SmokeDomainSettings *domain;
448         /** Inflow, outflow, smoke objects. */
449         struct SmokeFlowSettings *flow;
450         /** Collision objects. */
451         struct SmokeCollSettings *coll;
452         float time;
453         /** Domain, inflow, outflow, .... */
454         int type;
455 } SmokeModifierData;
456
457 /* Smoke modifier flags */
458 enum {
459         MOD_SMOKE_TYPE_DOMAIN = (1 << 0),
460         MOD_SMOKE_TYPE_FLOW   = (1 << 1),
461         MOD_SMOKE_TYPE_COLL   = (1 << 2),
462 };
463
464 typedef struct DisplaceModifierData {
465         ModifierData modifier;
466
467         /* keep in sync with MappingInfoModifierData */
468         struct Tex *texture;
469         struct Object *map_object;
470         /** MAX_CUSTOMDATA_LAYER_NAME. */
471         char uvlayer_name[64];
472         int uvlayer_tmp;
473         int texmapping;
474         /* end MappingInfoModifierData */
475
476         float strength;
477         int direction;
478         /** MAX_VGROUP_NAME. */
479         char defgrp_name[64];
480         float midlevel;
481         int space;
482 } DisplaceModifierData;
483
484 /* DisplaceModifierData->direction */
485 enum {
486         MOD_DISP_DIR_X       = 0,
487         MOD_DISP_DIR_Y       = 1,
488         MOD_DISP_DIR_Z       = 2,
489         MOD_DISP_DIR_NOR     = 3,
490         MOD_DISP_DIR_RGB_XYZ = 4,
491         MOD_DISP_DIR_CLNOR   = 5,
492 };
493
494 /* DisplaceModifierData->texmapping */
495 enum {
496         MOD_DISP_MAP_LOCAL  = 0,
497         MOD_DISP_MAP_GLOBAL = 1,
498         MOD_DISP_MAP_OBJECT = 2,
499         MOD_DISP_MAP_UV     = 3,
500 };
501
502 /* DisplaceModifierData->space */
503 enum {
504         MOD_DISP_SPACE_LOCAL  = 0,
505         MOD_DISP_SPACE_GLOBAL = 1,
506 };
507
508 typedef struct UVProjectModifierData {
509         ModifierData modifier;
510
511         /* the objects which do the projecting */
512         /** MOD_UVPROJECT_MAXPROJECTORS. */
513         struct Object *projectors[10];
514         char _pad2[4];
515         int num_projectors;
516         float aspectx, aspecty;
517         float scalex, scaley;
518         /** MAX_CUSTOMDATA_LAYER_NAME. */
519         char uvlayer_name[64];
520         int uvlayer_tmp;
521         char _pad[4];
522 } UVProjectModifierData;
523
524 #define MOD_UVPROJECT_MAXPROJECTORS 10
525
526 /* UVProjectModifierData->flags */
527 enum {
528         MOD_UVPROJECT_OVERRIDEIMAGE = (1 << 0),
529 };
530
531 typedef struct DecimateModifierData {
532         ModifierData modifier;
533
534         /** (mode == MOD_DECIM_MODE_COLLAPSE). */
535         float percent;
536         /** (mode == MOD_DECIM_MODE_UNSUBDIV). */
537         short iter;
538         /** (mode == MOD_DECIM_MODE_DISSOLVE). */
539         char delimit;
540         /** (mode == MOD_DECIM_MODE_COLLAPSE). */
541         char symmetry_axis;
542         /** (mode == MOD_DECIM_MODE_DISSOLVE). */
543         float angle;
544
545         /** MAX_VGROUP_NAME. */
546         char defgrp_name[64];
547         float defgrp_factor;
548         short flag, mode;
549
550         /* runtime only */
551         int face_count;
552 } DecimateModifierData;
553
554 enum {
555         MOD_DECIM_FLAG_INVERT_VGROUP       = (1 << 0),
556         /** for collapse only. dont convert tri pairs back to quads */
557         MOD_DECIM_FLAG_TRIANGULATE         = (1 << 1),
558         /** for dissolve only. collapse all verts between 2 faces */
559         MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS  = (1 << 2),
560         MOD_DECIM_FLAG_SYMMETRY            = (1 << 3),
561 };
562
563 enum {
564         MOD_DECIM_MODE_COLLAPSE,
565         MOD_DECIM_MODE_UNSUBDIV,
566         /** called planar in the UI */
567         MOD_DECIM_MODE_DISSOLVE,
568 };
569
570 typedef struct SmoothModifierData {
571         ModifierData modifier;
572         float fac;
573         /** MAX_VGROUP_NAME. */
574         char defgrp_name[64];
575         short flag, repeat;
576
577 } SmoothModifierData;
578
579 /* Smooth modifier flags */
580 enum {
581         MOD_SMOOTH_X = (1 << 1),
582         MOD_SMOOTH_Y = (1 << 2),
583         MOD_SMOOTH_Z = (1 << 3),
584 };
585
586 typedef struct CastModifierData {
587         ModifierData modifier;
588
589         struct Object *object;
590         float fac;
591         float radius;
592         float size;
593         /** MAX_VGROUP_NAME. */
594         char defgrp_name[64];
595         short flag, type;
596 } CastModifierData;
597
598 /* Cast modifier flags */
599 enum {
600         /* And what bout (1 << 0) flag? ;) */
601         MOD_CAST_X                = (1 << 1),
602         MOD_CAST_Y                = (1 << 2),
603         MOD_CAST_Z                = (1 << 3),
604         MOD_CAST_USE_OB_TRANSFORM = (1 << 4),
605         MOD_CAST_SIZE_FROM_RADIUS = (1 << 5),
606 };
607
608 /* Cast modifier projection types */
609 enum {
610         MOD_CAST_TYPE_SPHERE   = 0,
611         MOD_CAST_TYPE_CYLINDER = 1,
612         MOD_CAST_TYPE_CUBOID   = 2,
613 };
614
615 typedef struct WaveModifierData {
616         ModifierData modifier;
617
618         /* keep in sync with MappingInfoModifierData */
619         struct Tex *texture;
620         struct Object *map_object;
621         /** MAX_CUSTOMDATA_LAYER_NAME. */
622         char uvlayer_name[64];
623         int uvlayer_tmp;
624         int texmapping;
625         /* end MappingInfoModifierData */
626
627         struct Object *objectcenter;
628         /** MAX_VGROUP_NAME. */
629         char defgrp_name[64];
630
631         short flag;
632         char _pad[2];
633
634         float startx, starty, height, width;
635         float narrow, speed, damp, falloff;
636
637         float timeoffs, lifetime;
638         char _pad1[4];
639 } WaveModifierData;
640
641 /* WaveModifierData.flag */
642 enum {
643         /* And what bout (1 << 0) flag? ;) */
644         MOD_WAVE_X      = (1 << 1),
645         MOD_WAVE_Y      = (1 << 2),
646         MOD_WAVE_CYCL   = (1 << 3),
647         MOD_WAVE_NORM   = (1 << 4),
648         MOD_WAVE_NORM_X = (1 << 5),
649         MOD_WAVE_NORM_Y = (1 << 6),
650         MOD_WAVE_NORM_Z = (1 << 7),
651 };
652
653 typedef struct ArmatureModifierData {
654         ModifierData modifier;
655
656         /** Deformflag replaces armature->deformflag. */
657         short deformflag, multi;
658         char _pad2[4];
659         struct Object *object;
660         /** Stored input of previous modifier, for vertexgroup blending. */
661         float *prevCos;
662         /** MAX_VGROUP_NAME. */
663         char defgrp_name[64];
664 } ArmatureModifierData;
665
666 enum {
667         MOD_HOOK_UNIFORM_SPACE = (1 << 0),
668 };
669
670 /* same as WarpModifierFalloff */
671 typedef enum {
672         eHook_Falloff_None   = 0,
673         eHook_Falloff_Curve  = 1,
674         eHook_Falloff_Sharp  = 2, /* PROP_SHARP */
675         eHook_Falloff_Smooth = 3, /* PROP_SMOOTH */
676         eHook_Falloff_Root   = 4, /* PROP_ROOT */
677         eHook_Falloff_Linear = 5, /* PROP_LIN */
678         eHook_Falloff_Const  = 6, /* PROP_CONST */
679         eHook_Falloff_Sphere = 7, /* PROP_SPHERE */
680         eHook_Falloff_InvSquare = 8, /* PROP_INVSQUARE */
681         /* PROP_RANDOM not used */
682 } HookModifierFalloff;
683
684 typedef struct HookModifierData {
685         ModifierData modifier;
686
687         struct Object *object;
688         /** Optional name of bone target, MAX_ID_NAME-2. */
689         char subtarget[64];
690
691         char flag;
692         /** Use enums from WarpModifier (exact same functionality). */
693         char falloff_type;
694         char _pad[6];
695         /** Matrix making current transform unmodified. */
696         float parentinv[4][4];
697         /** Visualization of hook. */
698         float cent[3];
699         /** If not zero, falloff is distance where influence zero. */
700         float falloff;
701
702         struct CurveMapping *curfalloff;
703
704         /** If NULL, it's using vertexgroup. */
705         int *indexar;
706         int totindex;
707         float force;
708         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
709         char name[64];
710 } HookModifierData;
711
712 typedef struct SoftbodyModifierData {
713         ModifierData modifier;
714 } SoftbodyModifierData;
715
716 typedef struct ClothModifierData {
717         ModifierData modifier;
718
719         /** The internal data structure for cloth. */
720         struct Cloth *clothObject;
721         /** Definition is in DNA_cloth_types.h. */
722         struct ClothSimSettings *sim_parms;
723         /** Definition is in DNA_cloth_types.h. */
724         struct ClothCollSettings *coll_parms;
725
726         /* PointCache can be shared with other instances of ClothModifierData.
727          * Inspect (modifier.flag & eModifierFlag_SharedCaches) to find out. */
728         /** Definition is in DNA_object_force_types.h. */
729         struct PointCache *point_cache;
730         struct ListBase ptcaches;
731
732         /* XXX nasty hack, remove once hair can be separated from cloth modifier data */
733         struct ClothHairData *hairdata;
734         /* grid geometry values of hair continuum */
735         float hair_grid_min[3];
736         float hair_grid_max[3];
737         int hair_grid_res[3];
738         float hair_grid_cellsize;
739
740         struct ClothSolverResult *solver_result;
741 } ClothModifierData;
742
743 typedef struct CollisionModifierData {
744         ModifierData modifier;
745
746         /** Position at the beginning of the frame. */
747         struct MVert *x;
748         /** Position at the end of the frame. */
749         struct MVert *xnew;
750         /** Unused atm, but was discussed during sprint. */
751         struct MVert *xold;
752         /** New position at the actual inter-frame step. */
753         struct MVert *current_xnew;
754         /** Position at the actual inter-frame step. */
755         struct MVert *current_x;
756         /** (xnew - x) at the actual inter-frame step. */
757         struct MVert *current_v;
758
759         struct MVertTri *tri;
760
761         unsigned int mvert_num;
762         unsigned int tri_num;
763         /** Cfra time of modifier. */
764         float time_x, time_xnew;
765         /** Collider doesn't move this frame, i.e. x[].co==xnew[].co. */
766         char is_static;
767         char _pad[7];
768
769         /** Bounding volume hierarchy for this cloth object. */
770         struct BVHTree *bvhtree;
771 } CollisionModifierData;
772
773 typedef struct SurfaceModifierData {
774         ModifierData modifier;
775
776         /** Old position. */
777         struct MVert *x;
778         /** Velocity. */
779         struct MVert *v;
780
781         struct Mesh *mesh;
782
783         /** Bounding volume hierarchy of the mesh faces. */
784         struct BVHTreeFromMesh *bvhtree;
785
786         int cfra, numverts;
787 } SurfaceModifierData;
788
789 typedef struct BooleanModifierData {
790         ModifierData modifier;
791
792         struct Object *object;
793         char operation;
794         char _pad[2];
795         char bm_flag;
796         float double_threshold;
797 } BooleanModifierData;
798
799 typedef enum {
800         eBooleanModifierOp_Intersect  = 0,
801         eBooleanModifierOp_Union      = 1,
802         eBooleanModifierOp_Difference = 2,
803 } BooleanModifierOp;
804
805 /* bm_flag (only used when G_DEBUG) */
806 enum {
807         eBooleanModifierBMeshFlag_BMesh_Separate            = (1 << 0),
808         eBooleanModifierBMeshFlag_BMesh_NoDissolve          = (1 << 1),
809         eBooleanModifierBMeshFlag_BMesh_NoConnectRegions    = (1 << 2),
810 };
811
812 typedef struct MDefInfluence {
813         int vertex;
814         float weight;
815 } MDefInfluence;
816
817 typedef struct MDefCell {
818         int offset;
819         int totinfluence;
820 } MDefCell;
821
822 typedef struct MeshDeformModifierData {
823         ModifierData modifier;
824
825         /** Mesh object. */
826         struct Object *object;
827         /** Optional vertexgroup name, MAX_VGROUP_NAME. */
828         char defgrp_name[64];
829
830         short gridsize, flag;
831         char _pad[4];
832
833         /* result of static binding */
834         /** Influences. */
835         MDefInfluence *bindinfluences;
836         /** Offsets into influences array. */
837         int *bindoffsets;
838         /** Coordinates that cage was bound with. */
839         float *bindcagecos;
840         /** Total vertices in mesh and cage. */
841         int totvert, totcagevert;
842
843         /* result of dynamic binding */
844         /** Grid with dynamic binding cell points. */
845         MDefCell *dyngrid;
846         /** Dynamic binding vertex influences. */
847         MDefInfluence *dyninfluences;
848         /** Is this vertex bound or not?. */
849         int *dynverts;
850         /** Size of the dynamic bind grid. */
851         int dyngridsize;
852         /** Total number of vertex influences. */
853         int totinfluence;
854         /** Offset of the dynamic bind grid. */
855         float dyncellmin[3];
856         /** Width of dynamic bind cell. */
857         float dyncellwidth;
858         /** Matrix of cage at binding time. */
859         float bindmat[4][4];
860
861         /* deprecated storage */
862         /** Deprecated inefficient storage. */
863         float *bindweights;
864         /** Deprecated storage of cage coords. */
865         float *bindcos;
866
867         /* runtime */
868         void (*bindfunc)(struct MeshDeformModifierData *mmd, struct Mesh *cagemesh,
869                          float *vertexcos, int totvert, float cagemat[4][4]);
870 } MeshDeformModifierData;
871
872 enum {
873         MOD_MDEF_INVERT_VGROUP = (1 << 0),
874         MOD_MDEF_DYNAMIC_BIND  = (1 << 1),
875 };
876
877 enum {
878         MOD_MDEF_VOLUME   = 0,
879         MOD_MDEF_SURFACE  = 1,
880 };
881
882 typedef struct ParticleSystemModifierData {
883         ModifierData modifier;
884
885         struct ParticleSystem *psys;
886         /** Final Mesh - its topology may differ from orig mesh. */
887         struct Mesh *mesh_final;
888         /** Original mesh that particles are attached to. */
889         struct Mesh *mesh_original;
890         int totdmvert, totdmedge, totdmface;
891         short flag;
892         char _pad[2];
893 } ParticleSystemModifierData;
894
895 typedef enum {
896         eParticleSystemFlag_Pars         = (1 << 0),
897         eParticleSystemFlag_psys_updated = (1 << 1),
898         eParticleSystemFlag_file_loaded  = (1 << 2),
899 } ParticleSystemModifierFlag;
900
901 typedef enum {
902         eParticleInstanceFlag_Parents   = (1 << 0),
903         eParticleInstanceFlag_Children  = (1 << 1),
904         eParticleInstanceFlag_Path      = (1 << 2),
905         eParticleInstanceFlag_Unborn    = (1 << 3),
906         eParticleInstanceFlag_Alive     = (1 << 4),
907         eParticleInstanceFlag_Dead      = (1 << 5),
908         eParticleInstanceFlag_KeepShape = (1 << 6),
909         eParticleInstanceFlag_UseSize   = (1 << 7),
910 } ParticleInstanceModifierFlag;
911
912 typedef enum {
913         eParticleInstanceSpace_World    = 0,
914         eParticleInstanceSpace_Local    = 1,
915 } ParticleInstanceModifierSpace;
916
917 typedef struct ParticleInstanceModifierData {
918         ModifierData modifier;
919
920         struct Object *ob;
921         short psys, flag, axis, space;
922         float position, random_position;
923         float rotation, random_rotation;
924         float particle_amount, particle_offset;
925         /** MAX_CUSTOMDATA_LAYER_NAME. */
926         char index_layer_name[64];
927         /** MAX_CUSTOMDATA_LAYER_NAME. */
928         char value_layer_name[64];
929 } ParticleInstanceModifierData;
930
931 typedef enum {
932         eExplodeFlag_CalcFaces = (1 << 0),
933         eExplodeFlag_PaSize    = (1 << 1),
934         eExplodeFlag_EdgeCut   = (1 << 2),
935         eExplodeFlag_Unborn    = (1 << 3),
936         eExplodeFlag_Alive     = (1 << 4),
937         eExplodeFlag_Dead      = (1 << 5),
938 } ExplodeModifierFlag;
939
940 typedef struct ExplodeModifierData {
941         ModifierData modifier;
942
943         int *facepa;
944         short flag, vgroup;
945         float protect;
946         /** MAX_CUSTOMDATA_LAYER_NAME. */
947         char uvname[64];
948 } ExplodeModifierData;
949
950 typedef struct MultiresModifierData {
951         ModifierData modifier;
952
953         char lvl, sculptlvl, renderlvl, totlvl;
954         char simple, flags, _pad[2];
955         short quality;
956         short uv_smooth;
957         char _pad2[4];
958 } MultiresModifierData;
959
960 typedef enum {
961         eMultiresModifierFlag_ControlEdges = (1 << 0),
962         /* DEPRECATED, only used for versioning. */
963         eMultiresModifierFlag_PlainUv_DEPRECATED      = (1 << 1),
964         eMultiresModifierFlag_UseCrease    =  (1 << 2),
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         int min_vertices;
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__ */