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