1 /* 2 * This program is free software; you can redistribute it and/or 3 * modify it under the terms of the GNU General Public License 4 * as published by the Free Software Foundation; either version 2 5 * of the License, or (at your option) any later version. 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software Foundation, 14 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 15 */ 16 17 /** \file 18 * \ingroup DNA 19 */ 20 21 #pragma once 22 23 #include "DNA_defs.h" 24 #include "DNA_listBase.h" 25 #include "DNA_session_uuid_types.h" 26 27 #ifdef __cplusplus 28 extern "C" { 29 #endif 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 struct Mesh; 36 37 typedef enum ModifierType { 38 eModifierType_None = 0, 39 eModifierType_Subsurf = 1, 40 eModifierType_Lattice = 2, 41 eModifierType_Curve = 3, 42 eModifierType_Build = 4, 43 eModifierType_Mirror = 5, 44 eModifierType_Decimate = 6, 45 eModifierType_Wave = 7, 46 eModifierType_Armature = 8, 47 eModifierType_Hook = 9, 48 eModifierType_Softbody = 10, 49 eModifierType_Boolean = 11, 50 eModifierType_Array = 12, 51 eModifierType_EdgeSplit = 13, 52 eModifierType_Displace = 14, 53 eModifierType_UVProject = 15, 54 eModifierType_Smooth = 16, 55 eModifierType_Cast = 17, 56 eModifierType_MeshDeform = 18, 57 eModifierType_ParticleSystem = 19, 58 eModifierType_ParticleInstance = 20, 59 eModifierType_Explode = 21, 60 eModifierType_Cloth = 22, 61 eModifierType_Collision = 23, 62 eModifierType_Bevel = 24, 63 eModifierType_Shrinkwrap = 25, 64 eModifierType_Fluidsim = 26, 65 eModifierType_Mask = 27, 66 eModifierType_SimpleDeform = 28, 67 eModifierType_Multires = 29, 68 eModifierType_Surface = 30, 69 #ifdef DNA_DEPRECATED_ALLOW 70 eModifierType_Smoke = 31, 71 #endif 72 eModifierType_ShapeKey = 32, 73 eModifierType_Solidify = 33, 74 eModifierType_Screw = 34, 75 eModifierType_Warp = 35, 76 eModifierType_WeightVGEdit = 36, 77 eModifierType_WeightVGMix = 37, 78 eModifierType_WeightVGProximity = 38, 79 eModifierType_Ocean = 39, 80 eModifierType_DynamicPaint = 40, 81 eModifierType_Remesh = 41, 82 eModifierType_Skin = 42, 83 eModifierType_LaplacianSmooth = 43, 84 eModifierType_Triangulate = 44, 85 eModifierType_UVWarp = 45, 86 eModifierType_MeshCache = 46, 87 eModifierType_LaplacianDeform = 47, 88 eModifierType_Wireframe = 48, 89 eModifierType_DataTransfer = 49, 90 eModifierType_NormalEdit = 50, 91 eModifierType_CorrectiveSmooth = 51, 92 eModifierType_MeshSequenceCache = 52, 93 eModifierType_SurfaceDeform = 53, 94 eModifierType_WeightedNormal = 54, 95 eModifierType_Weld = 55, 96 eModifierType_Fluid = 56, 97 eModifierType_Simulation = 57, 98 eModifierType_MeshToVolume = 58, 99 eModifierType_VolumeDisplace = 59, 100 eModifierType_VolumeToMesh = 60, 101 NUM_MODIFIER_TYPES, 102 } ModifierType; 103 104 typedef enum ModifierMode { 105 eModifierMode_Realtime = (1 << 0), 106 eModifierMode_Render = (1 << 1), 107 eModifierMode_Editmode = (1 << 2), 108 eModifierMode_OnCage = (1 << 3), 109 /* Old modifier box expansion, just for versioning. */ 110 eModifierMode_Expanded_DEPRECATED = (1 << 4), 111 eModifierMode_Virtual = (1 << 5), 112 eModifierMode_ApplyOnSpline = (1 << 6), 113 eModifierMode_DisableTemporary = (1u << 31), 114 } ModifierMode; 115 116 typedef struct ModifierData { 117 struct ModifierData *next, *prev; 118 119 int type, mode; 120 char _pad0[4]; 121 short flag; 122 /* An "expand" bit for each of the modifier's (sub)panels. */ 123 short ui_expand_flag; 124 /** MAX_NAME. */ 125 char name[64]; 126 127 char *error; 128 129 /* Pointer to a ModifierData in the original domain. */ 130 struct ModifierData *orig_modifier_data; 131 132 /* Runtime field which contains unique identifier of the modifier. */ 133 SessionUUID session_uuid; 134 135 /* Runtime field which contains runtime data which is specific to a modifier type. */ 136 void *runtime; 137 } ModifierData; 138 139 typedef enum { 140 /* This modifier has been inserted in local override, and hence can be fully edited. */ 141 eModifierFlag_OverrideLibrary_Local = (1 << 0), 142 /* This modifier does not own its caches, but instead shares them with another modifier. */ 143 eModifierFlag_SharedCaches = (1 << 1), 144 } ModifierFlag; 145 146 /* not a real modifier */ 147 typedef struct MappingInfoModifierData { 148 ModifierData modifier; 149 150 struct Tex *texture; 151 struct Object *map_object; 152 char map_bone[64]; 153 /** MAX_CUSTOMDATA_LAYER_NAME. */ 154 char uvlayer_name[64]; 155 int uvlayer_tmp; 156 int texmapping; 157 } MappingInfoModifierData; 158 159 typedef enum { 160 eSubsurfModifierFlag_Incremental = (1 << 0), 161 eSubsurfModifierFlag_DebugIncr = (1 << 1), 162 eSubsurfModifierFlag_ControlEdges = (1 << 2), 163 /* DEPRECATED, ONLY USED FOR DO-VERSIONS */ 164 eSubsurfModifierFlag_SubsurfUv_DEPRECATED = (1 << 3), 165 eSubsurfModifierFlag_UseCrease = (1 << 4), 166 eSubsurfModifierFlag_UseCustomNormals = (1 << 5), 167 eSubsurfModifierFlag_UseRecursiveSubdivision = (1 << 6), 168 } SubsurfModifierFlag; 169 170 typedef enum { 171 SUBSURF_TYPE_CATMULL_CLARK = 0, 172 SUBSURF_TYPE_SIMPLE = 1, 173 } eSubsurfModifierType; 174 175 typedef enum { 176 SUBSURF_UV_SMOOTH_NONE = 0, 177 SUBSURF_UV_SMOOTH_PRESERVE_CORNERS = 1, 178 SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_AND_JUNCTIONS = 2, 179 SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE = 3, 180 SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES = 4, 181 SUBSURF_UV_SMOOTH_ALL = 5, 182 } eSubsurfUVSmooth; 183 184 typedef enum { 185 SUBSURF_BOUNDARY_SMOOTH_ALL = 0, 186 SUBSURF_BOUNDARY_SMOOTH_PRESERVE_CORNERS = 1, 187 } eSubsurfBoundarySmooth; 188 189 typedef struct SubsurfModifierData { 190 ModifierData modifier; 191 192 short subdivType, levels, renderLevels, flags; 193 short uv_smooth; 194 short quality; 195 short boundary_smooth; 196 char _pad[2]; 197 198 /* TODO(sergey): Get rid of those with the old CCG subdivision code. */ 199 void *emCache, *mCache; 200 } SubsurfModifierData; 201 202 typedef struct LatticeModifierData { 203 ModifierData modifier; 204 205 struct Object *object; 206 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 207 char name[64]; 208 float strength; 209 short flag; 210 char _pad[2]; 211 } LatticeModifierData; 212 213 /*Lattice modifier flags */ 214 enum { 215 MOD_LATTICE_INVERT_VGROUP = (1 << 0), 216 }; 217 218 typedef struct CurveModifierData { 219 ModifierData modifier; 220 221 struct Object *object; 222 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 223 char name[64]; 224 /** Axis along which curve deforms. */ 225 short defaxis; 226 short flag; 227 char _pad[4]; 228 } CurveModifierData; 229 230 /* Curve modifier flags */ 231 enum { 232 MOD_CURVE_INVERT_VGROUP = (1 << 0), 233 }; 234 235 /* CurveModifierData->defaxis */ 236 enum { 237 MOD_CURVE_POSX = 1, 238 MOD_CURVE_POSY = 2, 239 MOD_CURVE_POSZ = 3, 240 MOD_CURVE_NEGX = 4, 241 MOD_CURVE_NEGY = 5, 242 MOD_CURVE_NEGZ = 6, 243 }; 244 245 typedef struct BuildModifierData { 246 ModifierData modifier; 247 248 float start, length; 249 short flag; 250 251 /** (bool) whether order of vertices is randomized - legacy files (for readfile conversion). */ 252 short randomize; 253 /** (int) random seed. */ 254 int seed; 255 } BuildModifierData; 256 257 /* Build Modifier -> flag */ 258 enum { 259 /** order of vertices is randomized */ 260 MOD_BUILD_FLAG_RANDOMIZE = (1 << 0), 261 /** frame range is reversed, resulting in a deconstruction effect */ 262 MOD_BUILD_FLAG_REVERSE = (1 << 1), 263 }; 264 265 /* Mask Modifier */ 266 typedef struct MaskModifierData { 267 ModifierData modifier; 268 269 /** Armature to use to in place of hardcoded vgroup. */ 270 struct Object *ob_arm; 271 /** Name of vertex group to use to mask, MAX_VGROUP_NAME. */ 272 char vgroup[64]; 273 274 /** Using armature or hardcoded vgroup. */ 275 short mode; 276 /** Flags for various things. */ 277 short flag; 278 float threshold; 279 } MaskModifierData; 280 281 /* Mask Modifier -> mode */ 282 enum { 283 MOD_MASK_MODE_VGROUP = 0, 284 MOD_MASK_MODE_ARM = 1, 285 }; 286 287 /* Mask Modifier -> flag */ 288 enum { 289 MOD_MASK_INV = (1 << 0), 290 }; 291 292 typedef struct ArrayModifierData { 293 ModifierData modifier; 294 295 /* the object with which to cap the start of the array */ 296 struct Object *start_cap; 297 /* the object with which to cap the end of the array */ 298 struct Object *end_cap; 299 /* the curve object to use for MOD_ARR_FITCURVE */ 300 struct Object *curve_ob; 301 /* the object to use for object offset */ 302 struct Object *offset_ob; 303 /* a constant duplicate offset; 304 * 1 means the duplicates are 1 unit apart 305 */ 306 float offset[3]; 307 /* a scaled factor for duplicate offsets; 308 * 1 means the duplicates are 1 object-width apart 309 */ 310 float scale[3]; 311 /* the length over which to distribute the duplicates */ 312 float length; 313 /* the limit below which to merge vertices in adjacent duplicates */ 314 float merge_dist; 315 /* determines how duplicate count is calculated; one of: 316 * - MOD_ARR_FIXEDCOUNT -> fixed 317 * - MOD_ARR_FITLENGTH -> calculated to fit a set length 318 * - MOD_ARR_FITCURVE -> calculated to fit the length of a Curve object 319 */ 320 int fit_type; 321 /* flags specifying how total offset is calculated; binary OR of: 322 * - MOD_ARR_OFF_CONST -> total offset += offset 323 * - MOD_ARR_OFF_RELATIVE -> total offset += relative * object width 324 * - MOD_ARR_OFF_OBJ -> total offset += offset_ob's matrix 325 * total offset is the sum of the individual enabled offsets 326 */ 327 int offset_type; 328 /* general flags: 329 * MOD_ARR_MERGE -> merge vertices in adjacent duplicates 330 */ 331 int flags; 332 /* the number of duplicates to generate for MOD_ARR_FIXEDCOUNT */ 333 int count; 334 float uv_offset[2]; 335 } ArrayModifierData; 336 337 /* ArrayModifierData->fit_type */ 338 enum { 339 MOD_ARR_FIXEDCOUNT = 0, 340 MOD_ARR_FITLENGTH = 1, 341 MOD_ARR_FITCURVE = 2, 342 }; 343 344 /* ArrayModifierData->offset_type */ 345 enum { 346 MOD_ARR_OFF_CONST = (1 << 0), 347 MOD_ARR_OFF_RELATIVE = (1 << 1), 348 MOD_ARR_OFF_OBJ = (1 << 2), 349 }; 350 351 /* ArrayModifierData->flags */ 352 enum { 353 MOD_ARR_MERGE = (1 << 0), 354 MOD_ARR_MERGEFINAL = (1 << 1), 355 }; 356 357 typedef struct MirrorModifierData { 358 ModifierData modifier; 359 360 /** Deprecated, use flag instead. */ 361 short axis DNA_DEPRECATED; 362 short flag; 363 float tolerance; 364 float uv_offset[2]; 365 float uv_offset_copy[2]; 366 struct Object *mirror_ob; 367 } MirrorModifierData; 368 369 /* MirrorModifierData->flag */ 370 enum { 371 MOD_MIR_CLIPPING = (1 << 0), 372 MOD_MIR_MIRROR_U = (1 << 1), 373 MOD_MIR_MIRROR_V = (1 << 2), 374 MOD_MIR_AXIS_X = (1 << 3), 375 MOD_MIR_AXIS_Y = (1 << 4), 376 MOD_MIR_AXIS_Z = (1 << 5), 377 MOD_MIR_VGROUP = (1 << 6), 378 MOD_MIR_NO_MERGE = (1 << 7), 379 MOD_MIR_BISECT_AXIS_X = (1 << 8), 380 MOD_MIR_BISECT_AXIS_Y = (1 << 9), 381 MOD_MIR_BISECT_AXIS_Z = (1 << 10), 382 MOD_MIR_BISECT_FLIP_AXIS_X = (1 << 11), 383 MOD_MIR_BISECT_FLIP_AXIS_Y = (1 << 12), 384 MOD_MIR_BISECT_FLIP_AXIS_Z = (1 << 13), 385 MOD_MIR_MIRROR_UDIM = (1 << 14), 386 }; 387 388 typedef struct EdgeSplitModifierData { 389 ModifierData modifier; 390 391 /** Angle above which edges should be split. */ 392 float split_angle; 393 int flags; 394 } EdgeSplitModifierData; 395 396 /* EdgeSplitModifierData->flags */ 397 enum { 398 MOD_EDGESPLIT_FROMANGLE = (1 << 1), 399 MOD_EDGESPLIT_FROMFLAG = (1 << 2), 400 }; 401 402 typedef struct BevelModifierData { 403 ModifierData modifier; 404 405 /** The "raw" bevel value (distance/amount to bevel). */ 406 float value; 407 /** The resolution (as originally coded, it is the number of recursive bevels). */ 408 int res; 409 /** General option flags. */ 410 short flags; 411 /** Used to interpret the bevel value. */ 412 short val_flags; 413 /** For the type and how we build the bevel's profile. */ 414 short profile_type; 415 /** Flags to tell the tool how to limit the bevel. */ 416 short lim_flags; 417 /** Flags to direct how edge weights are applied to verts. */ 418 short e_flags; 419 /** Material index if >= 0, else material inherited from surrounding faces. */ 420 short mat; 421 short edge_flags; 422 short face_str_mode; 423 /** Patterns to use for mitering non-reflex and reflex miter edges */ 424 short miter_inner; 425 short miter_outer; 426 /** The method to use for creating >2-way intersections */ 427 short vmesh_method; 428 /** Whether to affect vertices or edges. */ 429 char affect_type; 430 char _pad; 431 /** Controls profile shape (0->1, .5 is round). */ 432 float profile; 433 /** if the MOD_BEVEL_ANGLE is set, 434 * this will be how "sharp" an edge must be before it gets beveled */ 435 float bevel_angle; 436 float spread; 437 /** if the MOD_BEVEL_VWEIGHT option is set, 438 * this will be the name of the vert group, MAX_VGROUP_NAME */ 439 char defgrp_name[64]; 440 441 char _pad1[4]; 442 /** Curve info for the custom profile */ 443 struct CurveProfile *custom_profile; 444 445 } BevelModifierData; 446 447 /* BevelModifierData->flags and BevelModifierData->lim_flags */ 448 enum { 449 #ifdef DNA_DEPRECATED_ALLOW 450 MOD_BEVEL_VERT_DEPRECATED = (1 << 1), 451 #endif 452 MOD_BEVEL_INVERT_VGROUP = (1 << 2), 453 MOD_BEVEL_ANGLE = (1 << 3), 454 MOD_BEVEL_WEIGHT = (1 << 4), 455 MOD_BEVEL_VGROUP = (1 << 5), 456 /* unused = (1 << 6), */ 457 #ifdef DNA_DEPRECATED_ALLOW 458 MOD_BEVEL_CUSTOM_PROFILE_DEPRECATED = (1 << 7), 459 #endif 460 /* unused = (1 << 8), */ 461 /* unused = (1 << 9), */ 462 /* unused = (1 << 10), */ 463 /* unused = (1 << 11), */ 464 /* unused = (1 << 12), */ 465 MOD_BEVEL_OVERLAP_OK = (1 << 13), 466 MOD_BEVEL_EVEN_WIDTHS = (1 << 14), 467 MOD_BEVEL_HARDEN_NORMALS = (1 << 15), 468 }; 469 470 /* BevelModifierData->val_flags (not used as flags any more) */ 471 enum { 472 MOD_BEVEL_AMT_OFFSET = 0, 473 MOD_BEVEL_AMT_WIDTH = 1, 474 MOD_BEVEL_AMT_DEPTH = 2, 475 MOD_BEVEL_AMT_PERCENT = 3, 476 MOD_BEVEL_AMT_ABSOLUTE = 4, 477 }; 478 479 /* BevelModifierData->profile_type */ 480 enum { 481 MOD_BEVEL_PROFILE_SUPERELLIPSE = 0, 482 MOD_BEVEL_PROFILE_CUSTOM = 1, 483 }; 484 485 /* BevelModifierData->edge_flags */ 486 enum { 487 MOD_BEVEL_MARK_SEAM = (1 << 0), 488 MOD_BEVEL_MARK_SHARP = (1 << 1), 489 }; 490 491 /* BevelModifierData->face_str_mode */ 492 enum { 493 MOD_BEVEL_FACE_STRENGTH_NONE = 0, 494 MOD_BEVEL_FACE_STRENGTH_NEW = 1, 495 MOD_BEVEL_FACE_STRENGTH_AFFECTED = 2, 496 MOD_BEVEL_FACE_STRENGTH_ALL = 3, 497 }; 498 499 /* BevelModifier->miter_inner and ->miter_outer */ 500 enum { 501 MOD_BEVEL_MITER_SHARP = 0, 502 MOD_BEVEL_MITER_PATCH = 1, 503 MOD_BEVEL_MITER_ARC = 2, 504 }; 505 506 /* BevelModifier->vmesh_method */ 507 enum { 508 MOD_BEVEL_VMESH_ADJ = 0, 509 MOD_BEVEL_VMESH_CUTOFF = 1, 510 }; 511 512 /* BevelModifier->affect_type */ 513 enum { 514 MOD_BEVEL_AFFECT_VERTICES = 0, 515 MOD_BEVEL_AFFECT_EDGES = 1, 516 }; 517 518 typedef struct FluidModifierData { 519 ModifierData modifier; 520 521 struct FluidDomainSettings *domain; 522 /** Inflow, outflow, smoke objects. */ 523 struct FluidFlowSettings *flow; 524 /** Effector objects (collision, guiding). */ 525 struct FluidEffectorSettings *effector; 526 float time; 527 /** Domain, inflow, outflow, .... */ 528 int type; 529 } FluidModifierData; 530 531 /* Fluid modifier flags */ 532 enum { 533 MOD_FLUID_TYPE_DOMAIN = (1 << 0), 534 MOD_FLUID_TYPE_FLOW = (1 << 1), 535 MOD_FLUID_TYPE_EFFEC = (1 << 2), 536 }; 537 538 typedef struct DisplaceModifierData { 539 ModifierData modifier; 540 541 /* keep in sync with MappingInfoModifierData */ 542 struct Tex *texture; 543 struct Object *map_object; 544 char map_bone[64]; 545 /** MAX_CUSTOMDATA_LAYER_NAME. */ 546 char uvlayer_name[64]; 547 int uvlayer_tmp; 548 int texmapping; 549 /* end MappingInfoModifierData */ 550 551 float strength; 552 int direction; 553 /** MAX_VGROUP_NAME. */ 554 char defgrp_name[64]; 555 float midlevel; 556 int space; 557 short flag; 558 char _pad[6]; 559 } DisplaceModifierData; 560 561 /* DisplaceModifierData->flag */ 562 enum { 563 MOD_DISP_INVERT_VGROUP = (1 << 0), 564 }; 565 566 /* DisplaceModifierData->direction */ 567 enum { 568 MOD_DISP_DIR_X = 0, 569 MOD_DISP_DIR_Y = 1, 570 MOD_DISP_DIR_Z = 2, 571 MOD_DISP_DIR_NOR = 3, 572 MOD_DISP_DIR_RGB_XYZ = 4, 573 MOD_DISP_DIR_CLNOR = 5, 574 }; 575 576 /* DisplaceModifierData->texmapping */ 577 enum { 578 MOD_DISP_MAP_LOCAL = 0, 579 MOD_DISP_MAP_GLOBAL = 1, 580 MOD_DISP_MAP_OBJECT = 2, 581 MOD_DISP_MAP_UV = 3, 582 }; 583 584 /* DisplaceModifierData->space */ 585 enum { 586 MOD_DISP_SPACE_LOCAL = 0, 587 MOD_DISP_SPACE_GLOBAL = 1, 588 }; 589 590 typedef struct UVProjectModifierData { 591 ModifierData modifier; 592 593 /* the objects which do the projecting */ 594 /** MOD_UVPROJECT_MAXPROJECTORS. */ 595 struct Object *projectors[10]; 596 char _pad2[4]; 597 int num_projectors; 598 float aspectx, aspecty; 599 float scalex, scaley; 600 /** MAX_CUSTOMDATA_LAYER_NAME. */ 601 char uvlayer_name[64]; 602 int uvlayer_tmp; 603 char _pad[4]; 604 } UVProjectModifierData; 605 606 #define MOD_UVPROJECT_MAXPROJECTORS 10 607 608 typedef struct DecimateModifierData { 609 ModifierData modifier; 610 611 /** (mode == MOD_DECIM_MODE_COLLAPSE). */ 612 float percent; 613 /** (mode == MOD_DECIM_MODE_UNSUBDIV). */ 614 short iter; 615 /** (mode == MOD_DECIM_MODE_DISSOLVE). */ 616 char delimit; 617 /** (mode == MOD_DECIM_MODE_COLLAPSE). */ 618 char symmetry_axis; 619 /** (mode == MOD_DECIM_MODE_DISSOLVE). */ 620 float angle; 621 622 /** MAX_VGROUP_NAME. */ 623 char defgrp_name[64]; 624 float defgrp_factor; 625 short flag, mode; 626 627 /* runtime only */ 628 int face_count; 629 } DecimateModifierData; 630 631 enum { 632 MOD_DECIM_FLAG_INVERT_VGROUP = (1 << 0), 633 /** for collapse only. dont convert tri pairs back to quads */ 634 MOD_DECIM_FLAG_TRIANGULATE = (1 << 1), 635 /** for dissolve only. collapse all verts between 2 faces */ 636 MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS = (1 << 2), 637 MOD_DECIM_FLAG_SYMMETRY = (1 << 3), 638 }; 639 640 enum { 641 MOD_DECIM_MODE_COLLAPSE = 0, 642 MOD_DECIM_MODE_UNSUBDIV = 1, 643 /** called planar in the UI */ 644 MOD_DECIM_MODE_DISSOLVE = 2, 645 }; 646 647 typedef struct SmoothModifierData { 648 ModifierData modifier; 649 float fac; 650 /** MAX_VGROUP_NAME. */ 651 char defgrp_name[64]; 652 short flag, repeat; 653 654 } SmoothModifierData; 655 656 /* Smooth modifier flags */ 657 enum { 658 MOD_SMOOTH_INVERT_VGROUP = (1 << 0), 659 MOD_SMOOTH_X = (1 << 1), 660 MOD_SMOOTH_Y = (1 << 2), 661 MOD_SMOOTH_Z = (1 << 3), 662 }; 663 664 typedef struct CastModifierData { 665 ModifierData modifier; 666 667 struct Object *object; 668 float fac; 669 float radius; 670 float size; 671 /** MAX_VGROUP_NAME. */ 672 char defgrp_name[64]; 673 short flag, type; 674 } CastModifierData; 675 676 /* Cast modifier flags */ 677 enum { 678 /* And what bout (1 << 0) flag? ;) */ 679 MOD_CAST_INVERT_VGROUP = (1 << 0), 680 MOD_CAST_X = (1 << 1), 681 MOD_CAST_Y = (1 << 2), 682 MOD_CAST_Z = (1 << 3), 683 MOD_CAST_USE_OB_TRANSFORM = (1 << 4), 684 MOD_CAST_SIZE_FROM_RADIUS = (1 << 5), 685 }; 686 687 /* Cast modifier projection types */ 688 enum { 689 MOD_CAST_TYPE_SPHERE = 0, 690 MOD_CAST_TYPE_CYLINDER = 1, 691 MOD_CAST_TYPE_CUBOID = 2, 692 }; 693 694 typedef struct WaveModifierData { 695 ModifierData modifier; 696 697 /* keep in sync with MappingInfoModifierData */ 698 struct Tex *texture; 699 struct Object *map_object; 700 char map_bone[64]; 701 /** MAX_CUSTOMDATA_LAYER_NAME. */ 702 char uvlayer_name[64]; 703 int uvlayer_tmp; 704 int texmapping; 705 /* end MappingInfoModifierData */ 706 707 struct Object *objectcenter; 708 /** MAX_VGROUP_NAME. */ 709 char defgrp_name[64]; 710 711 short flag; 712 char _pad[2]; 713 714 float startx, starty, height, width; 715 float narrow, speed, damp, falloff; 716 717 float timeoffs, lifetime; 718 char _pad1[4]; 719 } WaveModifierData; 720 721 /* WaveModifierData.flag */ 722 enum { 723 MOD_WAVE_INVERT_VGROUP = (1 << 0), 724 MOD_WAVE_X = (1 << 1), 725 MOD_WAVE_Y = (1 << 2), 726 MOD_WAVE_CYCL = (1 << 3), 727 MOD_WAVE_NORM = (1 << 4), 728 MOD_WAVE_NORM_X = (1 << 5), 729 MOD_WAVE_NORM_Y = (1 << 6), 730 MOD_WAVE_NORM_Z = (1 << 7), 731 }; 732 733 typedef struct ArmatureModifierData { 734 ModifierData modifier; 735 736 /** #eArmature_DeformFlag use instead of #bArmature.deformflag. */ 737 short deformflag, multi; 738 char _pad2[4]; 739 struct Object *object; 740 /** Stored input of previous modifier, for vertex-group blending. */ 741 float (*vert_coords_prev)[3]; 742 /** MAX_VGROUP_NAME. */ 743 char defgrp_name[64]; 744 } ArmatureModifierData; 745 746 enum { 747 MOD_HOOK_UNIFORM_SPACE = (1 << 0), 748 MOD_HOOK_INVERT_VGROUP = (1 << 1), 749 }; 750 751 /* same as WarpModifierFalloff */ 752 typedef enum { 753 eHook_Falloff_None = 0, 754 eHook_Falloff_Curve = 1, 755 eHook_Falloff_Sharp = 2, /* PROP_SHARP */ 756 eHook_Falloff_Smooth = 3, /* PROP_SMOOTH */ 757 eHook_Falloff_Root = 4, /* PROP_ROOT */ 758 eHook_Falloff_Linear = 5, /* PROP_LIN */ 759 eHook_Falloff_Const = 6, /* PROP_CONST */ 760 eHook_Falloff_Sphere = 7, /* PROP_SPHERE */ 761 eHook_Falloff_InvSquare = 8, /* PROP_INVSQUARE */ 762 /* PROP_RANDOM not used */ 763 } HookModifierFalloff; 764 765 typedef struct HookModifierData { 766 ModifierData modifier; 767 768 struct Object *object; 769 /** Optional name of bone target, MAX_ID_NAME-2. */ 770 char subtarget[64]; 771 772 char flag; 773 /** Use enums from WarpModifier (exact same functionality). */ 774 char falloff_type; 775 char _pad[6]; 776 /** Matrix making current transform unmodified. */ 777 float parentinv[4][4]; 778 /** Visualization of hook. */ 779 float cent[3]; 780 /** If not zero, falloff is distance where influence zero. */ 781 float falloff; 782 783 struct CurveMapping *curfalloff; 784 785 /** If NULL, it's using vertexgroup. */ 786 int *indexar; 787 int totindex; 788 float force; 789 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 790 char name[64]; 791 } HookModifierData; 792 793 typedef struct SoftbodyModifierData { 794 ModifierData modifier; 795 } SoftbodyModifierData; 796 797 typedef struct ClothModifierData { 798 ModifierData modifier; 799 800 /** The internal data structure for cloth. */ 801 struct Cloth *clothObject; 802 /** Definition is in DNA_cloth_types.h. */ 803 struct ClothSimSettings *sim_parms; 804 /** Definition is in DNA_cloth_types.h. */ 805 struct ClothCollSettings *coll_parms; 806 807 /* PointCache can be shared with other instances of ClothModifierData. 808 * Inspect (modifier.flag & eModifierFlag_SharedCaches) to find out. */ 809 /** Definition is in DNA_object_force_types.h. */ 810 struct PointCache *point_cache; 811 struct ListBase ptcaches; 812 813 /* XXX nasty hack, remove once hair can be separated from cloth modifier data */ 814 struct ClothHairData *hairdata; 815 /* grid geometry values of hair continuum */ 816 float hair_grid_min[3]; 817 float hair_grid_max[3]; 818 int hair_grid_res[3]; 819 float hair_grid_cellsize; 820 821 struct ClothSolverResult *solver_result; 822 } ClothModifierData; 823 824 typedef struct CollisionModifierData { 825 ModifierData modifier; 826 827 /** Position at the beginning of the frame. */ 828 struct MVert *x; 829 /** Position at the end of the frame. */ 830 struct MVert *xnew; 831 /** Unused atm, but was discussed during sprint. */ 832 struct MVert *xold; 833 /** New position at the actual inter-frame step. */ 834 struct MVert *current_xnew; 835 /** Position at the actual inter-frame step. */ 836 struct MVert *current_x; 837 /** (xnew - x) at the actual inter-frame step. */ 838 struct MVert *current_v; 839 840 struct MVertTri *tri; 841 842 unsigned int mvert_num; 843 unsigned int tri_num; 844 /** Cfra time of modifier. */ 845 float time_x, time_xnew; 846 /** Collider doesn't move this frame, i.e. x[].co==xnew[].co. */ 847 char is_static; 848 char _pad[7]; 849 850 /** Bounding volume hierarchy for this cloth object. */ 851 struct BVHTree *bvhtree; 852 } CollisionModifierData; 853 854 typedef struct SurfaceModifierData { 855 ModifierData modifier; 856 857 /** Old position. */ 858 struct MVert *x; 859 /** Velocity. */ 860 struct MVert *v; 861 862 struct Mesh *mesh; 863 864 /** Bounding volume hierarchy of the mesh faces. */ 865 struct BVHTreeFromMesh *bvhtree; 866 867 int cfra, numverts; 868 } SurfaceModifierData; 869 870 typedef struct BooleanModifierData { 871 ModifierData modifier; 872 873 struct Object *object; 874 struct Collection *collection; 875 float double_threshold; 876 char operation; 877 char solver; 878 char flag; 879 char bm_flag; 880 } BooleanModifierData; 881 882 /* BooleanModifierData->operation */ 883 typedef enum { 884 eBooleanModifierOp_Intersect = 0, 885 eBooleanModifierOp_Union = 1, 886 eBooleanModifierOp_Difference = 2, 887 } BooleanModifierOp; 888 889 /* BooleanModifierData->solver */ 890 typedef enum { 891 eBooleanModifierSolver_Fast = 0, 892 eBooleanModifierSolver_Exact = 1, 893 } BooleanModifierSolver; 894 895 /* BooleanModifierData->flag */ 896 enum { 897 eBooleanModifierFlag_Self = (1 << 0), 898 eBooleanModifierFlag_Object = (1 << 1), 899 eBooleanModifierFlag_Collection = (1 << 2), 900 }; 901 902 /* bm_flag only used when G_DEBUG. */ 903 enum { 904 eBooleanModifierBMeshFlag_BMesh_Separate = (1 << 0), 905 eBooleanModifierBMeshFlag_BMesh_NoDissolve = (1 << 1), 906 eBooleanModifierBMeshFlag_BMesh_NoConnectRegions = (1 << 2), 907 }; 908 909 typedef struct MDefInfluence { 910 int vertex; 911 float weight; 912 } MDefInfluence; 913 914 typedef struct MDefCell { 915 int offset; 916 int totinfluence; 917 } MDefCell; 918 919 typedef struct MeshDeformModifierData { 920 ModifierData modifier; 921 922 /** Mesh object. */ 923 struct Object *object; 924 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 925 char defgrp_name[64]; 926 927 short gridsize, flag; 928 char _pad[4]; 929 930 /* result of static binding */ 931 /** Influences. */ 932 MDefInfluence *bindinfluences; 933 /** Offsets into influences array. */ 934 int *bindoffsets; 935 /** Coordinates that cage was bound with. */ 936 float *bindcagecos; 937 /** Total vertices in mesh and cage. */ 938 int totvert, totcagevert; 939 940 /* result of dynamic binding */ 941 /** Grid with dynamic binding cell points. */ 942 MDefCell *dyngrid; 943 /** Dynamic binding vertex influences. */ 944 MDefInfluence *dyninfluences; 945 /** Is this vertex bound or not?. */ 946 int *dynverts; 947 /** Size of the dynamic bind grid. */ 948 int dyngridsize; 949 /** Total number of vertex influences. */ 950 int totinfluence; 951 /** Offset of the dynamic bind grid. */ 952 float dyncellmin[3]; 953 /** Width of dynamic bind cell. */ 954 float dyncellwidth; 955 /** Matrix of cage at binding time. */ 956 float bindmat[4][4]; 957 958 /* deprecated storage */ 959 /** Deprecated inefficient storage. */ 960 float *bindweights; 961 /** Deprecated storage of cage coords. */ 962 float *bindcos; 963 964 /* runtime */ 965 void (*bindfunc)(struct MeshDeformModifierData *mmd, 966 struct Mesh *cagemesh, 967 float *vertexcos, 968 int totvert, 969 float cagemat[4][4]); 970 } MeshDeformModifierData; 971 972 enum { 973 MOD_MDEF_INVERT_VGROUP = (1 << 0), 974 MOD_MDEF_DYNAMIC_BIND = (1 << 1), 975 }; 976 977 typedef struct ParticleSystemModifierData { 978 ModifierData modifier; 979 980 struct ParticleSystem *psys; 981 /** Final Mesh - its topology may differ from orig mesh. */ 982 struct Mesh *mesh_final; 983 /** Original mesh that particles are attached to. */ 984 struct Mesh *mesh_original; 985 int totdmvert, totdmedge, totdmface; 986 short flag; 987 char _pad[2]; 988 } ParticleSystemModifierData; 989 990 typedef enum { 991 eParticleSystemFlag_Pars = (1 << 0), 992 eParticleSystemFlag_psys_updated = (1 << 1), 993 eParticleSystemFlag_file_loaded = (1 << 2), 994 } ParticleSystemModifierFlag; 995 996 typedef enum { 997 eParticleInstanceFlag_Parents = (1 << 0), 998 eParticleInstanceFlag_Children = (1 << 1), 999 eParticleInstanceFlag_Path = (1 << 2), 1000 eParticleInstanceFlag_Unborn = (1 << 3), 1001 eParticleInstanceFlag_Alive = (1 << 4), 1002 eParticleInstanceFlag_Dead = (1 << 5), 1003 eParticleInstanceFlag_KeepShape = (1 << 6), 1004 eParticleInstanceFlag_UseSize = (1 << 7), 1005 } ParticleInstanceModifierFlag; 1006 1007 typedef enum { 1008 eParticleInstanceSpace_World = 0, 1009 eParticleInstanceSpace_Local = 1, 1010 } ParticleInstanceModifierSpace; 1011 1012 typedef struct ParticleInstanceModifierData { 1013 ModifierData modifier; 1014 1015 struct Object *ob; 1016 short psys, flag, axis, space; 1017 float position, random_position; 1018 float rotation, random_rotation; 1019 float particle_amount, particle_offset; 1020 /** MAX_CUSTOMDATA_LAYER_NAME. */ 1021 char index_layer_name[64]; 1022 /** MAX_CUSTOMDATA_LAYER_NAME. */ 1023 char value_layer_name[64]; 1024 } ParticleInstanceModifierData; 1025 1026 typedef enum { 1027 eExplodeFlag_CalcFaces = (1 << 0), 1028 eExplodeFlag_PaSize = (1 << 1), 1029 eExplodeFlag_EdgeCut = (1 << 2), 1030 eExplodeFlag_Unborn = (1 << 3), 1031 eExplodeFlag_Alive = (1 << 4), 1032 eExplodeFlag_Dead = (1 << 5), 1033 eExplodeFlag_INVERT_VGROUP = (1 << 6), 1034 } ExplodeModifierFlag; 1035 1036 typedef struct ExplodeModifierData { 1037 ModifierData modifier; 1038 1039 int *facepa; 1040 short flag, vgroup; 1041 float protect; 1042 /** MAX_CUSTOMDATA_LAYER_NAME. */ 1043 char uvname[64]; 1044 } ExplodeModifierData; 1045 1046 typedef struct MultiresModifierData { 1047 ModifierData modifier; 1048 1049 char lvl, sculptlvl, renderlvl, totlvl; 1050 char simple, flags, _pad[2]; 1051 short quality; 1052 short uv_smooth; 1053 short boundary_smooth; 1054 char _pad2[2]; 1055 } MultiresModifierData; 1056 1057 typedef enum { 1058 eMultiresModifierFlag_ControlEdges = (1 << 0), 1059 /* DEPRECATED, only used for versioning. */ 1060 eMultiresModifierFlag_PlainUv_DEPRECATED = (1 << 1), 1061 eMultiresModifierFlag_UseCrease = (1 << 2), 1062 eMultiresModifierFlag_UseCustomNormals = (1 << 3), 1063 eMultiresModifierFlag_UseSculptBaseMesh = (1 << 4), 1064 } MultiresModifierFlag; 1065 1066 /* DEPRECATED, only used for versioning. */ 1067 typedef struct FluidsimModifierData { 1068 ModifierData modifier; 1069 1070 /** Definition is in DNA_object_fluidsim_types.h. */ 1071 struct FluidsimSettings *fss; 1072 } FluidsimModifierData; 1073 1074 /* DEPRECATED, only used for versioning. */ 1075 typedef struct SmokeModifierData { 1076 ModifierData modifier; 1077 1078 /** Domain, inflow, outflow, .... */ 1079 int type; 1080 int _pad; 1081 } SmokeModifierData; 1082 1083 typedef struct ShrinkwrapModifierData { 1084 ModifierData modifier; 1085 1086 /** Shrink target. */ 1087 struct Object *target; 1088 /** Additional shrink target. */ 1089 struct Object *auxTarget; 1090 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 1091 char vgroup_name[64]; 1092 /** Distance offset to keep from mesh/projection point. */ 1093 float keepDist; 1094 /** Shrink type projection. */ 1095 short shrinkType; 1096 /** Shrink options. */ 1097 char shrinkOpts; 1098 /** Shrink to surface mode. */ 1099 char shrinkMode; 1100 /** Limit the projection ray cast. */ 1101 float projLimit; 1102 /** Axis to project over. */ 1103 char projAxis; 1104 1105 /** If using projection over vertex normal this controls the level of subsurface that must be 1106 * done before getting the vertex coordinates and normal 1107 */ 1108 char subsurfLevels; 1109 1110 char _pad[2]; 1111 } ShrinkwrapModifierData; 1112 1113 /* Shrinkwrap->shrinkType */ 1114 enum { 1115 MOD_SHRINKWRAP_NEAREST_SURFACE = 0, 1116 MOD_SHRINKWRAP_PROJECT = 1, 1117 MOD_SHRINKWRAP_NEAREST_VERTEX = 2, 1118 MOD_SHRINKWRAP_TARGET_PROJECT = 3, 1119 }; 1120 1121 /* Shrinkwrap->shrinkMode */ 1122 enum { 1123 /** Move vertex to the surface of the target object (keepDist towards original position) */ 1124 MOD_SHRINKWRAP_ON_SURFACE = 0, 1125 /** Move the vertex inside the target object; don't change if already inside */ 1126 MOD_SHRINKWRAP_INSIDE = 1, 1127 /** Move the vertex outside the target object; don't change if already outside */ 1128 MOD_SHRINKWRAP_OUTSIDE = 2, 1129 /** Move vertex to the surface of the target object, with keepDist towards the outside */ 1130 MOD_SHRINKWRAP_OUTSIDE_SURFACE = 3, 1131 /** Move vertex to the surface of the target object, with keepDist along the normal */ 1132 MOD_SHRINKWRAP_ABOVE_SURFACE = 4, 1133 }; 1134 1135 /* Shrinkwrap->shrinkOpts */ 1136 enum { 1137 /** allow shrinkwrap to move the vertex in the positive direction of axis */ 1138 MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR = (1 << 0), 1139 /** allow shrinkwrap to move the vertex in the negative direction of axis */ 1140 MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR = (1 << 1), 1141 1142 /** ignore vertex moves if a vertex ends projected on a front face of the target */ 1143 MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE = (1 << 3), 1144 /** ignore vertex moves if a vertex ends projected on a back face of the target */ 1145 MOD_SHRINKWRAP_CULL_TARGET_BACKFACE = (1 << 4), 1146 1147 #ifdef DNA_DEPRECATED_ALLOW 1148 /** distance is measure to the front face of the target */ 1149 MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE = (1 << 5), 1150 #endif 1151 1152 MOD_SHRINKWRAP_INVERT_VGROUP = (1 << 6), 1153 MOD_SHRINKWRAP_INVERT_CULL_TARGET = (1 << 7), 1154 }; 1155 1156 #define MOD_SHRINKWRAP_CULL_TARGET_MASK \ 1157 (MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE | MOD_SHRINKWRAP_CULL_TARGET_BACKFACE) 1158 1159 /* Shrinkwrap->projAxis */ 1160 enum { 1161 /** projection over normal is used if no axis is selected */ 1162 MOD_SHRINKWRAP_PROJECT_OVER_NORMAL = 0, 1163 MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS = (1 << 0), 1164 MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS = (1 << 1), 1165 MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS = (1 << 2), 1166 }; 1167 1168 typedef struct SimpleDeformModifierData { 1169 ModifierData modifier; 1170 1171 /** Object to control the origin of modifier space coordinates. */ 1172 struct Object *origin; 1173 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 1174 char vgroup_name[64]; 1175 /** Factors to control simple deforms. */ 1176 float factor; 1177 /** Lower and upper limit. */ 1178 float limit[2]; 1179 1180 /** Deform function. */ 1181 char mode; 1182 /** Lock axis (for taper and stretch). */ 1183 char axis; 1184 /** Axis to perform the deform on (default is X, but can be overridden by origin. */ 1185 char deform_axis; 1186 char flag; 1187 1188 } SimpleDeformModifierData; 1189 1190 /* SimpleDeform->flag */ 1191 enum { 1192 MOD_SIMPLEDEFORM_FLAG_INVERT_VGROUP = (1 << 0), 1193 }; 1194 1195 enum { 1196 MOD_SIMPLEDEFORM_MODE_TWIST = 1, 1197 MOD_SIMPLEDEFORM_MODE_BEND = 2, 1198 MOD_SIMPLEDEFORM_MODE_TAPER = 3, 1199 MOD_SIMPLEDEFORM_MODE_STRETCH = 4, 1200 }; 1201 1202 enum { 1203 MOD_SIMPLEDEFORM_LOCK_AXIS_X = (1 << 0), 1204 MOD_SIMPLEDEFORM_LOCK_AXIS_Y = (1 << 1), 1205 MOD_SIMPLEDEFORM_LOCK_AXIS_Z = (1 << 2), 1206 }; 1207 1208 typedef struct ShapeKeyModifierData { 1209 ModifierData modifier; 1210 } ShapeKeyModifierData; 1211 1212 typedef struct SolidifyModifierData { 1213 ModifierData modifier; 1214 1215 /** Name of vertex group to use, MAX_VGROUP_NAME. */ 1216 char defgrp_name[64]; 1217 char shell_defgrp_name[64]; 1218 char rim_defgrp_name[64]; 1219 /** New surface offset leve.l*/ 1220 float offset; 1221 /** Midpoint of the offset . */ 1222 float offset_fac; 1223 /** factor for the minimum weight to use when vgroups are used, 1224 * avoids 0.0 weights giving duplicate geometry */ 1225 float offset_fac_vg; 1226 /** Clamp offset based on surrounding geometry. */ 1227 float offset_clamp; 1228 char mode; 1229 1230 /** Variables for #MOD_SOLIDIFY_MODE_NONMANIFOLD. */ 1231 char nonmanifold_offset_mode; 1232 char nonmanifold_boundary_mode; 1233 1234 char _pad; 1235 float crease_inner; 1236 float crease_outer; 1237 float crease_rim; 1238 int flag; 1239 short mat_ofs; 1240 short mat_ofs_rim; 1241 1242 float merge_tolerance; 1243 float bevel_convex; 1244 } SolidifyModifierData; 1245 1246 /** #SolidifyModifierData.flag */ 1247 enum { 1248 MOD_SOLIDIFY_RIM = (1 << 0), 1249 MOD_SOLIDIFY_EVEN = (1 << 1), 1250 MOD_SOLIDIFY_NORMAL_CALC = (1 << 2), 1251 MOD_SOLIDIFY_VGROUP_INV = (1 << 3), 1252 #ifdef DNA_DEPRECATED_ALLOW 1253 MOD_SOLIDIFY_RIM_MATERIAL = (1 << 4), /* deprecated, used in do_versions */ 1254 #endif 1255 MOD_SOLIDIFY_FLIP = (1 << 5), 1256 MOD_SOLIDIFY_NOSHELL = (1 << 6), 1257 MOD_SOLIDIFY_OFFSET_ANGLE_CLAMP = (1 << 7), 1258 MOD_SOLIDIFY_NONMANIFOLD_FLAT_FACES = (1 << 8), 1259 }; 1260 1261 /** #SolidifyModifierData.mode */ 1262 enum { 1263 MOD_SOLIDIFY_MODE_EXTRUDE = 0, 1264 MOD_SOLIDIFY_MODE_NONMANIFOLD = 1, 1265 }; 1266 1267 /** #SolidifyModifierData.nonmanifold_offset_mode */ 1268 enum { 1269 MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_FIXED = 0, 1270 MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_EVEN = 1, 1271 MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_CONSTRAINTS = 2, 1272 }; 1273 1274 /** #SolidifyModifierData.nonmanifold_boundary_mode */ 1275 enum { 1276 MOD_SOLIDIFY_NONMANIFOLD_BOUNDARY_MODE_NONE = 0, 1277 MOD_SOLIDIFY_NONMANIFOLD_BOUNDARY_MODE_ROUND = 1, 1278 MOD_SOLIDIFY_NONMANIFOLD_BOUNDARY_MODE_FLAT = 2, 1279 }; 1280 1281 typedef struct ScrewModifierData { 1282 ModifierData modifier; 1283 1284 struct Object *ob_axis; 1285 unsigned int steps; 1286 unsigned int render_steps; 1287 unsigned int iter; 1288 float screw_ofs; 1289 float angle; 1290 float merge_dist; 1291 short flag; 1292 char axis; 1293 char _pad[5]; 1294 } ScrewModifierData; 1295 1296 enum { 1297 MOD_SCREW_NORMAL_FLIP = (1 << 0), 1298 MOD_SCREW_NORMAL_CALC = (1 << 1), 1299 MOD_SCREW_OBJECT_OFFSET = (1 << 2), 1300 /* MOD_SCREW_OBJECT_ANGLE = (1 << 4), */ 1301 MOD_SCREW_SMOOTH_SHADING = (1 << 5), 1302 MOD_SCREW_UV_STRETCH_U = (1 << 6), 1303 MOD_SCREW_UV_STRETCH_V = (1 << 7), 1304 MOD_SCREW_MERGE = (1 << 8), 1305 }; 1306 1307 typedef struct OceanModifierData { 1308 ModifierData modifier; 1309 1310 struct Ocean *ocean; 1311 struct OceanCache *oceancache; 1312 1313 /** Render resolution. */ 1314 int resolution; 1315 /** Viewport resolution for the non-render case. */ 1316 int viewport_resolution; 1317 1318 int spatial_size; 1319 1320 float wind_velocity; 1321 1322 float damp; 1323 float smallest_wave; 1324 float depth; 1325 1326 float wave_alignment; 1327 float wave_direction; 1328 float wave_scale; 1329 1330 float chop_amount; 1331 float foam_coverage; 1332 float time; 1333 1334 /* Spectrum being used. */ 1335 int spectrum; 1336 1337 /* Common JONSWAP parameters. */ 1338 /** 1339 * This is the distance from a lee shore, called the fetch, or the distance 1340 * over which the wind blows with constant velocity. 1341 */ 1342 float fetch_jonswap; 1343 float sharpen_peak_jonswap; 1344 1345 int bakestart; 1346 int bakeend; 1347 1348 /** FILE_MAX. */ 1349 char cachepath[1024]; 1350 /** MAX_CUSTOMDATA_LAYER_NAME. */ 1351 char foamlayername[64]; 1352 char spraylayername[64]; 1353 char cached; 1354 char geometry_mode; 1355 1356 char flag; 1357 char _pad2; 1358 1359 short repeat_x; 1360 short repeat_y; 1361 1362 int seed; 1363 1364 float size; 1365 1366 float foam_fade; 1367 1368 char _pad[4]; 1369 } OceanModifierData; 1370 1371 enum { 1372 MOD_OCEAN_GEOM_GENERATE = 0, 1373 MOD_OCEAN_GEOM_DISPLACE = 1, 1374 MOD_OCEAN_GEOM_SIM_ONLY = 2, 1375 }; 1376 1377 enum { 1378 MOD_OCEAN_SPECTRUM_PHILLIPS = 0, 1379 MOD_OCEAN_SPECTRUM_PIERSON_MOSKOWITZ = 1, 1380 MOD_OCEAN_SPECTRUM_JONSWAP = 2, 1381 MOD_OCEAN_SPECTRUM_TEXEL_MARSEN_ARSLOE = 3, 1382 }; 1383 1384 enum { 1385 MOD_OCEAN_GENERATE_FOAM = (1 << 0), 1386 MOD_OCEAN_GENERATE_NORMALS = (1 << 1), 1387 MOD_OCEAN_GENERATE_SPRAY = (1 << 2), 1388 MOD_OCEAN_INVERT_SPRAY = (1 << 3), 1389 }; 1390 1391 typedef struct WarpModifierData { 1392 ModifierData modifier; 1393 /* keep in sync with MappingInfoModifierData */ 1394 struct Tex *texture; 1395 struct Object *map_object; 1396 char map_bone[64]; 1397 /** MAX_CUSTOMDATA_LAYER_NAME. */ 1398 char uvlayer_name[64]; 1399 int uvlayer_tmp; 1400 int texmapping; 1401 /* end MappingInfoModifierData */ 1402 1403 struct Object *object_from; 1404 struct Object *object_to; 1405 /** Optional name of bone target, MAX_ID_NAME-2. */ 1406 char bone_from[64]; 1407 /** Optional name of bone target, MAX_ID_NAME-2. */ 1408 char bone_to[64]; 1409 1410 struct CurveMapping *curfalloff; 1411 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 1412 char defgrp_name[64]; 1413 float strength; 1414 float falloff_radius; 1415 char flag; 1416 char falloff_type; 1417 char _pad[6]; 1418 } WarpModifierData; 1419 1420 /* WarpModifierData->flag */ 1421 enum { 1422 MOD_WARP_VOLUME_PRESERVE = (1 << 0), 1423 MOD_WARP_INVERT_VGROUP = (1 << 1), 1424 }; 1425 1426 typedef enum { 1427 eWarp_Falloff_None = 0, 1428 eWarp_Falloff_Curve = 1, 1429 eWarp_Falloff_Sharp = 2, /* PROP_SHARP */ 1430 eWarp_Falloff_Smooth = 3, /* PROP_SMOOTH */ 1431 eWarp_Falloff_Root = 4, /* PROP_ROOT */ 1432 eWarp_Falloff_Linear = 5, /* PROP_LIN */ 1433 eWarp_Falloff_Const = 6, /* PROP_CONST */ 1434 eWarp_Falloff_Sphere = 7, /* PROP_SPHERE */ 1435 eWarp_Falloff_InvSquare = 8, /* PROP_INVSQUARE */ 1436 /* PROP_RANDOM not used */ 1437 } WarpModifierFalloff; 1438 1439 typedef struct WeightVGEditModifierData { 1440 ModifierData modifier; 1441 1442 /** Name of vertex group to edit. MAX_VGROUP_NAME. */ 1443 char defgrp_name[64]; 1444 1445 /** Using MOD_WVG_EDIT_* flags. */ 1446 short edit_flags; 1447 /** Using MOD_WVG_MAPPING_* defines. */ 1448 short falloff_type; 1449 /** Weight for vertices not in vgroup. */ 1450 float default_weight; 1451 1452 /* Mapping stuff. */ 1453 /** The custom mapping curve!. */ 1454 struct CurveMapping *cmap_curve; 1455 1456 /* The add/remove vertices weight thresholds. */ 1457 float add_threshold, rem_threshold; 1458 1459 /* Masking options. */ 1460 /** The global "influence", if no vgroup nor tex is used as mask. */ 1461 float mask_constant; 1462 /** Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME. */ 1463 char mask_defgrp_name[64]; 1464 1465 /* Texture masking. */ 1466 /** Which channel to use as weightf. */ 1467 int mask_tex_use_channel; 1468 /** The texture. */ 1469 struct Tex *mask_texture; 1470 /** Name of the map object. */ 1471 struct Object *mask_tex_map_obj; 1472 /** Name of the map bone. */ 1473 char mask_tex_map_bone[64]; 1474 /** How to map the texture (using MOD_DISP_MAP_* enums). */ 1475 int mask_tex_mapping; 1476 /** Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */ 1477 char mask_tex_uvlayer_name[64]; 1478 1479 /* Padding... */ 1480 char _pad0[4]; 1481 } WeightVGEditModifierData; 1482 1483 /* WeightVGEdit flags. */ 1484 enum { 1485 MOD_WVG_EDIT_WEIGHTS_NORMALIZE = (1 << 0), 1486 MOD_WVG_INVERT_FALLOFF = (1 << 1), 1487 MOD_WVG_EDIT_INVERT_VGROUP_MASK = (1 << 2), 1488 /** Add vertices with higher weight than threshold to vgroup. */ 1489 MOD_WVG_EDIT_ADD2VG = (1 << 3), 1490 /** Remove vertices with lower weight than threshold from vgroup. */ 1491 MOD_WVG_EDIT_REMFVG = (1 << 4), 1492 }; 1493 1494 typedef struct WeightVGMixModifierData { 1495 ModifierData modifier; 1496 1497 /** Name of vertex group to modify/weight. MAX_VGROUP_NAME. */ 1498 char defgrp_name_a[64]; 1499 /** Name of other vertex group to mix in. MAX_VGROUP_NAME. */ 1500 char defgrp_name_b[64]; 1501 /** Default weight value for first vgroup. */ 1502 float default_weight_a; 1503 /** Default weight value to mix in. */ 1504 float default_weight_b; 1505 /** How second vgroups weights affect first ones. */ 1506 char mix_mode; 1507 /** What vertices to affect. */ 1508 char mix_set; 1509 1510 char _pad0[6]; 1511 1512 /* Masking options. */ 1513 /** The global "influence", if no vgroup nor tex is used as mask. */ 1514 float mask_constant; 1515 /** Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME. */ 1516 char mask_defgrp_name[64]; 1517 1518 /* Texture masking. */ 1519 /** Which channel to use as weightf. */ 1520 int mask_tex_use_channel; 1521 /** The texture. */ 1522 struct Tex *mask_texture; 1523 /** Name of the map object. */ 1524 struct Object *mask_tex_map_obj; 1525 /** Name of the map bone. */ 1526 char mask_tex_map_bone[64]; 1527 /** How to map the texture!. */ 1528 int mask_tex_mapping; 1529 /** Name of the UV map. MAX_CUSTOMDATA_LAYER_NAME. */ 1530 char mask_tex_uvlayer_name[64]; 1531 1532 char flag; 1533 1534 /* Padding... */ 1535 char _pad1[3]; 1536 } WeightVGMixModifierData; 1537 1538 /* How second vgroup's weights affect first ones. */ 1539 enum { 1540 /** Second weights replace weights. */ 1541 MOD_WVG_MIX_SET = 1, 1542 /** Second weights are added to weights. */ 1543 MOD_WVG_MIX_ADD = 2, 1544 /** Second weights are subtracted from weights. */ 1545 MOD_WVG_MIX_SUB = 3, 1546 /** Second weights are multiplied with weights. */ 1547 MOD_WVG_MIX_MUL = 4, 1548 /** Second weights divide weights. */ 1549 MOD_WVG_MIX_DIV = 5, 1550 /** Difference between second weights and weights. */ 1551 MOD_WVG_MIX_DIF = 6, 1552 /** Average of both weights. */ 1553 MOD_WVG_MIX_AVG = 7, 1554 }; 1555 1556 /* What vertices to affect. */ 1557 enum { 1558 /** Affect all vertices. */ 1559 MOD_WVG_SET_ALL = 1, 1560 /** Affect only vertices in first vgroup. */ 1561 MOD_WVG_SET_A = 2, 1562 /** Affect only vertices in second vgroup. */ 1563 MOD_WVG_SET_B = 3, 1564 /** Affect only vertices in one vgroup or the other. */ 1565 MOD_WVG_SET_OR = 4, 1566 /** Affect only vertices in both vgroups. */ 1567 MOD_WVG_SET_AND = 5, 1568 }; 1569 1570 /* WeightVGMix->flag */ 1571 enum { 1572 MOD_WVG_MIX_INVERT_VGROUP_MASK = (1 << 0), 1573 MOD_WVG_MIX_WEIGHTS_NORMALIZE = (1 << 1), 1574 MOD_WVG_MIX_INVERT_VGROUP_A = (1 << 2), 1575 MOD_WVG_MIX_INVERT_VGROUP_B = (1 << 3), 1576 }; 1577 1578 typedef struct WeightVGProximityModifierData { 1579 ModifierData modifier; 1580 1581 /** Name of vertex group to modify/weight. MAX_VGROUP_NAME. */ 1582 char defgrp_name[64]; 1583 1584 /* Proximity modes. */ 1585 int proximity_mode; 1586 int proximity_flags; 1587 1588 /* Target object from which to calculate vertices distances. */ 1589 struct Object *proximity_ob_target; 1590 1591 /* Masking options. */ 1592 /** The global "influence", if no vgroup nor tex is used as mask. */ 1593 float mask_constant; 1594 /** Name of mask vertex group from which to get weight factors. MAX_VGROUP_NAME. */ 1595 char mask_defgrp_name[64]; 1596 1597 /* Texture masking. */ 1598 /** Which channel to use as weightf. */ 1599 int mask_tex_use_channel; 1600 /** The texture. */ 1601 struct Tex *mask_texture; 1602 /** Name of the map object. */ 1603 struct Object *mask_tex_map_obj; 1604 /** Name of the map bone. */ 1605 char mask_tex_map_bone[64]; 1606 /** How to map the texture!. */ 1607 int mask_tex_mapping; 1608 /** Name of the UV Map. MAX_CUSTOMDATA_LAYER_NAME. */ 1609 char mask_tex_uvlayer_name[64]; 1610 1611 /** Distances mapping to 0.0/1.0 weights. */ 1612 float min_dist, max_dist; 1613 1614 /* Put here to avoid breaking existing struct... */ 1615 /** Using MOD_WVG_MAPPING_* enums. */ 1616 short falloff_type; 1617 1618 /* Padding... */ 1619 char _pad0[2]; 1620 } WeightVGProximityModifierData; 1621 1622 /* Modes of proximity weighting. */ 1623 enum { 1624 MOD_WVG_PROXIMITY_OBJECT = 1, /* source vertex to other location */ 1625 MOD_WVG_PROXIMITY_GEOMETRY = 2, /* source vertex to other geometry */ 1626 }; 1627 1628 /* Flags options for proximity weighting. */ 1629 enum { 1630 /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */ 1631 MOD_WVG_PROXIMITY_GEOM_VERTS = (1 << 0), 1632 /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */ 1633 MOD_WVG_PROXIMITY_GEOM_EDGES = (1 << 1), 1634 /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */ 1635 MOD_WVG_PROXIMITY_GEOM_FACES = (1 << 2), 1636 MOD_WVG_PROXIMITY_INVERT_VGROUP_MASK = (1 << 3), 1637 MOD_WVG_PROXIMITY_INVERT_FALLOFF = (1 << 4), 1638 MOD_WVG_PROXIMITY_WEIGHTS_NORMALIZE = (1 << 3), 1639 }; 1640 1641 /* Defines common to all WeightVG modifiers. */ 1642 /* Mapping modes. */ 1643 enum { 1644 MOD_WVG_MAPPING_NONE = 0, 1645 MOD_WVG_MAPPING_CURVE = 1, 1646 MOD_WVG_MAPPING_SHARP = 2, /* PROP_SHARP */ 1647 MOD_WVG_MAPPING_SMOOTH = 3, /* PROP_SMOOTH */ 1648 MOD_WVG_MAPPING_ROOT = 4, /* PROP_ROOT */ 1649 /* PROP_LIN not used (same as NONE, here...). */ 1650 /* PROP_CONST not used. */ 1651 MOD_WVG_MAPPING_SPHERE = 7, /* PROP_SPHERE */ 1652 MOD_WVG_MAPPING_RANDOM = 8, /* PROP_RANDOM */ 1653 MOD_WVG_MAPPING_STEP = 9, /* Median Step. */ 1654 }; 1655 1656 /* Tex channel to be used as mask. */ 1657 enum { 1658 MOD_WVG_MASK_TEX_USE_INT = 1, 1659 MOD_WVG_MASK_TEX_USE_RED = 2, 1660 MOD_WVG_MASK_TEX_USE_GREEN = 3, 1661 MOD_WVG_MASK_TEX_USE_BLUE = 4, 1662 MOD_WVG_MASK_TEX_USE_HUE = 5, 1663 MOD_WVG_MASK_TEX_USE_SAT = 6, 1664 MOD_WVG_MASK_TEX_USE_VAL = 7, 1665 MOD_WVG_MASK_TEX_USE_ALPHA = 8, 1666 }; 1667 1668 typedef struct DynamicPaintModifierData { 1669 ModifierData modifier; 1670 1671 struct DynamicPaintCanvasSettings *canvas; 1672 struct DynamicPaintBrushSettings *brush; 1673 /** UI display: canvas / brush. */ 1674 int type; 1675 char _pad[4]; 1676 } DynamicPaintModifierData; 1677 1678 /* Dynamic paint modifier flags */ 1679 enum { 1680 MOD_DYNAMICPAINT_TYPE_CANVAS = (1 << 0), 1681 MOD_DYNAMICPAINT_TYPE_BRUSH = (1 << 1), 1682 }; 1683 1684 /* Remesh modifier */ 1685 typedef enum eRemeshModifierFlags { 1686 MOD_REMESH_FLOOD_FILL = (1 << 0), 1687 MOD_REMESH_SMOOTH_SHADING = (1 << 1), 1688 } RemeshModifierFlags; 1689 1690 typedef enum eRemeshModifierMode { 1691 /* blocky */ 1692 MOD_REMESH_CENTROID = 0, 1693 /* smooth */ 1694 MOD_REMESH_MASS_POINT = 1, 1695 /* keeps sharp edges */ 1696 MOD_REMESH_SHARP_FEATURES = 2, 1697 /* Voxel remesh */ 1698 MOD_REMESH_VOXEL = 3, 1699 } eRemeshModifierMode; 1700 1701 typedef struct RemeshModifierData { 1702 ModifierData modifier; 1703 1704 /* floodfill option, controls how small components can be before they are removed */ 1705 float threshold; 1706 1707 /* ratio between size of model and grid */ 1708 float scale; 1709 1710 float hermite_num; 1711 1712 /* octree depth */ 1713 char depth; 1714 char flag; 1715 char mode; 1716 char _pad; 1717 1718 /* OpenVDB Voxel remesh properties. */ 1719 float voxel_size; 1720 float adaptivity; 1721 } RemeshModifierData; 1722 1723 /* Skin modifier */ 1724 typedef struct SkinModifierData { 1725 ModifierData modifier; 1726 1727 float branch_smoothing; 1728 1729 char flag; 1730 1731 char symmetry_axes; 1732 1733 char _pad[2]; 1734 } SkinModifierData; 1735 1736 /* SkinModifierData.symmetry_axes */ 1737 enum { 1738 MOD_SKIN_SYMM_X = (1 << 0), 1739 MOD_SKIN_SYMM_Y = (1 << 1), 1740 MOD_SKIN_SYMM_Z = (1 << 2), 1741 }; 1742 1743 /* SkinModifierData.flag */ 1744 enum { 1745 MOD_SKIN_SMOOTH_SHADING = 1, 1746 }; 1747 1748 /* Triangulate modifier */ 1749 typedef struct TriangulateModifierData { 1750 ModifierData modifier; 1751 1752 int flag; 1753 int quad_method; 1754 int ngon_method; 1755 int min_vertices; 1756 } TriangulateModifierData; 1757 1758 /* TriangulateModifierData.flag */ 1759 enum { 1760 #ifdef DNA_DEPRECATED_ALLOW 1761 MOD_TRIANGULATE_BEAUTY = (1 << 0), /* deprecated */ 1762 #endif 1763 MOD_TRIANGULATE_KEEP_CUSTOMLOOP_NORMALS = 1 << 1, 1764 }; 1765 1766 /* Triangulate methods - NGons */ 1767 enum { 1768 MOD_TRIANGULATE_NGON_BEAUTY = 0, 1769 MOD_TRIANGULATE_NGON_EARCLIP = 1, 1770 }; 1771 1772 /* Triangulate methods - Quads */ 1773 enum { 1774 MOD_TRIANGULATE_QUAD_BEAUTY = 0, 1775 MOD_TRIANGULATE_QUAD_FIXED = 1, 1776 MOD_TRIANGULATE_QUAD_ALTERNATE = 2, 1777 MOD_TRIANGULATE_QUAD_SHORTEDGE = 3, 1778 }; 1779 1780 typedef struct LaplacianSmoothModifierData { 1781 ModifierData modifier; 1782 1783 float lambda, lambda_border; 1784 char _pad1[4]; 1785 /** MAX_VGROUP_NAME. */ 1786 char defgrp_name[64]; 1787 short flag, repeat; 1788 } LaplacianSmoothModifierData; 1789 1790 /* Smooth modifier flags */ 1791 enum { 1792 MOD_LAPLACIANSMOOTH_X = (1 << 1), 1793 MOD_LAPLACIANSMOOTH_Y = (1 << 2), 1794 MOD_LAPLACIANSMOOTH_Z = (1 << 3), 1795 MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME = (1 << 4), 1796 MOD_LAPLACIANSMOOTH_NORMALIZED = (1 << 5), 1797 MOD_LAPLACIANSMOOTH_INVERT_VGROUP = (1 << 6), 1798 }; 1799 1800 typedef struct CorrectiveSmoothDeltaCache { 1801 /* delta's between the original positions and the smoothed positions */ 1802 float (*deltas)[3]; 1803 unsigned int totverts; 1804 1805 /* Value of settings when creating the cache. 1806 * These are used to check if the cache should be recomputed. */ 1807 float lambda, scale; 1808 short repeat, flag; 1809 char smooth_type, rest_source; 1810 char _pad[6]; 1811 } CorrectiveSmoothDeltaCache; 1812 1813 typedef struct CorrectiveSmoothModifierData { 1814 ModifierData modifier; 1815 1816 /* positions set during 'bind' operator 1817 * use for MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND */ 1818 float (*bind_coords)[3]; 1819 1820 /* note: -1 is used to bind */ 1821 unsigned int bind_coords_num; 1822 1823 float lambda, scale; 1824 short repeat, flag; 1825 char smooth_type, rest_source; 1826 char _pad[6]; 1827 1828 /** MAX_VGROUP_NAME. */ 1829 char defgrp_name[64]; 1830 1831 /* runtime-only cache */ 1832 CorrectiveSmoothDeltaCache delta_cache; 1833 } CorrectiveSmoothModifierData; 1834 1835 enum { 1836 MOD_CORRECTIVESMOOTH_SMOOTH_SIMPLE = 0, 1837 MOD_CORRECTIVESMOOTH_SMOOTH_LENGTH_WEIGHT = 1, 1838 }; 1839 1840 enum { 1841 MOD_CORRECTIVESMOOTH_RESTSOURCE_ORCO = 0, 1842 MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND = 1, 1843 }; 1844 1845 /* Corrective Smooth modifier flags */ 1846 enum { 1847 MOD_CORRECTIVESMOOTH_INVERT_VGROUP = (1 << 0), 1848 MOD_CORRECTIVESMOOTH_ONLY_SMOOTH = (1 << 1), 1849 MOD_CORRECTIVESMOOTH_PIN_BOUNDARY = (1 << 2), 1850 }; 1851 1852 typedef struct UVWarpModifierData { 1853 ModifierData modifier; 1854 1855 char axis_u, axis_v; 1856 short flag; 1857 /** Used for rotate/scale. */ 1858 float center[2]; 1859 1860 float offset[2]; 1861 float scale[2]; 1862 float rotation; 1863 1864 /** Source. */ 1865 struct Object *object_src; 1866 /** Optional name of bone target, MAX_ID_NAME-2. */ 1867 char bone_src[64]; 1868 /** Target. */ 1869 struct Object *object_dst; 1870 /** Optional name of bone target, MAX_ID_NAME-2. */ 1871 char bone_dst[64]; 1872 1873 /** Optional vertexgroup name, MAX_VGROUP_NAME. */ 1874 char vgroup_name[64]; 1875 /** MAX_CUSTOMDATA_LAYER_NAME. */ 1876 char uvlayer_name[64]; 1877 } UVWarpModifierData; 1878 1879 /* UVWarp modifier flags */ 1880 enum { 1881 MOD_UVWARP_INVERT_VGROUP = 1 << 0, 1882 }; 1883 1884 /* cache modifier */ 1885 typedef struct MeshCacheModifierData { 1886 ModifierData modifier; 1887 1888 char flag; 1889 /** File format. */ 1890 char type; 1891 char time_mode; 1892 char play_mode; 1893 1894 /* axis conversion */ 1895 char forward_axis; 1896 char up_axis; 1897 char flip_axis; 1898 1899 char interp; 1900 1901 float factor; 1902 char deform_mode; 1903 char _pad[7]; 1904 1905 /* play_mode == MOD_MESHCACHE_PLAY_CFEA */ 1906 float frame_start; 1907 float frame_scale; 1908 1909 /* play_mode == MOD_MESHCACHE_PLAY_EVAL */ 1910 /* we could use one float for all these but their purpose is very different */ 1911 float eval_frame; 1912 float eval_time; 1913 float eval_factor; 1914 1915 /** FILE_MAX. */ 1916 char filepath[1024]; 1917 } MeshCacheModifierData; 1918 1919 enum { 1920 MOD_MESHCACHE_TYPE_MDD = 1, 1921 MOD_MESHCACHE_TYPE_PC2 = 2, 1922 }; 1923 1924 enum { 1925 MOD_MESHCACHE_DEFORM_OVERWRITE = 0, 1926 MOD_MESHCACHE_DEFORM_INTEGRATE = 1, 1927 }; 1928 1929 enum { 1930 MOD_MESHCACHE_INTERP_NONE = 0, 1931 MOD_MESHCACHE_INTERP_LINEAR = 1, 1932 /* MOD_MESHCACHE_INTERP_CARDINAL = 2, */ 1933 }; 1934 1935 enum { 1936 MOD_MESHCACHE_TIME_FRAME = 0, 1937 MOD_MESHCACHE_TIME_SECONDS = 1, 1938 MOD_MESHCACHE_TIME_FACTOR = 2, 1939 }; 1940 1941 enum { 1942 MOD_MESHCACHE_PLAY_CFEA = 0, 1943 MOD_MESHCACHE_PLAY_EVAL = 1, 1944 }; 1945 1946 typedef struct LaplacianDeformModifierData { 1947 ModifierData modifier; 1948 /** MAX_VGROUP_NAME. */ 1949 char anchor_grp_name[64]; 1950 int total_verts, repeat; 1951 float *vertexco; 1952 /** Runtime only. */ 1953 void *cache_system; 1954 short flag; 1955 char _pad[6]; 1956 1957 } LaplacianDeformModifierData; 1958 1959 /* Laplacian Deform modifier flags */ 1960 enum { 1961 MOD_LAPLACIANDEFORM_BIND = 1 << 0, 1962 MOD_LAPLACIANDEFORM_INVERT_VGROUP = 1 << 1, 1963 }; 1964 1965 /* many of these options match 'solidify' */ 1966 typedef struct WireframeModifierData { 1967 ModifierData modifier; 1968 /** MAX_VGROUP_NAME. */ 1969 char defgrp_name[64]; 1970 float offset; 1971 float offset_fac; 1972 float offset_fac_vg; 1973 float crease_weight; 1974 short flag, mat_ofs; 1975 char _pad[4]; 1976 } WireframeModifierData; 1977 1978 enum { 1979 MOD_WIREFRAME_INVERT_VGROUP = (1 << 0), 1980 MOD_WIREFRAME_REPLACE = (1 << 1), 1981 MOD_WIREFRAME_BOUNDARY = (1 << 2), 1982 MOD_WIREFRAME_OFS_EVEN = (1 << 3), 1983 MOD_WIREFRAME_OFS_RELATIVE = (1 << 4), 1984 MOD_WIREFRAME_CREASE = (1 << 5), 1985 }; 1986 1987 typedef struct WeldModifierData { 1988 ModifierData modifier; 1989 1990 /* The limit below which to merge vertices. */ 1991 float merge_dist; 1992 /* Name of vertex group to use to mask, MAX_VGROUP_NAME. */ 1993 char defgrp_name[64]; 1994 1995 short flag; 1996 char _pad[2]; 1997 } WeldModifierData; 1998 1999 /* WeldModifierData->flag */ 2000 enum { 2001 MOD_WELD_INVERT_VGROUP = (1 << 0), 2002 }; 2003 2004 typedef struct DataTransferModifierData { 2005 ModifierData modifier; 2006 2007 struct Object *ob_source; 2008 2009 /** See DT_TYPE_ enum in ED_object.h. */ 2010 int data_types; 2011 2012 /* See MREMAP_MODE_ enum in BKE_mesh_mapping.h */ 2013 int vmap_mode; 2014 int emap_mode; 2015 int lmap_mode; 2016 int pmap_mode; 2017 2018 float map_max_distance; 2019 float map_ray_radius; 2020 float islands_precision; 2021 2022 char _pad1[4]; 2023 2024 /** DT_MULTILAYER_INDEX_MAX; See DT_FROMLAYERS_ enum in ED_object.h. */ 2025 int layers_select_src[4]; 2026 /** DT_MULTILAYER_INDEX_MAX; See DT_TOLAYERS_ enum in ED_object.h. */ 2027 int layers_select_dst[4]; 2028 2029 /** See CDT_MIX_ enum in BKE_customdata.h. */ 2030 int mix_mode; 2031 float mix_factor; 2032 /** MAX_VGROUP_NAME. */ 2033 char defgrp_name[64]; 2034 2035 int flags; 2036 } DataTransferModifierData; 2037 2038 /* DataTransferModifierData.flags */ 2039 enum { 2040 MOD_DATATRANSFER_OBSRC_TRANSFORM = 1 << 0, 2041 MOD_DATATRANSFER_MAP_MAXDIST = 1 << 1, 2042 MOD_DATATRANSFER_INVERT_VGROUP = 1 << 2, 2043 2044 /* Only for UI really. */ 2045 MOD_DATATRANSFER_USE_VERT = 1 << 28, 2046 MOD_DATATRANSFER_USE_EDGE = 1 << 29, 2047 MOD_DATATRANSFER_USE_LOOP = 1 << 30, 2048 MOD_DATATRANSFER_USE_POLY = 1u << 31, 2049 }; 2050 2051 /* Set Split Normals modifier */ 2052 typedef struct NormalEditModifierData { 2053 ModifierData modifier; 2054 /** MAX_VGROUP_NAME. */ 2055 char defgrp_name[64]; 2056 /** Source of normals, or center of ellipsoid. */ 2057 struct Object *target; 2058 short mode; 2059 short flag; 2060 short mix_mode; 2061 char _pad[2]; 2062 float mix_factor; 2063 float mix_limit; 2064 float offset[3]; 2065 char _pad0[4]; 2066 } NormalEditModifierData; 2067 2068 /* NormalEditModifierData.mode */ 2069 enum { 2070 MOD_NORMALEDIT_MODE_RADIAL = 0, 2071 MOD_NORMALEDIT_MODE_DIRECTIONAL = 1, 2072 }; 2073 2074 /* NormalEditModifierData.flags */ 2075 enum { 2076 MOD_NORMALEDIT_INVERT_VGROUP = (1 << 0), 2077 MOD_NORMALEDIT_USE_DIRECTION_PARALLEL = (1 << 1), 2078 MOD_NORMALEDIT_NO_POLYNORS_FIX = (1 << 2), 2079 }; 2080 2081 /* NormalEditModifierData.mix_mode */ 2082 enum { 2083 MOD_NORMALEDIT_MIX_COPY = 0, 2084 MOD_NORMALEDIT_MIX_ADD = 1, 2085 MOD_NORMALEDIT_MIX_SUB = 2, 2086 MOD_NORMALEDIT_MIX_MUL = 3, 2087 }; 2088 2089 typedef struct MeshCacheVertexVelocity { 2090 float vel[3]; 2091 } MeshCacheVertexVelocity; 2092 2093 typedef struct MeshSeqCacheModifierData { 2094 ModifierData modifier; 2095 2096 struct CacheFile *cache_file; 2097 /** 1024 = FILE_MAX. */ 2098 char object_path[1024]; 2099 2100 char read_flag; 2101 char _pad[3]; 2102 2103 float velocity_scale; 2104 2105 /* Runtime. */ 2106 struct CacheReader *reader; 2107 char reader_object_path[1024]; 2108 2109 /* Vertex velocities read from the cache. The velocities are not automatically read during 2110 * modifier execution, and therefore have to manually be read when needed. This is only used 2111 * through the RNA for now. */ 2112 struct MeshCacheVertexVelocity *vertex_velocities; 2113 2114 /* The number of vertices of the Alembic mesh, set when the modifier is executed. */ 2115 int num_vertices; 2116 2117 /* Time (in frames or seconds) between two velocity samples. Automatically computed to 2118 * scale the velocity vectors at render time for generating proper motion blur data. */ 2119 float velocity_delta; 2120 2121 /* Caches the scene time (in seconds) used to lookup data in the Alembic archive when the 2122 * modifier was last executed. Used to access Alembic samples through the RNA. */ 2123 float last_lookup_time; 2124 2125 int _pad1; 2126 } MeshSeqCacheModifierData; 2127 2128 /* MeshSeqCacheModifierData.read_flag */ 2129 enum { 2130 MOD_MESHSEQ_READ_VERT = (1 << 0), 2131 MOD_MESHSEQ_READ_POLY = (1 << 1), 2132 MOD_MESHSEQ_READ_UV = (1 << 2), 2133 MOD_MESHSEQ_READ_COLOR = (1 << 3), 2134 2135 /* Allow interpolation of mesh vertex positions. There is a heuristic to avoid interpolation when 2136 * the mesh topology changes, but this heuristic sometimes fails. In these cases, users can 2137 * disable interpolation with this flag. */ 2138 MOD_MESHSEQ_INTERPOLATE_VERTICES = (1 << 4), 2139 }; 2140 2141 typedef struct SDefBind { 2142 unsigned int *vert_inds; 2143 unsigned int numverts; 2144 int mode; 2145 float *vert_weights; 2146 float normal_dist; 2147 float influence; 2148 } SDefBind; 2149 2150 typedef struct SDefVert { 2151 SDefBind *binds; 2152 unsigned int numbinds; 2153 char _pad[4]; 2154 } SDefVert; 2155 2156 typedef struct SurfaceDeformModifierData { 2157 ModifierData modifier; 2158 2159 struct Depsgraph *depsgraph; 2160 /** Bind target object. */ 2161 struct Object *target; 2162 /** Vertex bind data. */ 2163 SDefVert *verts; 2164 float falloff; 2165 unsigned int numverts, numpoly; 2166 int flags; 2167 float mat[4][4]; 2168 float strength; 2169 char _pad[4]; 2170 char defgrp_name[64]; 2171 } SurfaceDeformModifierData; 2172 2173 /* Surface Deform modifier flags */ 2174 enum { 2175 /* This indicates "do bind on next modifier evaluation" as well as "is bound". */ 2176 MOD_SDEF_BIND = (1 << 0), 2177 MOD_SDEF_INVERT_VGROUP = (1 << 1) 2178 2179 /* MOD_SDEF_USES_LOOPTRI = (1 << 1), */ /* UNUSED */ 2180 /* MOD_SDEF_HAS_CONCAVE = (1 << 2), */ /* UNUSED */ 2181 }; 2182 2183 /* Surface Deform vertex bind modes */ 2184 enum { 2185 MOD_SDEF_MODE_LOOPTRI = 0, 2186 MOD_SDEF_MODE_NGON = 1, 2187 MOD_SDEF_MODE_CENTROID = 2, 2188 }; 2189 2190 typedef struct WeightedNormalModifierData { 2191 ModifierData modifier; 2192 2193 /** MAX_VGROUP_NAME. */ 2194 char defgrp_name[64]; 2195 char mode, flag; 2196 short weight; 2197 float thresh; 2198 } WeightedNormalModifierData; 2199 2200 /* Name/id of the generic PROP_INT cdlayer storing face weights. */ 2201 #define MOD_WEIGHTEDNORMALS_FACEWEIGHT_CDLAYER_ID "__mod_weightednormals_faceweight" 2202 2203 /* WeightedNormalModifierData.mode */ 2204 enum { 2205 MOD_WEIGHTEDNORMAL_MODE_FACE = 0, 2206 MOD_WEIGHTEDNORMAL_MODE_ANGLE = 1, 2207 MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE = 2, 2208 }; 2209 2210 /* WeightedNormalModifierData.flag */ 2211 enum { 2212 MOD_WEIGHTEDNORMAL_KEEP_SHARP = (1 << 0), 2213 MOD_WEIGHTEDNORMAL_INVERT_VGROUP = (1 << 1), 2214 MOD_WEIGHTEDNORMAL_FACE_INFLUENCE = (1 << 2), 2215 }; 2216 2217 #define MOD_MESHSEQ_READ_ALL \ 2218 (MOD_MESHSEQ_READ_VERT | MOD_MESHSEQ_READ_POLY | MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR) 2219 2220 typedef struct SimulationModifierData { 2221 ModifierData modifier; 2222 } SimulationModifierData; 2223 2224 typedef struct MeshToVolumeModifierData { 2225 ModifierData modifier; 2226 2227 /** This is the object that is supposed to be converted to a volume. */ 2228 struct Object *object; 2229 2230 /** MeshToVolumeModifierResolutionMode */ 2231 int resolution_mode; 2232 /** Size of a voxel in object space. */ 2233 float voxel_size; 2234 /** The desired amount of voxels along one axis. The actual amount of voxels might be slightly 2235 * different. */ 2236 int voxel_amount; 2237 2238 /** If true, every cell in the enclosed volume gets a density. Otherwise, the interior_band_width 2239 * is used. */ 2240 char fill_volume; 2241 char _pad1[3]; 2242 2243 /** Band widths are in object space. */ 2244 float interior_band_width; 2245 float exterior_band_width; 2246 2247 float density; 2248 char _pad2[4]; 2249 } MeshToVolumeModifierData; 2250 2251 /* MeshToVolumeModifierData->resolution_mode */ 2252 typedef enum MeshToVolumeModifierResolutionMode { 2253 MESH_TO_VOLUME_RESOLUTION_MODE_VOXEL_AMOUNT = 0, 2254 MESH_TO_VOLUME_RESOLUTION_MODE_VOXEL_SIZE = 1, 2255 } MeshToVolumeModifierResolutionMode; 2256 2257 typedef struct VolumeDisplaceModifierData { 2258 ModifierData modifier; 2259 2260 struct Tex *texture; 2261 struct Object *texture_map_object; 2262 int texture_map_mode; 2263 2264 float strength; 2265 float texture_mid_level[3]; 2266 float texture_sample_radius; 2267 } VolumeDisplaceModifierData; 2268 2269 /* VolumeDisplaceModifierData->texture_map_mode */ 2270 enum { 2271 MOD_VOLUME_DISPLACE_MAP_LOCAL = 0, 2272 MOD_VOLUME_DISPLACE_MAP_GLOBAL = 1, 2273 MOD_VOLUME_DISPLACE_MAP_OBJECT = 2, 2274 }; 2275 2276 typedef struct VolumeToMeshModifierData { 2277 ModifierData modifier; 2278 2279 /** This is the volume object that is supposed to be converted to a mesh. */ 2280 struct Object *object; 2281 2282 float threshold; 2283 float adaptivity; 2284 2285 /** VolumeToMeshFlag */ 2286 uint32_t flag; 2287 2288 /** VolumeToMeshResolutionMode */ 2289 int resolution_mode; 2290 float voxel_size; 2291 int voxel_amount; 2292 2293 /** MAX_NAME */ 2294 char grid_name[64]; 2295 } VolumeToMeshModifierData; 2296 2297 /** VolumeToMeshModifierData->resolution_mode */ 2298 typedef enum VolumeToMeshResolutionMode { 2299 VOLUME_TO_MESH_RESOLUTION_MODE_GRID = 0, 2300 VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_AMOUNT = 1, 2301 VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_SIZE = 2, 2302 } VolumeToMeshResolutionMode; 2303 2304 /** VolumeToMeshModifierData->flag */ 2305 typedef enum VolumeToMeshFlag { 2306 VOLUME_TO_MESH_USE_SMOOTH_SHADE = 1 << 0, 2307 } VolumeToMeshFlag; 2308 2309 #ifdef __cplusplus 2310 } 2311 #endif 2312