Fix compile error on 32 bits linux / windows, wireframe modifier needs padding.
[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
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         NUM_MODIFIER_TYPES
86 } ModifierType;
87
88 typedef enum ModifierMode {
89         eModifierMode_Realtime          = (1 << 0),
90         eModifierMode_Render            = (1 << 1),
91         eModifierMode_Editmode          = (1 << 2),
92         eModifierMode_OnCage            = (1 << 3),
93         eModifierMode_Expanded          = (1 << 4),
94         eModifierMode_Virtual           = (1 << 5),
95         eModifierMode_ApplyOnSpline     = (1 << 6),
96         eModifierMode_DisableTemporary  = (1 << 31)
97 } ModifierMode;
98
99 typedef struct ModifierData {
100         struct ModifierData *next, *prev;
101
102         int type, mode;
103         int stackindex, pad;
104         char name[64];  /* MAX_NAME */
105
106         /* XXX for timing info set by caller... solve later? (ton) */
107         struct Scene *scene;
108
109         char *error;
110 } ModifierData;
111
112 typedef enum {
113         eSubsurfModifierFlag_Incremental  = (1 << 0),
114         eSubsurfModifierFlag_DebugIncr    = (1 << 1),
115         eSubsurfModifierFlag_ControlEdges = (1 << 2),
116         eSubsurfModifierFlag_SubsurfUv    = (1 << 3),
117 } SubsurfModifierFlag;
118
119 /* not a real modifier */
120 typedef struct MappingInfoModifierData {
121         ModifierData modifier;
122
123         struct Tex *texture;
124         struct Object *map_object;
125         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
126         int uvlayer_tmp;
127         int texmapping;
128 } MappingInfoModifierData;
129
130 typedef struct SubsurfModifierData {
131         ModifierData modifier;
132
133         short subdivType, levels, renderLevels, flags;
134
135         void *emCache, *mCache;
136 } SubsurfModifierData;
137
138 typedef struct LatticeModifierData {
139         ModifierData modifier;
140
141         struct Object *object;
142         char name[64];          /* optional vertexgroup name, MAX_VGROUP_NAME */
143         float strength;
144         char pad[4];
145 } LatticeModifierData;
146
147 typedef struct CurveModifierData {
148         ModifierData modifier;
149
150         struct Object *object;
151         char name[64];          /* optional vertexgroup name, MAX_VGROUP_NAME */
152         short defaxis;          /* axis along which curve deforms */
153         char pad[6];
154 } CurveModifierData;
155
156 /* CurveModifierData->defaxis */
157 enum {
158         MOD_CURVE_POSX = 1,
159         MOD_CURVE_POSY = 2,
160         MOD_CURVE_POSZ = 3,
161         MOD_CURVE_NEGX = 4,
162         MOD_CURVE_NEGY = 5,
163         MOD_CURVE_NEGZ = 6,
164 };
165
166 typedef struct BuildModifierData {
167         ModifierData modifier;
168
169         float start, length;
170         int randomize, seed;
171 } BuildModifierData;
172
173 /* Mask Modifier */
174 typedef struct MaskModifierData {
175         ModifierData modifier;
176
177         struct Object *ob_arm;  /* armature to use to in place of hardcoded vgroup */
178         char vgroup[64];        /* name of vertex group to use to mask, MAX_VGROUP_NAME */
179
180         int mode;               /* using armature or hardcoded vgroup */
181         int flag;               /* flags for various things */
182 } MaskModifierData;
183
184 /* Mask Modifier -> mode */
185 enum {
186         MOD_MASK_MODE_VGROUP = 0,
187         MOD_MASK_MODE_ARM    = 1,
188 };
189
190 /* Mask Modifier -> flag */
191 enum {
192         MOD_MASK_INV         = (1 << 0),
193 };
194
195 typedef struct ArrayModifierData {
196         ModifierData modifier;
197
198         /* the object with which to cap the start of the array  */
199         struct Object *start_cap;
200         /* the object with which to cap the end of the array  */
201         struct Object *end_cap;
202         /* the curve object to use for MOD_ARR_FITCURVE */
203         struct Object *curve_ob;
204         /* the object to use for object offset */
205         struct Object *offset_ob;
206         /* a constant duplicate offset;
207          * 1 means the duplicates are 1 unit apart
208          */
209         float offset[3];
210         /* a scaled factor for duplicate offsets;
211          * 1 means the duplicates are 1 object-width apart
212          */
213         float scale[3];
214         /* the length over which to distribute the duplicates */
215         float length;
216         /* the limit below which to merge vertices in adjacent duplicates */
217         float merge_dist;
218         /* determines how duplicate count is calculated; one of:
219          * - MOD_ARR_FIXEDCOUNT -> fixed
220          * - MOD_ARR_FITLENGTH  -> calculated to fit a set length
221          * - MOD_ARR_FITCURVE   -> calculated to fit the length of a Curve object
222          */
223         int fit_type;
224         /* flags specifying how total offset is calculated; binary OR of:
225          * - MOD_ARR_OFF_CONST    -> total offset += offset
226          * - MOD_ARR_OFF_RELATIVE -> total offset += relative * object width
227          * - MOD_ARR_OFF_OBJ      -> total offset += offset_ob's matrix
228          * total offset is the sum of the individual enabled offsets
229          */
230         int offset_type;
231         /* general flags:
232          * MOD_ARR_MERGE -> merge vertices in adjacent duplicates
233          */
234         int flags;
235         /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */
236         int count;
237 } ArrayModifierData;
238
239 /* ArrayModifierData->fit_type */
240 enum {
241         MOD_ARR_FIXEDCOUNT = 0,
242         MOD_ARR_FITLENGTH  = 1,
243         MOD_ARR_FITCURVE   = 2,
244 };
245
246 /* ArrayModifierData->offset_type */
247 enum {
248         MOD_ARR_OFF_CONST    = (1 << 0),
249         MOD_ARR_OFF_RELATIVE = (1 << 1),
250         MOD_ARR_OFF_OBJ      = (1 << 2),
251 };
252
253 /* ArrayModifierData->flags */
254 enum {
255         MOD_ARR_MERGE      = (1 << 0),
256         MOD_ARR_MERGEFINAL = (1 << 1),
257 };
258
259 typedef struct MirrorModifierData {
260         ModifierData modifier;
261
262         short axis  DNA_DEPRECATED; /* deprecated, use flag instead */
263         short flag;
264         float tolerance;
265         struct Object *mirror_ob;
266 } MirrorModifierData;
267
268 /* MirrorModifierData->flag */
269 enum {
270         MOD_MIR_CLIPPING  = (1 << 0),
271         MOD_MIR_MIRROR_U  = (1 << 1),
272         MOD_MIR_MIRROR_V  = (1 << 2),
273         MOD_MIR_AXIS_X    = (1 << 3),
274         MOD_MIR_AXIS_Y    = (1 << 4),
275         MOD_MIR_AXIS_Z    = (1 << 5),
276         MOD_MIR_VGROUP    = (1 << 6),
277         MOD_MIR_NO_MERGE  = (1 << 7),
278 };
279
280 typedef struct EdgeSplitModifierData {
281         ModifierData modifier;
282
283         float split_angle;    /* angle above which edges should be split */
284         int flags;
285 } EdgeSplitModifierData;
286
287 /* EdgeSplitModifierData->flags */
288 enum {
289         MOD_EDGESPLIT_FROMANGLE  = (1 << 1),
290         MOD_EDGESPLIT_FROMFLAG   = (1 << 2),
291 };
292
293 typedef struct BevelModifierData {
294         ModifierData modifier;
295
296         float value;          /* the "raw" bevel value (distance/amount to bevel) */
297         int res;              /* the resolution (as originally coded, it is the number of recursive bevels) */
298         int pad;
299         short flags;          /* general option flags */
300         short val_flags;      /* flags used to interpret the bevel value */
301         short lim_flags;      /* flags to tell the tool how to limit the bevel */
302         short e_flags;        /* flags to direct how edge weights are applied to verts */
303         /* if the MOD_BEVEL_ANGLE is set, this will be how "sharp" an edge must be before it gets beveled */
304         float bevel_angle;
305         /* if the MOD_BEVEL_VWEIGHT option is set, this will be the name of the vert group, MAX_VGROUP_NAME */
306         char defgrp_name[64];
307 } BevelModifierData;
308
309 enum {
310         MOD_BEVEL_VERT          = (1 << 1),
311 /*      MOD_BEVEL_RADIUS        = (1 << 2), */
312         MOD_BEVEL_ANGLE         = (1 << 3),
313         MOD_BEVEL_WEIGHT        = (1 << 4),
314         MOD_BEVEL_VGROUP        = (1 << 5),
315         MOD_BEVEL_EMIN          = (1 << 7),
316         MOD_BEVEL_EMAX          = (1 << 8),
317 /*      MOD_BEVEL_RUNNING       = (1 << 9), */
318 /*      MOD_BEVEL_RES           = (1 << 10), */
319         /* This is a new setting not related to old (trunk bmesh bevel code)
320          * but adding here because they are mixed - campbell
321          */
322 /*      MOD_BEVEL_EVEN          = (1 << 11), */
323 /*      MOD_BEVEL_DIST          = (1 << 12), */  /* same as above */
324         MOD_BEVEL_OVERLAP_OK    = (1 << 13),
325 };
326
327 typedef struct SmokeModifierData {
328         ModifierData modifier;
329
330         struct SmokeDomainSettings *domain;
331         struct SmokeFlowSettings *flow; /* inflow, outflow, smoke objects */
332         struct SmokeCollSettings *coll; /* collision objects */
333         float time;
334         int type;  /* domain, inflow, outflow, ... */
335 } SmokeModifierData;
336
337 /* Smoke modifier flags */
338 enum {
339         MOD_SMOKE_TYPE_DOMAIN = (1 << 0),
340         MOD_SMOKE_TYPE_FLOW   = (1 << 1),
341         MOD_SMOKE_TYPE_COLL   = (1 << 2),
342 };
343
344 typedef struct DisplaceModifierData {
345         ModifierData modifier;
346
347         /* keep in sync with MappingInfoModifierData */
348         struct Tex *texture;
349         struct Object *map_object;
350         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
351         int uvlayer_tmp;
352         int texmapping;
353         /* end MappingInfoModifierData */
354
355         float strength;
356         int direction;
357         char defgrp_name[64];   /* MAX_VGROUP_NAME */
358         float midlevel;
359         int pad;
360 } DisplaceModifierData;
361
362 /* DisplaceModifierData->direction */
363 enum {
364         MOD_DISP_DIR_X       = 0,
365         MOD_DISP_DIR_Y       = 1,
366         MOD_DISP_DIR_Z       = 2,
367         MOD_DISP_DIR_NOR     = 3,
368         MOD_DISP_DIR_RGB_XYZ = 4,
369 };
370
371 /* DisplaceModifierData->texmapping */
372 enum {
373         MOD_DISP_MAP_LOCAL  = 0,
374         MOD_DISP_MAP_GLOBAL = 1,
375         MOD_DISP_MAP_OBJECT = 2,
376         MOD_DISP_MAP_UV     = 3,
377 };
378
379 typedef struct UVProjectModifierData {
380         ModifierData modifier;
381
382         /* the objects which do the projecting */
383         struct Object *projectors[10]; /* MOD_UVPROJECT_MAXPROJECTORS */
384         struct Image *image;           /* the image to project */
385         int flags;
386         int num_projectors;
387         float aspectx, aspecty;
388         float scalex, scaley;
389         char uvlayer_name[64];         /* MAX_CUSTOMDATA_LAYER_NAME */
390         int uvlayer_tmp, pad;
391 } UVProjectModifierData;
392
393 #define MOD_UVPROJECT_MAXPROJECTORS 10
394
395 /* UVProjectModifierData->flags */
396 enum {
397         MOD_UVPROJECT_OVERRIDEIMAGE = (1 << 0),
398 };
399
400 typedef struct DecimateModifierData {
401         ModifierData modifier;
402
403         float percent;  /* (mode == MOD_DECIM_MODE_COLLAPSE) */
404         short iter;     /* (mode == MOD_DECIM_MODE_UNSUBDIV) */
405         char delimit;   /* (mode == MOD_DECIM_MODE_DISSOLVE) */
406         char pad;
407         float angle;    /* (mode == MOD_DECIM_MODE_DISSOLVE) */
408
409         char defgrp_name[64];  /* MAX_VGROUP_NAME */
410         short flag, mode;
411
412         /* runtime only */
413         int face_count, pad2;
414 } DecimateModifierData;
415
416 enum {
417         MOD_DECIM_FLAG_INVERT_VGROUP       = (1 << 0),
418         MOD_DECIM_FLAG_TRIANGULATE         = (1 << 1),  /* for collapse only. dont convert tri pairs back to quads */
419         MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS  = (1 << 2),  /* for dissolve only. collapse all verts between 2 faces */
420 };
421
422 enum {
423         MOD_DECIM_MODE_COLLAPSE,
424         MOD_DECIM_MODE_UNSUBDIV,
425         MOD_DECIM_MODE_DISSOLVE,  /* called planar in the UI */
426 };
427
428 typedef struct SmoothModifierData {
429         ModifierData modifier;
430         float fac;
431         char defgrp_name[64];   /* MAX_VGROUP_NAME */
432         short flag, repeat;
433
434 } SmoothModifierData;
435
436 /* Smooth modifier flags */
437 enum {
438         MOD_SMOOTH_X = (1 << 1),
439         MOD_SMOOTH_Y = (1 << 2),
440         MOD_SMOOTH_Z = (1 << 3),
441 };
442
443 typedef struct CastModifierData {
444         ModifierData modifier;
445
446         struct Object *object;
447         float fac;
448         float radius;
449         float size;
450         char defgrp_name[64];  /* MAX_VGROUP_NAME */
451         short flag, type;
452 } CastModifierData;
453
454 /* Cast modifier flags */
455 enum {
456         /* And what bout (1 << 0) flag? ;) */
457         MOD_CAST_X                = (1 << 1),
458         MOD_CAST_Y                = (1 << 2),
459         MOD_CAST_Z                = (1 << 3),
460         MOD_CAST_USE_OB_TRANSFORM = (1 << 4),
461         MOD_CAST_SIZE_FROM_RADIUS = (1 << 5),
462 };
463
464 /* Cast modifier projection types */
465 enum {
466         MOD_CAST_TYPE_SPHERE   = 0,
467         MOD_CAST_TYPE_CYLINDER = 1,
468         MOD_CAST_TYPE_CUBOID   = 2,
469 };
470
471 typedef struct WaveModifierData {
472         ModifierData modifier;
473
474         /* keep in sync with MappingInfoModifierData */
475         struct Tex *texture;
476         struct Object *map_object;
477         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
478         int uvlayer_tmp;
479         int texmapping;
480         /* end MappingInfoModifierData */
481
482         struct Object *objectcenter;
483         char defgrp_name[64];   /* MAX_VGROUP_NAME */
484
485         short flag, pad;
486
487         float startx, starty, height, width;
488         float narrow, speed, damp, falloff;
489
490         float timeoffs, lifetime;
491         float pad1;
492 } WaveModifierData;
493
494 /* WaveModifierData.flag */
495 enum {
496         /* And what bout (1 << 0) flag? ;) */
497         MOD_WAVE_X      = (1 << 1),
498         MOD_WAVE_Y      = (1 << 2),
499         MOD_WAVE_CYCL   = (1 << 3),
500         MOD_WAVE_NORM   = (1 << 4),
501         MOD_WAVE_NORM_X = (1 << 5),
502         MOD_WAVE_NORM_Y = (1 << 6),
503         MOD_WAVE_NORM_Z = (1 << 7),
504 };
505
506 typedef struct ArmatureModifierData {
507         ModifierData modifier;
508
509         short deformflag, multi;  /* deformflag replaces armature->deformflag */
510         int pad2;
511         struct Object *object;
512         float *prevCos;           /* stored input of previous modifier, for vertexgroup blending */
513         char defgrp_name[64];     /* MAX_VGROUP_NAME */
514 } ArmatureModifierData;
515
516 typedef struct HookModifierData {
517         ModifierData modifier;
518
519         struct Object *object;
520         char subtarget[64];     /* optional name of bone target, MAX_ID_NAME-2 */
521
522         float parentinv[4][4];  /* matrix making current transform unmodified */
523         float cent[3];          /* visualization of hook */
524         float falloff;          /* if not zero, falloff is distance where influence zero */
525
526         int *indexar;           /* if NULL, it's using vertexgroup */
527         int totindex;
528         float force;
529         char name[64];          /* optional vertexgroup name, MAX_VGROUP_NAME */
530 } HookModifierData;
531
532 typedef struct SoftbodyModifierData {
533         ModifierData modifier;
534 } SoftbodyModifierData;
535
536 typedef struct ClothModifierData {
537         ModifierData modifier;
538
539         struct Scene *scene;                  /* the context, time etc is here */
540         struct Cloth *clothObject;            /* The internal data structure for cloth. */
541         struct ClothSimSettings *sim_parms;   /* definition is in DNA_cloth_types.h */
542         struct ClothCollSettings *coll_parms; /* definition is in DNA_cloth_types.h */
543         struct PointCache *point_cache;       /* definition is in DNA_object_force.h */
544         struct ListBase ptcaches;
545 } ClothModifierData;
546
547 typedef struct CollisionModifierData {
548         ModifierData modifier;
549
550         struct MVert *x;            /* position at the beginning of the frame */
551         struct MVert *xnew;         /* position at the end of the frame */
552         struct MVert *xold;         /* unused atm, but was discussed during sprint */
553         struct MVert *current_xnew; /* new position at the actual inter-frame step */
554         struct MVert *current_x;    /* position at the actual inter-frame step */
555         struct MVert *current_v;    /* (xnew - x) at the actual inter-frame step */
556
557         struct MFace *mfaces;       /* object face data */
558
559         unsigned int numverts;
560         unsigned int numfaces;
561         float time_x, time_xnew;    /* cfra time of modifier */
562         struct BVHTree *bvhtree;    /* bounding volume hierarchy for this cloth object */
563 } CollisionModifierData;
564
565 typedef struct SurfaceModifierData {
566         ModifierData modifier;
567
568         struct MVert *x; /* old position */
569         struct MVert *v; /* velocity */
570
571         struct DerivedMesh *dm;
572
573         struct BVHTreeFromMesh *bvhtree; /* bounding volume hierarchy of the mesh faces */
574
575         int cfra, numverts;
576 } SurfaceModifierData;
577
578 typedef struct BooleanModifierData {
579         ModifierData modifier;
580
581         struct Object *object;
582         int operation, pad;
583 } BooleanModifierData;
584
585 typedef enum {
586         eBooleanModifierOp_Intersect  = 0,
587         eBooleanModifierOp_Union      = 1,
588         eBooleanModifierOp_Difference = 2,
589 } BooleanModifierOp;
590
591 typedef struct MDefInfluence {
592         int vertex;
593         float weight;
594 } MDefInfluence;
595
596 typedef struct MDefCell {
597         int offset;
598         int totinfluence;
599 } MDefCell;
600
601 typedef struct MeshDeformModifierData {
602         ModifierData modifier;
603
604         struct Object *object;          /* mesh object */
605         char defgrp_name[64];           /* optional vertexgroup name, MAX_VGROUP_NAME */
606
607         short gridsize, flag, pad[2];
608
609         /* result of static binding */
610         MDefInfluence *bindinfluences;  /* influences */
611         int *bindoffsets;               /* offsets into influences array */
612         float *bindcagecos;             /* coordinates that cage was bound with */
613         int totvert, totcagevert;       /* total vertices in mesh and cage */
614
615         /* result of dynamic binding */
616         MDefCell *dyngrid;              /* grid with dynamic binding cell points */
617         MDefInfluence *dyninfluences;   /* dynamic binding vertex influences */
618         int *dynverts;                  /* is this vertex bound or not? */
619         int dyngridsize;                /* size of the dynamic bind grid */
620         int totinfluence;               /* total number of vertex influences */
621         float dyncellmin[3];            /* offset of the dynamic bind grid */
622         float dyncellwidth;             /* width of dynamic bind cell */
623         float bindmat[4][4];            /* matrix of cage at binding time */
624
625         /* deprecated storage */
626         float *bindweights;             /* deprecated inefficient storage */
627         float *bindcos;                 /* deprecated storage of cage coords */
628
629         /* runtime */
630         void (*bindfunc)(struct Scene *scene, struct MeshDeformModifierData *mmd,
631                          float *vertexcos, int totvert, float cagemat[4][4]);
632 } MeshDeformModifierData;
633
634 enum {
635         MOD_MDEF_INVERT_VGROUP = (1 << 0),
636         MOD_MDEF_DYNAMIC_BIND  = (1 << 1),
637 };
638
639 enum {
640         MOD_MDEF_VOLUME   = 0,
641         MOD_MDEF_SURFACE  = 1,
642 };
643
644 typedef struct ParticleSystemModifierData {
645         ModifierData modifier;
646
647         struct ParticleSystem *psys;
648         struct DerivedMesh *dm;
649         int totdmvert, totdmedge, totdmface;
650         short flag, pad;
651 } ParticleSystemModifierData;
652
653 typedef enum {
654         eParticleSystemFlag_Pars         = (1 << 0),
655         eParticleSystemFlag_psys_updated = (1 << 1),
656         eParticleSystemFlag_file_loaded  = (1 << 2),
657 } ParticleSystemModifierFlag;
658
659 typedef enum {
660         eParticleInstanceFlag_Parents   = (1 << 0),
661         eParticleInstanceFlag_Children  = (1 << 1),
662         eParticleInstanceFlag_Path      = (1 << 2),
663         eParticleInstanceFlag_Unborn    = (1 << 3),
664         eParticleInstanceFlag_Alive     = (1 << 4),
665         eParticleInstanceFlag_Dead      = (1 << 5),
666         eParticleInstanceFlag_KeepShape = (1 << 6),
667         eParticleInstanceFlag_UseSize   = (1 << 7),
668 } ParticleInstanceModifierFlag;
669
670 typedef struct ParticleInstanceModifierData {
671         ModifierData modifier;
672
673         struct Object *ob;
674         short psys, flag, axis, pad;
675         float position, random_position;
676 } ParticleInstanceModifierData;
677
678 typedef enum {
679         eExplodeFlag_CalcFaces = (1 << 0),
680         eExplodeFlag_PaSize    = (1 << 1),
681         eExplodeFlag_EdgeCut   = (1 << 2),
682         eExplodeFlag_Unborn    = (1 << 3),
683         eExplodeFlag_Alive     = (1 << 4),
684         eExplodeFlag_Dead      = (1 << 5),
685 } ExplodeModifierFlag;
686
687 typedef struct ExplodeModifierData {
688         ModifierData modifier;
689
690         int *facepa;
691         short flag, vgroup;
692         float protect;
693         char uvname[64]; /* MAX_CUSTOMDATA_LAYER_NAME */
694 } ExplodeModifierData;
695
696 typedef struct MultiresModifierData {
697         ModifierData modifier;
698
699         char lvl, sculptlvl, renderlvl, totlvl;
700         char simple, flags, pad[2];
701 } MultiresModifierData;
702
703 typedef enum {
704         eMultiresModifierFlag_ControlEdges = (1 << 0),
705         eMultiresModifierFlag_PlainUv      = (1 << 1),
706 } MultiresModifierFlag;
707
708 typedef struct FluidsimModifierData {
709         ModifierData modifier;
710
711         struct FluidsimSettings *fss;   /* definition is in DNA_object_fluidsim.h */
712         struct PointCache *point_cache; /* definition is in DNA_object_force.h */
713 } FluidsimModifierData;
714
715 typedef struct ShrinkwrapModifierData {
716         ModifierData modifier;
717
718         struct Object *target;    /* shrink target */
719         struct Object *auxTarget; /* additional shrink target */
720         char vgroup_name[64];     /* optional vertexgroup name, MAX_VGROUP_NAME */
721         float keepDist;           /* distance offset to keep from mesh/projection point */
722         short shrinkType;         /* shrink type projection */
723         short shrinkOpts;         /* shrink options */
724         float projLimit;          /* limit the projection ray cast */
725         char  projAxis;           /* axis to project over */
726
727         /* If using projection over vertex normal this controls the level of subsurface that must be done
728          * before getting the vertex coordinates and normal
729          */
730         char subsurfLevels;
731
732         char pad[2];
733 } ShrinkwrapModifierData;
734
735 /* Shrinkwrap->shrinkType */
736 enum {
737         MOD_SHRINKWRAP_NEAREST_SURFACE = 0,
738         MOD_SHRINKWRAP_PROJECT         = 1,
739         MOD_SHRINKWRAP_NEAREST_VERTEX  = 2,
740 };
741
742 /* Shrinkwrap->shrinkOpts */
743 enum {
744         /* allow shrinkwrap to move the vertex in the positive direction of axis */
745         MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR = (1 << 0),
746         /* allow shrinkwrap to move the vertex in the negative direction of axis */
747         MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR = (1 << 1),
748
749         /* ignore vertex moves if a vertex ends projected on a front face of the target */
750         MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE = (1 << 3),
751         /* ignore vertex moves if a vertex ends projected on a back face of the target */
752         MOD_SHRINKWRAP_CULL_TARGET_BACKFACE  = (1 << 4),
753
754         MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE    = (1 << 5),  /* distance is measure to the front face of the target */
755 };
756
757 /* Shrinkwrap->projAxis */
758 enum {
759         MOD_SHRINKWRAP_PROJECT_OVER_NORMAL   = 0,        /* projection over normal is used if no axis is selected */
760         MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS   = (1 << 0),
761         MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS   = (1 << 1),
762         MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS   = (1 << 2),
763 };
764
765
766 typedef struct SimpleDeformModifierData {
767         ModifierData modifier;
768
769         struct Object *origin;  /* object to control the origin of modifier space coordinates */
770         char vgroup_name[64];   /* optional vertexgroup name, MAX_VGROUP_NAME */
771         float factor;           /* factors to control simple deforms */
772         float limit[2];         /* lower and upper limit */
773
774         char mode;              /* deform function */
775         char axis;              /* lock axis (for taper and strech) */
776         char pad[2];
777
778 } SimpleDeformModifierData;
779
780 enum {
781         MOD_SIMPLEDEFORM_MODE_TWIST   = 1,
782         MOD_SIMPLEDEFORM_MODE_BEND    = 2,
783         MOD_SIMPLEDEFORM_MODE_TAPER   = 3,
784         MOD_SIMPLEDEFORM_MODE_STRETCH = 4,
785 };
786
787 enum {
788         MOD_SIMPLEDEFORM_LOCK_AXIS_X = (1 << 0),
789         MOD_SIMPLEDEFORM_LOCK_AXIS_Y = (1 << 1),
790 };
791
792 typedef struct ShapeKeyModifierData {
793         ModifierData modifier;
794 } ShapeKeyModifierData;
795
796 typedef struct SolidifyModifierData {
797         ModifierData modifier;
798
799         char defgrp_name[64];   /* name of vertex group to use, MAX_VGROUP_NAME */
800         float offset;           /* new surface offset level*/
801         float offset_fac;       /* midpoint of the offset  */
802         /* factor for the minimum weight to use when vgroups are used, avoids 0.0 weights giving duplicate geometry */
803         float offset_fac_vg;
804         float offset_clamp;     /* clamp offset based on surrounding geometry */
805         float pad;
806         float crease_inner;
807         float crease_outer;
808         float crease_rim;
809         int flag;
810         short mat_ofs;
811         short mat_ofs_rim;
812 } SolidifyModifierData;
813
814 enum {
815         MOD_SOLIDIFY_RIM            = (1 << 0),
816         MOD_SOLIDIFY_EVEN           = (1 << 1),
817         MOD_SOLIDIFY_NORMAL_CALC    = (1 << 2),
818         MOD_SOLIDIFY_VGROUP_INV     = (1 << 3),
819         MOD_SOLIDIFY_RIM_MATERIAL   = (1 << 4),  /* deprecated, used in do_versions */
820         MOD_SOLIDIFY_FLIP           = (1 << 5),
821 };
822
823 #if (DNA_DEPRECATED_GCC_POISON == 1)
824 #pragma GCC poison MOD_SOLIDIFY_RIM_MATERIAL
825 #endif
826
827 typedef struct ScrewModifierData {
828         ModifierData modifier;
829
830         struct Object *ob_axis;
831         unsigned int steps;
832         unsigned int render_steps;
833         unsigned int iter;
834         float screw_ofs;
835         float angle;
836         char axis;
837         char pad;
838         short flag;
839 } ScrewModifierData;
840
841 enum {
842         MOD_SCREW_NORMAL_FLIP    = (1 << 0),
843         MOD_SCREW_NORMAL_CALC    = (1 << 1),
844         MOD_SCREW_OBJECT_OFFSET  = (1 << 2),
845 /*      MOD_SCREW_OBJECT_ANGLE   = (1 << 4), */
846         MOD_SCREW_SMOOTH_SHADING = (1 << 5),
847         MOD_SCREW_UV_STRETCH_U   = (1 << 6),
848         MOD_SCREW_UV_STRETCH_V   = (1 << 7),
849 };
850
851 typedef struct OceanModifierData {
852         ModifierData modifier;
853
854         struct Ocean *ocean;
855         struct OceanCache *oceancache;
856         
857         int resolution;
858         int spatial_size;
859
860         float wind_velocity;
861
862         float damp;
863         float smallest_wave;
864         float depth;
865
866         float wave_alignment;
867         float wave_direction;
868         float wave_scale;
869
870         float chop_amount;
871         float foam_coverage;
872         float time;
873
874         int bakestart;
875         int bakeend;
876
877         char cachepath[1024];    /* FILE_MAX */
878         char foamlayername[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
879         char cached;
880         char geometry_mode;
881
882         char flag;
883         char refresh;
884
885         short repeat_x;
886         short repeat_y;
887
888         int seed;
889
890         float size;
891
892         float foam_fade;
893
894         int pad;
895 } OceanModifierData;
896
897 enum {
898         MOD_OCEAN_GEOM_GENERATE = 0,
899         MOD_OCEAN_GEOM_DISPLACE = 1,
900         MOD_OCEAN_GEOM_SIM_ONLY = 2,
901 };
902
903 enum {
904         MOD_OCEAN_REFRESH_RESET        = (1 << 0),
905         MOD_OCEAN_REFRESH_SIM          = (1 << 1),
906         MOD_OCEAN_REFRESH_ADD          = (1 << 2),
907         MOD_OCEAN_REFRESH_CLEAR_CACHE  = (1 << 3),
908         MOD_OCEAN_REFRESH_TOPOLOGY     = (1 << 4),
909 };
910
911 enum {
912         MOD_OCEAN_GENERATE_FOAM     = (1 << 0),
913         MOD_OCEAN_GENERATE_NORMALS  = (1 << 1),
914 };
915
916 typedef struct WarpModifierData {
917         ModifierData modifier;
918         /* keep in sync with MappingInfoModifierData */
919         struct Tex *texture;
920         struct Object *map_object;
921         char uvlayer_name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
922         int uvlayer_tmp;
923         int texmapping;
924         /* end MappingInfoModifierData */
925
926         struct Object *object_from;
927         struct Object *object_to;
928         struct CurveMapping *curfalloff;
929         char defgrp_name[64];  /* optional vertexgroup name, MAX_VGROUP_NAME */
930         float strength;
931         float falloff_radius;
932         char flag; /* not used yet */
933         char falloff_type;
934         char pad[6];
935 } WarpModifierData;
936
937 #define MOD_WARP_VOLUME_PRESERVE 1
938
939 typedef enum {
940         eWarp_Falloff_None   = 0,
941         eWarp_Falloff_Curve  = 1,
942         eWarp_Falloff_Sharp  = 2, /* PROP_SHARP */
943         eWarp_Falloff_Smooth = 3, /* PROP_SMOOTH */
944         eWarp_Falloff_Root   = 4, /* PROP_ROOT */
945         eWarp_Falloff_Linear = 5, /* PROP_LIN */
946         eWarp_Falloff_Const  = 6, /* PROP_CONST */
947         eWarp_Falloff_Sphere = 7, /* PROP_SPHERE */
948         /* PROP_RANDOM not used */
949 } WarpModifierFalloff;
950
951 typedef struct WeightVGEditModifierData {
952         ModifierData modifier;
953
954         char defgrp_name[64]; /* Name of vertex group to edit. MAX_VGROUP_NAME. */
955
956         short edit_flags;     /* Using MOD_WVG_EDIT_* flags. */
957         short falloff_type;   /* Using MOD_WVG_MAPPING_* defines. */
958         float default_weight; /* Weight for vertices not in vgroup. */
959
960         /* Mapping stuff. */
961         struct CurveMapping *cmap_curve;  /* The custom mapping curve! */
962
963         /* The add/remove vertices weight thresholds. */
964         float add_threshold, rem_threshold;
965
966         /* Masking options. */
967         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
968         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. 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 (using MOD_DISP_MAP_* enums). */
975         char mask_tex_uvlayer_name[64];    /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME */
976
977         /* Padding... */
978         int pad_i1;
979 } WeightVGEditModifierData;
980
981 /* WeightVGEdit flags. */
982 enum {
983         /* (1 << 0), (1 << 1) and (1 << 2) are free for future use! */
984         MOD_WVG_EDIT_ADD2VG  = (1 << 3),  /* Add vertices with higher weight than threshold to vgroup. */
985         MOD_WVG_EDIT_REMFVG  = (1 << 4),  /* Remove vertices with lower weight than threshold from vgroup. */
986 };
987
988 typedef struct WeightVGMixModifierData {
989         ModifierData modifier;
990
991         char defgrp_name_a[64];    /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
992         char defgrp_name_b[64];    /* Name of other vertex group to mix in. MAX_VGROUP_NAME. */
993         float default_weight_a;    /* Default weight value for first vgroup. */
994         float default_weight_b;    /* Default weight value to mix in. */
995         char mix_mode;             /* How second vgroups weights affect first ones */
996         char mix_set;              /* What vertices to affect. */
997
998         char pad_c1[6];
999
1000         /* Masking options. */
1001         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1002         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1003
1004         /* Texture masking. */
1005         int mask_tex_use_channel;         /* Which channel to use as weightf. */
1006         struct Tex *mask_texture;         /* The texture. */
1007         struct Object *mask_tex_map_obj;  /* Name of the map object. */
1008         int mask_tex_mapping;             /* How to map the texture! */
1009         char mask_tex_uvlayer_name[64];   /* Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */
1010
1011         /* Padding... */
1012         int pad_i1;
1013 } WeightVGMixModifierData;
1014
1015 /* How second vgroup's weights affect first ones. */
1016 enum {
1017         MOD_WVG_MIX_SET = 1,  /* Second weights replace weights. */
1018         MOD_WVG_MIX_ADD = 2,  /* Second weights are added to weights. */
1019         MOD_WVG_MIX_SUB = 3,  /* Second weights are subtracted from weights. */
1020         MOD_WVG_MIX_MUL = 4,  /* Second weights are multiplied with weights. */
1021         MOD_WVG_MIX_DIV = 5,  /* Second weights divide weights. */
1022         MOD_WVG_MIX_DIF = 6,  /* Difference between second weights and weights. */
1023         MOD_WVG_MIX_AVG = 7,  /* Average of both weights. */
1024 };
1025
1026 /* What vertices to affect. */
1027 enum {
1028         MOD_WVG_SET_ALL = 1,  /* Affect all vertices. */
1029         MOD_WVG_SET_A   = 2,  /* Affect only vertices in first vgroup. */
1030         MOD_WVG_SET_B   = 3,  /* Affect only vertices in second vgroup. */
1031         MOD_WVG_SET_OR  = 4,  /* Affect only vertices in one vgroup or the other. */
1032         MOD_WVG_SET_AND = 5,  /* Affect only vertices in both vgroups. */
1033 };
1034
1035 typedef struct WeightVGProximityModifierData {
1036         ModifierData modifier;
1037
1038         char defgrp_name[64];      /* Name of vertex group to modify/weight. MAX_VGROUP_NAME. */
1039
1040         /* Proximity modes. */
1041         int proximity_mode;
1042         int proximity_flags;
1043
1044         /* Target object from which to calculate vertices distances. */
1045         struct Object *proximity_ob_target;
1046
1047         /* Masking options. */
1048         float mask_constant;        /* The global "influence", if no vgroup nor tex is used as mask. */
1049         char mask_defgrp_name[64];  /* Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME */
1050
1051         /* Texture masking. */
1052         int mask_tex_use_channel;        /* Which channel to use as weightf. */
1053         struct Tex *mask_texture;        /* The texture. */
1054         struct Object *mask_tex_map_obj; /* Name of the map object. */
1055         int mask_tex_mapping;            /* How to map the texture! */
1056         char mask_tex_uvlayer_name[64];  /* Name of the UV Map. MAX_CUSTOMDATA_LAYER_NAME. */
1057
1058         float min_dist, max_dist;        /* Distances mapping to 0.0/1.0 weights. */
1059
1060         /* Put here to avoid breaking existing struct... */
1061         short falloff_type;              /* Using MOD_WVG_MAPPING_* enums. */
1062
1063         /* Padding... */
1064         short pad_s1;
1065 } WeightVGProximityModifierData;
1066
1067 /* Modes of proximity weighting. */
1068 enum {
1069         MOD_WVG_PROXIMITY_OBJECT    = 1,  /* source vertex to other location */
1070         MOD_WVG_PROXIMITY_GEOMETRY  = 2,  /* source vertex to other geometry */
1071 };
1072
1073 /* Flags options for proximity weighting. */
1074 enum {
1075         /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1076         MOD_WVG_PROXIMITY_GEOM_VERTS  = (1 << 0),
1077         /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1078         MOD_WVG_PROXIMITY_GEOM_EDGES  = (1 << 1),
1079         /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
1080         MOD_WVG_PROXIMITY_GEOM_FACES  = (1 << 2),
1081 };
1082
1083 /* Defines common to all WeightVG modifiers. */
1084 /* Mapping modes. */
1085 enum {
1086         MOD_WVG_MAPPING_NONE    = 0,
1087         MOD_WVG_MAPPING_CURVE   = 1,
1088         MOD_WVG_MAPPING_SHARP   = 2,  /* PROP_SHARP */
1089         MOD_WVG_MAPPING_SMOOTH  = 3,  /* PROP_SMOOTH */
1090         MOD_WVG_MAPPING_ROOT    = 4,  /* PROP_ROOT */
1091         /* PROP_LIN not used (same as NONE, here...). */
1092         /* PROP_CONST not used. */
1093         MOD_WVG_MAPPING_SPHERE  = 7,  /* PROP_SPHERE */
1094         MOD_WVG_MAPPING_RANDOM  = 8,  /* PROP_RANDOM */
1095         MOD_WVG_MAPPING_STEP    = 9,  /* Median Step. */
1096 };
1097
1098 /* Tex channel to be used as mask. */
1099 enum {
1100         MOD_WVG_MASK_TEX_USE_INT    = 1,
1101         MOD_WVG_MASK_TEX_USE_RED    = 2,
1102         MOD_WVG_MASK_TEX_USE_GREEN  = 3,
1103         MOD_WVG_MASK_TEX_USE_BLUE   = 4,
1104         MOD_WVG_MASK_TEX_USE_HUE    = 5,
1105         MOD_WVG_MASK_TEX_USE_SAT    = 6,
1106         MOD_WVG_MASK_TEX_USE_VAL    = 7,
1107         MOD_WVG_MASK_TEX_USE_ALPHA  = 8,
1108 };
1109
1110 typedef struct DynamicPaintModifierData {
1111         ModifierData modifier;
1112
1113         struct DynamicPaintCanvasSettings *canvas;
1114         struct DynamicPaintBrushSettings *brush;
1115         int type;  /* ui display: canvas / brush */
1116         int pad;
1117 } DynamicPaintModifierData;
1118
1119 /* Dynamic paint modifier flags */
1120 enum {
1121         MOD_DYNAMICPAINT_TYPE_CANVAS  = (1 << 0),
1122         MOD_DYNAMICPAINT_TYPE_BRUSH   = (1 << 1),
1123 };
1124
1125 /* Remesh modifier */
1126 typedef enum RemeshModifierFlags {
1127         MOD_REMESH_FLOOD_FILL     = 1,
1128         MOD_REMESH_SMOOTH_SHADING = 2,
1129 } RemeshModifierFlags;
1130
1131 typedef enum RemeshModifierMode {
1132         /* blocky */
1133         MOD_REMESH_CENTROID       = 0,
1134         /* smooth */
1135         MOD_REMESH_MASS_POINT     = 1,
1136         /* keeps sharp edges */
1137         MOD_REMESH_SHARP_FEATURES = 2,
1138 } RemeshModifierMode;
1139
1140 typedef struct RemeshModifierData {
1141         ModifierData modifier;
1142
1143         /* floodfill option, controls how small components can be before they are removed */
1144         float threshold;
1145
1146         /* ratio between size of model and grid */
1147         float scale;
1148
1149         float hermite_num;
1150
1151         /* octree depth */
1152         char depth;
1153
1154         char flag;
1155         char mode;
1156         char pad;
1157 } RemeshModifierData;
1158
1159 /* Skin modifier */
1160 typedef struct SkinModifierData {
1161         ModifierData modifier;
1162
1163         float branch_smoothing;
1164
1165         char flag;
1166
1167         char symmetry_axes;
1168
1169         char pad[2];
1170 } SkinModifierData;
1171
1172 /* SkinModifierData.symmetry_axes */
1173 enum {
1174         MOD_SKIN_SYMM_X = (1 << 0),
1175         MOD_SKIN_SYMM_Y = (1 << 1),
1176         MOD_SKIN_SYMM_Z = (1 << 2),
1177 };
1178
1179 /* SkinModifierData.flag */
1180 enum {
1181         MOD_SKIN_SMOOTH_SHADING = 1,
1182 };
1183
1184 /* Triangulate modifier */
1185 typedef struct TriangulateModifierData {
1186         ModifierData modifier;
1187
1188         int flag;
1189         int quad_method;
1190         int ngon_method;
1191         int pad;
1192 } TriangulateModifierData;
1193
1194 enum {
1195         MOD_TRIANGULATE_BEAUTY = (1 << 0), /* deprecated */
1196 };
1197
1198 #if (DNA_DEPRECATED_GCC_POISON == 1)
1199 #pragma GCC poison MOD_TRIANGULATE_BEAUTY
1200 #endif
1201
1202 /* Triangulate methods - NGons */
1203 enum {
1204         MOD_TRIANGULATE_NGON_BEAUTY = 0,
1205         MOD_TRIANGULATE_NGON_SCANFILL,
1206 };
1207
1208 /* Triangulate methods - Quads */
1209 enum {
1210         MOD_TRIANGULATE_QUAD_BEAUTY = 0,
1211         MOD_TRIANGULATE_QUAD_FIXED,
1212         MOD_TRIANGULATE_QUAD_ALTERNATE,
1213         MOD_TRIANGULATE_QUAD_SHORTEDGE
1214 };
1215
1216 typedef struct LaplacianSmoothModifierData {
1217         ModifierData modifier;
1218
1219         float lambda, lambda_border, pad1;
1220         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1221         short flag, repeat;
1222 } LaplacianSmoothModifierData;
1223
1224 /* Smooth modifier flags */
1225 enum {
1226         MOD_LAPLACIANSMOOTH_X               = (1 << 1),
1227         MOD_LAPLACIANSMOOTH_Y               = (1 << 2),
1228         MOD_LAPLACIANSMOOTH_Z               = (1 << 3),
1229         MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME = (1 << 4),
1230         MOD_LAPLACIANSMOOTH_NORMALIZED      = (1 << 5),
1231 };
1232
1233 typedef struct UVWarpModifierData {
1234         ModifierData modifier;
1235
1236         char axis_u, axis_v;
1237         char pad[6];
1238         float center[2];            /* used for rotate/scale */
1239
1240         struct Object *object_src;  /* source */
1241         char bone_src[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1242         struct Object *object_dst;  /* target */
1243         char bone_dst[64];          /* optional name of bone target, MAX_ID_NAME-2 */
1244
1245         char vgroup_name[64];       /* optional vertexgroup name, MAX_VGROUP_NAME */
1246         char uvlayer_name[64];      /* MAX_CUSTOMDATA_LAYER_NAME */
1247 } UVWarpModifierData;
1248
1249 /* cache modifier */
1250 typedef struct MeshCacheModifierData {
1251         ModifierData modifier;
1252
1253         char flag;
1254         char type;  /* file format */
1255         char time_mode;
1256         char play_mode;
1257
1258         /* axis conversion */
1259         char forward_axis;
1260         char up_axis;
1261         char flip_axis;
1262
1263         char interp;
1264
1265         float factor;
1266         char deform_mode;
1267         char pad[7];
1268
1269         /* play_mode == MOD_MESHCACHE_PLAY_CFEA */
1270         float frame_start;
1271         float frame_scale;
1272
1273         /* play_mode == MOD_MESHCACHE_PLAY_EVAL */
1274         /* we could use one float for all these but their purpose is very different */
1275         float eval_frame;
1276         float eval_time;
1277         float eval_factor;
1278
1279         char filepath[1024];  /* FILE_MAX */
1280 } MeshCacheModifierData;
1281
1282 enum {
1283         MOD_MESHCACHE_TYPE_MDD  = 1,
1284         MOD_MESHCACHE_TYPE_PC2  = 2,
1285 };
1286
1287 enum {
1288         MOD_MESHCACHE_DEFORM_OVERWRITE  = 0,
1289         MOD_MESHCACHE_DEFORM_INTEGRATE  = 1,
1290 };
1291
1292 enum {
1293         MOD_MESHCACHE_INTERP_NONE      = 0,
1294         MOD_MESHCACHE_INTERP_LINEAR    = 1,
1295 /*      MOD_MESHCACHE_INTERP_CARDINAL  = 2, */
1296 };
1297
1298 enum {
1299         MOD_MESHCACHE_TIME_FRAME   = 0,
1300         MOD_MESHCACHE_TIME_SECONDS = 1,
1301         MOD_MESHCACHE_TIME_FACTOR  = 2,
1302 };
1303
1304 enum {
1305         MOD_MESHCACHE_PLAY_CFEA = 0,
1306         MOD_MESHCACHE_PLAY_EVAL = 1,
1307 };
1308
1309
1310 typedef struct LaplacianDeformModifierData {
1311         ModifierData modifier;
1312         char anchor_grp_name[64];  /* MAX_VGROUP_NAME */
1313         int total_verts, repeat;
1314         float *vertexco;
1315         void *cache_system;  /* runtime only */
1316         short flag, pad[3];
1317
1318 } LaplacianDeformModifierData;
1319
1320 /* Smooth modifier flags */
1321 enum {
1322         MOD_LAPLACIANDEFORM_BIND = 1,
1323 };
1324
1325 /* many of these options match 'solidify' */
1326 typedef struct WireframeModifierData {
1327         ModifierData modifier;
1328         char defgrp_name[64];  /* MAX_VGROUP_NAME */
1329         float offset;
1330         float offset_fac;
1331         float offset_fac_vg;
1332         float crease_weight;
1333         short flag, mat_ofs;
1334         short pad[2];
1335 } WireframeModifierData;
1336
1337 enum {
1338         MOD_WIREFRAME_INVERT_VGROUP = (1 << 0),
1339         MOD_WIREFRAME_REPLACE       = (1 << 1),
1340         MOD_WIREFRAME_BOUNDARY      = (1 << 2),
1341         MOD_WIREFRAME_OFS_EVEN      = (1 << 3),
1342         MOD_WIREFRAME_OFS_RELATIVE  = (1 << 4),
1343         MOD_WIREFRAME_CREASE        = (1 << 5),
1344 };
1345
1346
1347
1348 #endif  /* __DNA_MODIFIER_TYPES_H__ */