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