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