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