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