code cleanup: make bmesh operator names more consistant since python has access to...
[blender.git] / source / blender / makesdna / DNA_modifier_types.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file DNA_modifier_types.h
22  *  \ingroup DNA
23  */
24
25 #ifndef __DNA_MODIFIER_TYPES_H__
26 #define __DNA_MODIFIER_TYPES_H__
27
28 #include "DNA_defs.h"
29 #include "DNA_listBase.h"
30
31 /* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE!
32  * (ONLY ADD NEW ITEMS AT THE END) */
33
34 typedef enum ModifierType {
35         eModifierType_None              = 0,
36         eModifierType_Subsurf           = 1,
37         eModifierType_Lattice           = 2,
38         eModifierType_Curve             = 3,
39         eModifierType_Build             = 4,
40         eModifierType_Mirror            = 5,
41         eModifierType_Decimate          = 6,
42         eModifierType_Wave              = 7,
43         eModifierType_Armature          = 8,
44         eModifierType_Hook              = 9,
45         eModifierType_Softbody          = 10,
46         eModifierType_Boolean           = 11,
47         eModifierType_Array             = 12,
48         eModifierType_EdgeSplit         = 13,
49         eModifierType_Displace          = 14,
50         eModifierType_UVProject         = 15,
51         eModifierType_Smooth            = 16,
52         eModifierType_Cast              = 17,
53         eModifierType_MeshDeform        = 18,
54         eModifierType_ParticleSystem    = 19,
55         eModifierType_ParticleInstance  = 20,
56         eModifierType_Explode           = 21,
57         eModifierType_Cloth             = 22,
58         eModifierType_Collision         = 23,
59         eModifierType_Bevel             = 24,
60         eModifierType_Shrinkwrap        = 25,
61         eModifierType_Fluidsim          = 26,
62         eModifierType_Mask              = 27,
63         eModifierType_SimpleDeform      = 28,
64         eModifierType_Multires          = 29,
65         eModifierType_Surface           = 30,
66         eModifierType_Smoke             = 31,
67         eModifierType_ShapeKey          = 32,
68         eModifierType_Solidify          = 33,
69         eModifierType_Screw             = 34,
70         eModifierType_Warp              = 35,
71         eModifierType_WeightVGEdit      = 36,
72         eModifierType_WeightVGMix       = 37,
73         eModifierType_WeightVGProximity = 38,
74         eModifierType_Ocean             = 39,
75         eModifierType_DynamicPaint      = 40,
76         eModifierType_Remesh            = 41,
77         eModifierType_Skin              = 42,
78         eModifierType_LaplacianSmooth   = 43,
79         eModifierType_Triangulate               = 44,
80         NUM_MODIFIER_TYPES
81 } ModifierType;
82
83 typedef enum ModifierMode {
84         eModifierMode_Realtime = (1<<0),
85         eModifierMode_Render = (1<<1),
86         eModifierMode_Editmode = (1<<2),
87         eModifierMode_OnCage = (1<<3),
88         eModifierMode_Expanded = (1<<4),
89         eModifierMode_Virtual = (1<<5),
90         eModifierMode_ApplyOnSpline = (1<<6),
91         eModifierMode_DisableTemporary = (1 << 31)
92 } ModifierMode;
93
94 typedef struct ModifierData {
95         struct ModifierData *next, *prev;
96
97         int type, mode;
98         int stackindex, pad;
99         char name[64];  /* MAX_NAME */
100         
101         /* XXX for timing info set by caller... solve later? (ton) */
102         struct Scene *scene;
103         
104         char *error;
105 } ModifierData;
106
107 typedef enum {
108         eSubsurfModifierFlag_Incremental = (1<<0),
109         eSubsurfModifierFlag_DebugIncr = (1<<1),
110         eSubsurfModifierFlag_ControlEdges = (1<<2),
111         eSubsurfModifierFlag_SubsurfUv = (1<<3)
112 } SubsurfModifierFlag;
113
114 /* not a real modifier */
115 typedef struct MappingInfoModifierData {
116         ModifierData modifier;
117
118         struct Tex *texture;
119         struct Object *map_object;
120         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
121         int uvlayer_tmp;
122         int texmapping;
123 } MappingInfoModifierData;
124
125 typedef struct SubsurfModifierData {
126         ModifierData modifier;
127
128         short subdivType, levels, renderLevels, flags;
129
130         void *emCache, *mCache;
131 } SubsurfModifierData;
132
133 typedef struct LatticeModifierData {
134         ModifierData modifier;
135
136         struct Object *object;
137         char name[64];                  /* optional vertexgroup name, MAX_VGROUP_NAME */
138         float strength;
139         char pad[4];
140 } LatticeModifierData;
141
142 typedef struct CurveModifierData {
143         ModifierData modifier;
144
145         struct Object *object;
146         char name[64];                  /* optional vertexgroup name, MAX_VGROUP_NAME */
147         short defaxis;                  /* axis along which curve deforms */
148         char pad[6];
149 } CurveModifierData;
150
151 /* CurveModifierData->defaxis */
152 #define MOD_CURVE_POSX  1
153 #define MOD_CURVE_POSY  2
154 #define MOD_CURVE_POSZ  3
155 #define MOD_CURVE_NEGX  4
156 #define MOD_CURVE_NEGY  5
157 #define MOD_CURVE_NEGZ  6
158
159 typedef struct BuildModifierData {
160         ModifierData modifier;
161
162         float start, length;
163         int randomize, seed;
164 } BuildModifierData;
165
166 /* Mask Modifier */
167 typedef struct MaskModifierData {
168         ModifierData modifier;
169         
170         struct Object *ob_arm;  /* armature to use to in place of hardcoded vgroup */
171         char vgroup[64];                /* name of vertex group to use to mask, MAX_VGROUP_NAME */
172         
173         int mode;                               /* using armature or hardcoded vgroup */
174         int flag;                               /* flags for various things */
175 } MaskModifierData;
176
177 /* Mask Modifier -> mode */
178 #define MOD_MASK_MODE_VGROUP            0
179 #define MOD_MASK_MODE_ARM                       1
180
181 /* Mask Modifier -> flag */
182 #define MOD_MASK_INV                    (1<<0)
183
184 typedef struct ArrayModifierData {
185         ModifierData modifier;
186
187         /* the object with which to cap the start of the array  */
188         struct Object *start_cap;
189         /* the object with which to cap the end of the array  */
190         struct Object *end_cap;
191         /* the curve object to use for MOD_ARR_FITCURVE */
192         struct Object *curve_ob;
193         /* the object to use for object offset */
194         struct Object *offset_ob;
195         /* a constant duplicate offset;
196          * 1 means the duplicates are 1 unit apart
197          */
198         float offset[3];
199         /* a scaled factor for duplicate offsets;
200          * 1 means the duplicates are 1 object-width apart
201          */
202         float scale[3];
203         /* the length over which to distribute the duplicates */
204         float length;
205         /* the limit below which to merge vertices in adjacent duplicates */
206         float merge_dist;
207         /* determines how duplicate count is calculated; one of:
208          * - MOD_ARR_FIXEDCOUNT -> fixed
209          * - MOD_ARR_FITLENGTH  -> calculated to fit a set length
210          * - MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
211          */
212         int fit_type;
213         /* flags specifying how total offset is calculated; binary OR of:
214          * - MOD_ARR_OFF_CONST    -> total offset += offset
215          * - MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
216          * - MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
217          * total offset is the sum of the individual enabled offsets
218          */
219         int offset_type;
220         /* general flags:
221          * MOD_ARR_MERGE -> merge vertices in adjacent duplicates
222          */
223         int flags;
224         /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */
225         int count;
226 } ArrayModifierData;
227
228 /* ArrayModifierData->fit_type */
229 #define MOD_ARR_FIXEDCOUNT 0
230 #define MOD_ARR_FITLENGTH  1
231 #define MOD_ARR_FITCURVE   2
232
233 /* ArrayModifierData->offset_type */
234 #define MOD_ARR_OFF_CONST    (1<<0)
235 #define MOD_ARR_OFF_RELATIVE (1<<1)
236 #define MOD_ARR_OFF_OBJ      (1<<2)
237
238 /* ArrayModifierData->flags */
239 #define MOD_ARR_MERGE      (1<<0)
240 #define MOD_ARR_MERGEFINAL (1<<1)
241
242 typedef struct MirrorModifierData {
243         ModifierData modifier;
244
245         short axis  DNA_DEPRECATED; /* deprecated, use flag instead */
246         short flag;
247         float tolerance;
248         struct Object *mirror_ob;
249 } MirrorModifierData;
250
251 /* MirrorModifierData->flag */
252 #define MOD_MIR_CLIPPING        (1<<0)
253 #define MOD_MIR_MIRROR_U        (1<<1)
254 #define MOD_MIR_MIRROR_V        (1<<2)
255 #define MOD_MIR_AXIS_X          (1<<3)
256 #define MOD_MIR_AXIS_Y          (1<<4)
257 #define MOD_MIR_AXIS_Z          (1<<5)
258 #define MOD_MIR_VGROUP          (1<<6)
259 #define MOD_MIR_NO_MERGE        (1<<7)
260
261 typedef struct EdgeSplitModifierData {
262         ModifierData modifier;
263
264         float split_angle;    /* angle above which edges should be split */
265         int flags;
266 } EdgeSplitModifierData;
267
268 /* EdgeSplitModifierData->flags */
269 #define MOD_EDGESPLIT_FROMANGLE   (1<<1)
270 #define MOD_EDGESPLIT_FROMFLAG    (1<<2)
271
272 typedef struct BevelModifierData {
273         ModifierData modifier;
274
275         float value;          /* the "raw" bevel value (distance/amount to bevel) */
276         int res;              /* the resolution (as originally coded, it is the number of recursive bevels) */
277         int pad;
278         short flags;          /* general option flags */
279         short val_flags;      /* flags used to interpret the bevel value */
280         short lim_flags;      /* flags to tell the tool how to limit the bevel */
281         short e_flags;        /* flags to direct how edge weights are applied to verts */
282         float bevel_angle;    /* if the BME_BEVEL_ANGLE is set, this will be how "sharp" an edge must be before it gets beveled */
283         char defgrp_name[64]; /* if the BME_BEVEL_VWEIGHT option is set, this will be the name of the vert group, MAX_VGROUP_NAME */
284 } BevelModifierData;
285
286 typedef struct BMeshModifierData {
287         ModifierData modifier;
288
289         float pad;
290         int type;
291 } BMeshModifierData;
292
293
294 /* Smoke modifier flags */
295 #define MOD_SMOKE_TYPE_DOMAIN (1 << 0)
296 #define MOD_SMOKE_TYPE_FLOW (1 << 1)
297 #define MOD_SMOKE_TYPE_COLL (1 << 2)
298
299 typedef struct SmokeModifierData {
300         ModifierData modifier;
301
302         struct SmokeDomainSettings *domain;
303         struct SmokeFlowSettings *flow; /* inflow, outflow, smoke objects */
304         struct SmokeCollSettings *coll; /* collision objects */
305         float time;
306         int type;  /* domain, inflow, outflow, ... */
307 } SmokeModifierData;
308
309 typedef struct DisplaceModifierData {
310         ModifierData modifier;
311
312         /* keep in sync with MappingInfoModifierData */
313         struct Tex *texture;
314         struct Object *map_object;
315         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
316         int uvlayer_tmp;
317         int texmapping;
318         /* end MappingInfoModifierData */
319
320         float strength;
321         int direction;
322         char defgrp_name[64];   /* MAX_VGROUP_NAME */
323         float midlevel;
324         int pad;
325 } DisplaceModifierData;
326
327 /* DisplaceModifierData->direction */
328 enum {
329         MOD_DISP_DIR_X = 0,
330         MOD_DISP_DIR_Y = 1,
331         MOD_DISP_DIR_Z = 2,
332         MOD_DISP_DIR_NOR = 3,
333         MOD_DISP_DIR_RGB_XYZ = 4,
334 };
335
336 /* DisplaceModifierData->texmapping */
337 enum {
338         MOD_DISP_MAP_LOCAL = 0,
339         MOD_DISP_MAP_GLOBAL = 1,
340         MOD_DISP_MAP_OBJECT = 2,
341         MOD_DISP_MAP_UV = 3
342 };
343
344 typedef struct UVProjectModifierData {
345         ModifierData modifier;
346
347         /* the objects which do the projecting */
348         struct Object *projectors[10]; /* MOD_UVPROJECT_MAX */
349         struct Image *image;      /* the image to project */
350         int flags;
351         int num_projectors;
352         float aspectx, aspecty;
353         float scalex, scaley;
354         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
355         int uvlayer_tmp, pad;
356 } UVProjectModifierData;
357
358 #define MOD_UVPROJECT_MAXPROJECTORS 10
359
360 /* UVProjectModifierData->flags */
361 #define MOD_UVPROJECT_OVERRIDEIMAGE (1<<0)
362
363 typedef struct DecimateModifierData {
364         ModifierData modifier;
365
366         float percent;  /* (mode == MOD_DECIM_MODE_COLLAPSE) */
367         short   iter;   /* (mode == MOD_DECIM_MODE_UNSUBDIV) */
368         short   pad;
369         float   angle;  /* (mode == MOD_DECIM_MODE_DISSOLVE) */
370
371         char defgrp_name[64];   /* MAX_VGROUP_NAME */
372         short flag, mode;
373
374         /* runtime only */
375         int face_count, pad2;
376 } DecimateModifierData;
377
378 enum {
379         MOD_DECIM_FLAG_INVERT_VGROUP       = (1 << 0),
380         MOD_DECIM_FLAG_TRIANGULATE         = (1 << 1),  /* for collapse only. dont convert tri pairs back to quads */
381         MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS  = (1 << 2)   /* for dissolve only. collapse all verts between 2 faces */
382 };
383
384 enum {
385         MOD_DECIM_MODE_COLLAPSE,
386         MOD_DECIM_MODE_UNSUBDIV,
387         MOD_DECIM_MODE_DISSOLVE   /* called planar in the UI */
388 };
389
390 /* Smooth modifier flags */
391 #define MOD_SMOOTH_X (1<<1)
392 #define MOD_SMOOTH_Y (1<<2)
393 #define MOD_SMOOTH_Z (1<<3)
394
395 typedef struct SmoothModifierData {
396         ModifierData modifier;
397         float fac;
398         char defgrp_name[64];   /* MAX_VGROUP_NAME */
399         short flag, repeat;
400
401 } SmoothModifierData;
402
403 /* Cast modifier flags */
404 #define MOD_CAST_X (1<<1)
405 #define MOD_CAST_Y (1<<2)
406 #define MOD_CAST_Z (1<<3)
407 #define MOD_CAST_USE_OB_TRANSFORM (1<<4)
408 #define MOD_CAST_SIZE_FROM_RADIUS (1<<5)
409
410 /* Cast modifier projection types */
411 #define MOD_CAST_TYPE_SPHERE 0
412 #define MOD_CAST_TYPE_CYLINDER 1
413 #define MOD_CAST_TYPE_CUBOID 2
414
415 typedef struct CastModifierData {
416         ModifierData modifier;
417
418         struct Object *object;
419         float fac;
420         float radius;
421         float size;
422         char defgrp_name[64];   /* MAX_VGROUP_NAME */
423         short flag, type;
424 } CastModifierData;
425
426 /* WaveModifierData.flag */
427 #define MOD_WAVE_X      (1<<1)
428 #define MOD_WAVE_Y      (1<<2)
429 #define MOD_WAVE_CYCL   (1<<3)
430 #define MOD_WAVE_NORM   (1<<4)
431 #define MOD_WAVE_NORM_X (1<<5)
432 #define MOD_WAVE_NORM_Y (1<<6)
433 #define MOD_WAVE_NORM_Z (1<<7)
434
435 typedef struct WaveModifierData {
436         ModifierData modifier;
437
438         /* keep in sync with MappingInfoModifierData */
439         struct Tex *texture;
440         struct Object *map_object;
441         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
442         int uvlayer_tmp;
443         int texmapping;
444         /* end MappingInfoModifierData */
445
446         struct Object *objectcenter;
447         char defgrp_name[64];   /* MAX_VGROUP_NAME */
448
449         short flag, pad;
450
451         float startx, starty, height, width;
452         float narrow, speed, damp, falloff;
453
454         float timeoffs, lifetime;
455         float pad1;
456 } WaveModifierData;
457
458 typedef struct ArmatureModifierData {
459         ModifierData modifier;
460
461         short deformflag, multi;                /* deformflag replaces armature->deformflag */
462         int pad2;
463         struct Object *object;
464         float *prevCos;         /* stored input of previous modifier, for vertexgroup blending */
465         char defgrp_name[64];   /* MAX_VGROUP_NAME */
466 } ArmatureModifierData;
467
468 typedef struct HookModifierData {
469         ModifierData modifier;
470
471         struct Object *object;
472         char subtarget[64];             /* optional name of bone target, MAX_ID_NAME-2 */
473         
474         float parentinv[4][4];  /* matrix making current transform unmodified */
475         float cent[3];                  /* visualization of hook */
476         float falloff;                  /* if not zero, falloff is distance where influence zero */
477         
478         int *indexar;                   /* if NULL, it's using vertexgroup */
479         int totindex;
480         float force;
481         char name[64];                  /* optional vertexgroup name, MAX_VGROUP_NAME */
482 } HookModifierData;
483
484 typedef struct SoftbodyModifierData {
485         ModifierData modifier;
486 } SoftbodyModifierData;
487
488 typedef struct ClothModifierData {
489         ModifierData            modifier;
490
491         struct Scene *scene;                    /* the context, time etc is here */
492         struct Cloth *clothObject;              /* The internal data structure for cloth. */
493         struct ClothSimSettings *sim_parms; /* definition is in DNA_cloth_types.h */
494         struct ClothCollSettings *coll_parms; /* definition is in DNA_cloth_types.h */
495         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
496         struct ListBase ptcaches;
497 } ClothModifierData;
498
499 typedef struct CollisionModifierData {
500         ModifierData    modifier;
501         
502         struct MVert *x; /* position at the beginning of the frame */
503         struct MVert *xnew; /* position at the end of the frame */
504         struct MVert *xold; /* unsued atm, but was discussed during sprint */
505         struct MVert *current_xnew; /* new position at the actual inter-frame step */
506         struct MVert *current_x; /* position at the actual inter-frame step */
507         struct MVert *current_v; /* (xnew - x) at the actual inter-frame step */
508         
509         struct MFace *mfaces; /* object face data */
510         
511         unsigned int numverts;
512         unsigned int numfaces;
513         float time_x, time_xnew;                /* cfra time of modifier */
514         struct BVHTree *bvhtree; /* bounding volume hierarchy for this cloth object */
515 } CollisionModifierData;
516
517 typedef struct SurfaceModifierData {
518         ModifierData    modifier;
519
520         struct MVert *x; /* old position */
521         struct MVert *v; /* velocity */
522
523         struct DerivedMesh *dm;
524
525         struct BVHTreeFromMesh *bvhtree; /* bounding volume hierarchy of the mesh faces */
526
527         int cfra, numverts;
528 } SurfaceModifierData;
529
530 typedef enum {
531         eBooleanModifierOp_Intersect = 0,
532         eBooleanModifierOp_Union = 1,
533         eBooleanModifierOp_Difference = 2,
534 } BooleanModifierOp;
535 typedef struct BooleanModifierData {
536         ModifierData modifier;
537
538         struct Object *object;
539         int operation, pad;
540 } BooleanModifierData;
541
542 #define MOD_MDEF_INVERT_VGROUP  (1<<0)
543 #define MOD_MDEF_DYNAMIC_BIND   (1<<1)
544
545 #define MOD_MDEF_VOLUME                 0
546 #define MOD_MDEF_SURFACE                1
547
548 typedef struct MDefInfluence {
549         int vertex;
550         float weight;
551 } MDefInfluence;
552
553 typedef struct MDefCell {
554         int offset;
555         int totinfluence;
556 } MDefCell;
557
558 typedef struct MeshDeformModifierData {
559         ModifierData modifier;
560
561         struct Object *object;                  /* mesh object */
562         char defgrp_name[64];                   /* optional vertexgroup name, MAX_VGROUP_NAME */
563
564         short gridsize, flag, mode, pad;
565
566         /* result of static binding */
567         MDefInfluence *bindinfluences;  /* influences */
568         int *bindoffsets;                               /* offsets into influences array */
569         float *bindcagecos;                             /* coordinates that cage was bound with */
570         int totvert, totcagevert;               /* total vertices in mesh and cage */
571
572         /* result of dynamic binding */
573         MDefCell *dyngrid;                              /* grid with dynamic binding cell points */
574         MDefInfluence *dyninfluences;   /* dynamic binding vertex influences */
575         int *dynverts, *pad2;                   /* is this vertex bound or not? */
576         int dyngridsize;                                /* size of the dynamic bind grid */
577         int totinfluence;                               /* total number of vertex influences */
578         float dyncellmin[3];                    /* offset of the dynamic bind grid */
579         float dyncellwidth;                             /* width of dynamic bind cell */
580         float bindmat[4][4];                    /* matrix of cage at binding time */
581
582         /* deprecated storage */
583         float *bindweights;                             /* deprecated inefficient storage */
584         float *bindcos;                                 /* deprecated storage of cage coords */
585
586         /* runtime */
587         void (*bindfunc)(struct Scene *scene,
588                 struct MeshDeformModifierData *mmd,
589                 float *vertexcos, int totvert, float cagemat[][4]);
590 } MeshDeformModifierData;
591
592 typedef enum {
593         eParticleSystemFlag_Pars =                      (1<<0),
594         eParticleSystemFlag_psys_updated =      (1<<1),
595         eParticleSystemFlag_file_loaded =       (1<<2),
596 } ParticleSystemModifierFlag;
597
598 typedef struct ParticleSystemModifierData {
599         ModifierData modifier;
600         struct ParticleSystem *psys;
601         struct DerivedMesh *dm;
602         int totdmvert, totdmedge, totdmface;
603         short flag, rt;
604 } ParticleSystemModifierData;
605
606 typedef enum {
607         eParticleInstanceFlag_Parents =         (1<<0),
608         eParticleInstanceFlag_Children =        (1<<1),
609         eParticleInstanceFlag_Path =            (1<<2),
610         eParticleInstanceFlag_Unborn =          (1<<3),
611         eParticleInstanceFlag_Alive =           (1<<4),
612         eParticleInstanceFlag_Dead =            (1<<5),
613         eParticleInstanceFlag_KeepShape =       (1<<6),
614         eParticleInstanceFlag_UseSize =         (1<<7),
615 } ParticleInstanceModifierFlag;
616
617 typedef struct ParticleInstanceModifierData {
618         ModifierData modifier;
619         struct Object *ob;
620         short psys, flag, axis, rt;
621         float position, random_position;
622 } ParticleInstanceModifierData;
623
624 typedef enum {
625         eExplodeFlag_CalcFaces =        (1<<0),
626         eExplodeFlag_PaSize =           (1<<1),
627         eExplodeFlag_EdgeCut =          (1<<2),
628         eExplodeFlag_Unborn =           (1<<3),
629         eExplodeFlag_Alive =            (1<<4),
630         eExplodeFlag_Dead =                     (1<<5),
631 } ExplodeModifierFlag;
632
633 typedef struct ExplodeModifierData {
634         ModifierData modifier;
635         int *facepa;
636         short flag, vgroup;
637         float protect;
638         char uvname[64];        /* MAX_CUSTOMDATA_LAYER_NAME */
639 } ExplodeModifierData;
640
641 typedef struct MultiresModifierData {
642         ModifierData modifier;
643
644         char lvl, sculptlvl, renderlvl, totlvl;
645         char simple, flags, pad[2];
646 } MultiresModifierData;
647
648 typedef enum {
649         eMultiresModifierFlag_ControlEdges = (1<<0),
650         eMultiresModifierFlag_PlainUv = (1<<1),
651 } MultiresModifierFlag;
652
653 typedef struct FluidsimModifierData {
654         ModifierData modifier;
655         
656         struct FluidsimSettings *fss; /* definition is in DNA_object_fluidsim.h */
657         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
658 } FluidsimModifierData;
659
660 typedef struct ShrinkwrapModifierData {
661         ModifierData modifier;
662
663         struct Object *target;  /* shrink target */
664         struct Object *auxTarget; /* additional shrink target */
665         char vgroup_name[64];   /* optional vertexgroup name, MAX_VGROUP_NAME */
666         float keepDist;                 /* distance offset to keep from mesh/projection point */
667         short shrinkType;               /* shrink type projection */
668         short shrinkOpts;               /* shrink options */
669         float projLimit;                /* limit the projection ray cast */
670         char  projAxis;                 /* axis to project over */
671
672         /*
673          * if using projection over vertex normal this controls the
674          * the level of subsurface that must be done before getting the
675          * vertex coordinates and normal
676          */
677         char subsurfLevels;
678
679         char pad[2];
680
681 } ShrinkwrapModifierData;
682
683 /* Shrinkwrap->shrinkType */
684 #define MOD_SHRINKWRAP_NEAREST_SURFACE  0
685 #define MOD_SHRINKWRAP_PROJECT                  1
686 #define MOD_SHRINKWRAP_NEAREST_VERTEX   2
687
688 /* Shrinkwrap->shrinkOpts */
689 #define MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR    (1<<0)  /* allow shrinkwrap to move the vertex in the positive direction of axis */
690 #define MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR    (1<<1)  /* allow shrinkwrap to move the vertex in the negative direction of axis */
691
692 #define MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE    (1<<3)  /* ignore vertex moves if a vertex ends projected on a front face of the target */
693 #define MOD_SHRINKWRAP_CULL_TARGET_BACKFACE             (1<<4)  /* ignore vertex moves if a vertex ends projected on a back face of the target */
694
695 #define MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE               (1<<5)  /* distance is measure to the front face of the target */
696
697 #define MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS              (1<<0)
698 #define MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS              (1<<1)
699 #define MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS              (1<<2)
700 #define MOD_SHRINKWRAP_PROJECT_OVER_NORMAL                      0       /* projection over normal is used if no axis is selected */
701
702
703 typedef struct SimpleDeformModifierData {
704         ModifierData modifier;
705
706         struct Object *origin;  /* object to control the origin of modifier space coordinates */
707         char vgroup_name[64];   /* optional vertexgroup name, MAX_VGROUP_NAME */
708         float factor;                   /* factors to control simple deforms */
709         float limit[2];                 /* lower and upper limit */
710
711         char mode;                              /* deform function */
712         char axis;                              /* lock axis (for taper and strech) */
713         char originOpts;                /* originOptions */
714         char pad;
715
716 } SimpleDeformModifierData;
717
718 #define MOD_SIMPLEDEFORM_MODE_TWIST             1
719 #define MOD_SIMPLEDEFORM_MODE_BEND              2
720 #define MOD_SIMPLEDEFORM_MODE_TAPER             3
721 #define MOD_SIMPLEDEFORM_MODE_STRETCH   4
722
723 #define MOD_SIMPLEDEFORM_LOCK_AXIS_X                    (1<<0)
724 #define MOD_SIMPLEDEFORM_LOCK_AXIS_Y                    (1<<1)
725
726 /* indicates whether simple deform should use the local
727  * coordinates or global coordinates of origin */
728 /* XXX, this should have never been an option, all other modifiers work relatively
729  * (so moving both objects makes no change!) - Campbell */
730 #define MOD_SIMPLEDEFORM_ORIGIN_LOCAL                   (1<<0)
731
732 #define MOD_UVPROJECT_MAX                               10
733
734 typedef struct ShapeKeyModifierData {
735         ModifierData modifier;
736 } ShapeKeyModifierData;
737
738 typedef struct SolidifyModifierData {
739         ModifierData modifier;
740
741         char defgrp_name[64];   /* name of vertex group to use, MAX_VGROUP_NAME */
742         float offset;                   /* new surface offset level*/
743         float offset_fac;               /* midpoint of the offset  */
744         float offset_fac_vg;    /* factor for the minimum weight to use when vgroups are used, avoids 0.0 weights giving duplicate geometry */
745         float crease_inner;
746         float crease_outer;
747         float crease_rim;
748         int flag;
749         short mat_ofs;
750         short mat_ofs_rim;
751 } SolidifyModifierData;
752
753 #define MOD_SOLIDIFY_RIM            (1 << 0)
754 #define MOD_SOLIDIFY_EVEN           (1 << 1)
755 #define MOD_SOLIDIFY_NORMAL_CALC    (1 << 2)
756 #define MOD_SOLIDIFY_VGROUP_INV     (1 << 3)
757 #define MOD_SOLIDIFY_RIM_MATERIAL   (1 << 4) /* deprecated, used in do_versions */
758 #define MOD_SOLIDIFY_FLIP           (1 << 5)
759
760 typedef struct ScrewModifierData {
761         ModifierData modifier;
762         struct Object *ob_axis;
763         int             steps;
764         int             render_steps;
765         int             iter;
766         float   screw_ofs;
767         float   angle;
768         short   axis;
769         short   flag;
770 } ScrewModifierData;
771
772 #define MOD_SCREW_NORMAL_FLIP    (1 << 0)
773 #define MOD_SCREW_NORMAL_CALC    (1 << 1)
774 #define MOD_SCREW_OBJECT_OFFSET  (1 << 2)
775 // #define MOD_SCREW_OBJECT_ANGLE       (1 << 4)
776 #define MOD_SCREW_SMOOTH_SHADING (1 << 5)
777
778 typedef struct OceanModifierData {
779         ModifierData modifier;
780         
781         struct Ocean *ocean;
782         struct OceanCache *oceancache;
783         
784         int             resolution;
785         int             spatial_size;
786         
787         float   wind_velocity;
788         
789         float   damp;
790         float   smallest_wave;
791         float   depth;
792         
793         float   wave_alignment;
794         float   wave_direction;
795         float   wave_scale;
796         
797         float   chop_amount;
798         float   foam_coverage;
799         float   time;
800         
801         int             bakestart;
802         int             bakeend;
803         
804         char    cachepath[1024];        // FILE_MAX
805         char    foamlayername[64];      /* MAX_CUSTOMDATA_LAYER_NAME */
806         char    cached;
807         char    geometry_mode;
808
809         char    flag;
810         char    refresh;
811
812         short   repeat_x;
813         short   repeat_y;
814
815         int             seed;
816
817         float   size;
818         
819         float   foam_fade;
820
821         int pad;
822
823 } OceanModifierData;
824
825 #define MOD_OCEAN_GEOM_GENERATE 0
826 #define MOD_OCEAN_GEOM_DISPLACE 1
827 #define MOD_OCEAN_GEOM_SIM_ONLY 2
828
829 #define MOD_OCEAN_REFRESH_RESET                 1
830 #define MOD_OCEAN_REFRESH_SIM                   2
831 #define MOD_OCEAN_REFRESH_ADD                   4
832 #define MOD_OCEAN_REFRESH_CLEAR_CACHE   8
833 #define MOD_OCEAN_REFRESH_TOPOLOGY              16
834
835 #define MOD_OCEAN_GENERATE_FOAM 1
836 #define MOD_OCEAN_GENERATE_NORMALS      2
837
838
839 typedef struct WarpModifierData {
840         ModifierData modifier;
841         /* keep in sync with MappingInfoModifierData */
842         struct Tex *texture;
843         struct Object *map_object;
844         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
845         int uvlayer_tmp;
846         int texmapping;
847         /* end MappingInfoModifierData */
848
849         struct Object *object_from;
850         struct Object *object_to;
851         struct CurveMapping *curfalloff;
852         char defgrp_name[64];                   /* optional vertexgroup name, MAX_VGROUP_NAME */
853         float strength;
854         float falloff_radius;
855         char flag; /* not used yet */
856         char falloff_type;
857         char pad[6];
858 } WarpModifierData;
859
860 #define MOD_WARP_VOLUME_PRESERVE 1
861
862 typedef enum {
863         eWarp_Falloff_None =            0,
864         eWarp_Falloff_Curve =           1,
865         eWarp_Falloff_Sharp =           2, /* PROP_SHARP */
866         eWarp_Falloff_Smooth =          3, /* PROP_SMOOTH */
867         eWarp_Falloff_Root =            4, /* PROP_ROOT */
868         eWarp_Falloff_Linear =          5, /* PROP_LIN */
869         eWarp_Falloff_Const =           6, /* PROP_CONST */
870         eWarp_Falloff_Sphere =          7, /* PROP_SPHERE */
871         /* PROP_RANDOM not used */
872 } WarpModifierFalloff;
873
874 typedef struct WeightVGEditModifierData {
875         ModifierData modifier;
876
877         /* Note: I tried to keep everything logically ordered - provided the
878          * alignment constraints... */
879
880         char    defgrp_name[64];      /* Name of vertex group to edit. MAX_VGROUP_NAME. */
881
882         short   edit_flags;     /* Using MOD_WVG_EDIT_* flags. */
883         short   falloff_type;   /* Using MOD_WVG_MAPPING_* defines. */
884         float   default_weight; /* Weight for vertices not in vgroup. */
885
886         /* Mapping stuff. */
887         struct CurveMapping *cmap_curve;  /* The custom mapping curve! */
888
889         /* The add/remove vertices weight thresholds. */
890         float   add_threshold, rem_threshold;
891
892         /* Masking options. */
893         float   mask_constant; /* The global "influence", if no vgroup nor tex is used as mask. */
894         /* Name of mask vertex group from which to get weight factors. */
895         char    mask_defgrp_name[64];   /* MAX_VGROUP_NAME */
896
897         /* Texture masking. */
898         int             mask_tex_use_channel;      /* Which channel to use as weightf. */
899         struct Tex *mask_texture;          /* The texture. */
900         struct Object *mask_tex_map_obj;   /* Name of the map object. */
901         /* How to map the texture (using MOD_DISP_MAP_* constants). */
902         int             mask_tex_mapping;
903         char    mask_tex_uvlayer_name[64]; /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME */
904
905         /* Padding... */
906         int pad_i1;
907 } WeightVGEditModifierData;
908
909 /* WeightVGEdit flags. */
910 /* Use parametric mapping. */
911 //#define MOD_WVG_EDIT_MAP                                      (1 << 0)
912 /* Use curve mapping. */
913 //#define MOD_WVG_EDIT_CMAP                                     (1 << 1)
914 /* Reverse weights (in the [0.0, 1.0] standard range). */
915 //#define MOD_WVG_EDIT_REVERSE_WEIGHTS          (1 << 2)
916 /* Add vertices with higher weight than threshold to vgroup. */
917 #define MOD_WVG_EDIT_ADD2VG                                     (1 << 3)
918 /* Remove vertices with lower weight than threshold from vgroup. */
919 #define MOD_WVG_EDIT_REMFVG                                     (1 << 4)
920 /* Clamp weights. */
921 //#define MOD_WVG_EDIT_CLAMP                                    (1 << 5)
922
923 typedef struct WeightVGMixModifierData {
924         ModifierData modifier;
925
926         /* XXX Note: I tried to keep everything logically ordered - provided the
927          *           alignment constraints... */
928
929         char    defgrp_name_a[64];      /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
930         char    defgrp_name_b[64];     /* Name of other vertex group to mix in. MAX_VGROUP_NAME. */
931         float   default_weight_a;       /* Default weight value for first vgroup. */
932         float   default_weight_b;      /* Default weight value to mix in. */
933         char    mix_mode;             /* How second vgroups weights affect first ones */
934         char    mix_set;              /* What vertices to affect. */
935
936         char    pad_c1[6];
937
938         /* Masking options. */
939         float   mask_constant; /* The global "influence", if no vgroup nor tex is used as mask. */
940         /* Name of mask vertex group from which to get weight factors. */
941         char    mask_defgrp_name[64];   /* MAX_VGROUP_NAME */
942
943         /* Texture masking. */
944         int             mask_tex_use_channel;      /* Which channel to use as weightf. */
945         struct Tex *mask_texture;          /* The texture. */
946         struct Object *mask_tex_map_obj;   /* Name of the map object. */
947         int             mask_tex_mapping;          /* How to map the texture! */
948         char    mask_tex_uvlayer_name[64]; /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */
949
950         /* Padding... */
951         int pad_i1;
952 } WeightVGMixModifierData;
953
954 /* How second vgroup's weights affect first ones. */
955 #define MOD_WVG_MIX_SET                 1 /* Second weights replace weights. */
956 #define MOD_WVG_MIX_ADD                 2 /* Second weights are added to weights. */
957 #define MOD_WVG_MIX_SUB                 3 /* Second weights are subtracted from weights. */
958 #define MOD_WVG_MIX_MUL                 4 /* Second weights are multiplied with weights. */
959 #define MOD_WVG_MIX_DIV                 5 /* Second weights divide weights. */
960 #define MOD_WVG_MIX_DIF                 6 /* Difference between second weights and weights. */
961 #define MOD_WVG_MIX_AVG                 7 /* Average of both weights. */
962
963 /* What vertices to affect. */
964 #define MOD_WVG_SET_ALL                 1 /* Affect all vertices. */
965 #define MOD_WVG_SET_A                   2 /* Affect only vertices in first vgroup. */
966 #define MOD_WVG_SET_B                   3 /* Affect only vertices in second vgroup. */
967 #define MOD_WVG_SET_OR                  4 /* Affect only vertices in one vgroup or the other. */
968 #define MOD_WVG_SET_AND                 5 /* Affect only vertices in both vgroups. */
969
970 typedef struct WeightVGProximityModifierData {
971         ModifierData modifier;
972
973         /* Note: I tried to keep everything logically ordered - provided the
974          * alignment constraints... */
975
976         char    defgrp_name[64];      /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
977
978         /* Proximity modes. */
979         int             proximity_mode;
980         int             proximity_flags;
981
982         /* Target object from which to calculate vertices distances. */
983         struct Object *proximity_ob_target;
984
985         /* Masking options. */
986         float   mask_constant; /* The global "influence", if no vgroup nor tex is used as mask. */
987         /* Name of mask vertex group from which to get weight factors. */
988         char    mask_defgrp_name[64];   /* MAX_VGROUP_NAME */
989
990         /* Texture masking. */
991         int             mask_tex_use_channel;      /* Which channel to use as weightf. */
992         struct Tex *mask_texture;          /* The texture. */
993         struct Object *mask_tex_map_obj;   /* Name of the map object. */
994         int             mask_tex_mapping;          /* How to map the texture! */
995         char    mask_tex_uvlayer_name[64]; /* Name of the UV Map. MAX_CUSTOMDATA_LAYER_NAME. */
996
997         float   min_dist, max_dist;        /* Distances mapping to 0.0/1.0 weights. */
998
999         /* Put here to avoid breaking existing struct... */
1000         short   falloff_type;              /* Using MOD_WVG_MAPPING_* defines. */
1001
1002         /* Padding... */
1003         short pad_s1;
1004 } WeightVGProximityModifierData;
1005
1006 /* Modes of proximity weighting. */
1007 /* Dist from target object to affected object. */
1008 #define MOD_WVG_PROXIMITY_OBJECT                        1 /* source vertex to other location */
1009 /* Dist from target object to vertex. */
1010 #define MOD_WVG_PROXIMITY_GEOMETRY                      2 /* source vertex to other geometry */
1011
1012 /* Flags options for proximity weighting. */
1013 /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1014 #define MOD_WVG_PROXIMITY_GEOM_VERTS            (1 << 0)
1015 /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1016 #define MOD_WVG_PROXIMITY_GEOM_EDGES            (1 << 1)
1017 /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1018 #define MOD_WVG_PROXIMITY_GEOM_FACES            (1 << 2)
1019
1020 /* Defines common to all WeightVG modifiers. */
1021 /* Mapping modes. */
1022 #define MOD_WVG_MAPPING_NONE                            0
1023 #define MOD_WVG_MAPPING_CURVE                           1
1024 #define MOD_WVG_MAPPING_SHARP                           2 /* PROP_SHARP */
1025 #define MOD_WVG_MAPPING_SMOOTH                          3 /* PROP_SMOOTH */
1026 #define MOD_WVG_MAPPING_ROOT                            4 /* PROP_ROOT */
1027 /* PROP_LIN not used (same as NONE, here...). */
1028 /* PROP_CONST not used. */
1029 #define MOD_WVG_MAPPING_SPHERE                          7 /* PROP_SPHERE */
1030 #define MOD_WVG_MAPPING_RANDOM                          8 /* PROP_RANDOM */
1031 #define MOD_WVG_MAPPING_STEP                            9 /* Median Step. */
1032
1033 /* Tex channel to be used as mask. */
1034 #define MOD_WVG_MASK_TEX_USE_INT                        1
1035 #define MOD_WVG_MASK_TEX_USE_RED                        2
1036 #define MOD_WVG_MASK_TEX_USE_GREEN                      3
1037 #define MOD_WVG_MASK_TEX_USE_BLUE                       4
1038 #define MOD_WVG_MASK_TEX_USE_HUE                        5
1039 #define MOD_WVG_MASK_TEX_USE_SAT                        6
1040 #define MOD_WVG_MASK_TEX_USE_VAL                        7
1041 #define MOD_WVG_MASK_TEX_USE_ALPHA                      8
1042
1043 /* Dynamic paint modifier flags */
1044 #define MOD_DYNAMICPAINT_TYPE_CANVAS (1 << 0)
1045 #define MOD_DYNAMICPAINT_TYPE_BRUSH (1 << 1)
1046
1047 typedef struct DynamicPaintModifierData {
1048         ModifierData modifier;
1049
1050         struct DynamicPaintCanvasSettings *canvas;
1051         struct DynamicPaintBrushSettings *brush;
1052         int type;  /* ui display: canvas / brush */
1053         int pad;
1054 } DynamicPaintModifierData;
1055
1056 /* Remesh modifier */
1057
1058 typedef enum RemeshModifierFlags {
1059         MOD_REMESH_FLOOD_FILL = 1,
1060         MOD_REMESH_SMOOTH_SHADING = 2,
1061 } RemeshModifierFlags;
1062
1063 typedef enum RemeshModifierMode {
1064         /* blocky */
1065         MOD_REMESH_CENTROID = 0,
1066         /* smooth */
1067         MOD_REMESH_MASS_POINT = 1,
1068         /* keeps sharp edges */
1069         MOD_REMESH_SHARP_FEATURES = 2,
1070 } RemeshModifierMode;
1071
1072 typedef struct RemeshModifierData {
1073         ModifierData modifier;
1074
1075         /* floodfill option, controls how small components can be
1076          * before they are removed */
1077         float threshold;
1078
1079         /* ratio between size of model and grid */
1080         float scale;
1081
1082         float hermite_num;
1083
1084         /* octree depth */
1085         char depth;
1086
1087         char flag;
1088         char mode;
1089         char pad;
1090 } RemeshModifierData;
1091
1092 /* Skin modifier */
1093
1094 typedef struct SkinModifierData {
1095         ModifierData modifier;
1096
1097         float branch_smoothing;
1098
1099         char flag;
1100         
1101         char symmetry_axes;
1102
1103         char pad[2];
1104 } SkinModifierData;
1105
1106 /* SkinModifierData.symmetry_axes */
1107 enum {
1108         MOD_SKIN_SYMM_X = 1,
1109         MOD_SKIN_SYMM_Y = 2,
1110         MOD_SKIN_SYMM_Z = 4,
1111 };
1112
1113 /* SkinModifierData.flag */
1114 enum {
1115         MOD_SKIN_SMOOTH_SHADING = 1
1116 };
1117
1118 /* Triangulate modifier */
1119
1120 typedef struct TriangulateModifierData {
1121         ModifierData modifier;
1122         int flag;
1123         int pad;
1124 } TriangulateModifierData;
1125
1126 enum {
1127         MOD_TRIANGULATE_BEAUTY = (1 << 0),
1128 };
1129
1130 /* Smooth modifier flags */
1131 #define MOD_LAPLACIANSMOOTH_X (1<<1)
1132 #define MOD_LAPLACIANSMOOTH_Y (1<<2)
1133 #define MOD_LAPLACIANSMOOTH_Z (1<<3)
1134 #define MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME (1 << 4)
1135
1136 typedef struct LaplacianSmoothModifierData {
1137         ModifierData modifier;
1138         float lambda, lambda_border, pad1;
1139         char defgrp_name[64]; /* MAX_VGROUP_NAME */
1140         short flag, repeat;
1141 } LaplacianSmoothModifierData;
1142
1143 #endif