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