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