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