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