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