DNA_modifier_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_utildefines.h"
 
#include "DNA_defs.h"
#include "DNA_listBase.h"
#include "DNA_packedFile_types.h"
#include "DNA_session_uid_types.h"
 
#ifdef __cplusplus
#  include "BLI_span.hh"
 
namespace blender {
struct NodesModifierRuntime;
}
using NodesModifierRuntimeHandle = blender::NodesModifierRuntime;
#else
typedef struct NodesModifierRuntimeHandle NodesModifierRuntimeHandle;
#endif
 
/* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE!
 * (ONLY ADD NEW ITEMS AT THE END)
 */
 
struct Mesh;
 
typedef enum ModifierType {
  eModifierType_None = 0,
  eModifierType_Subsurf = 1,
  eModifierType_Lattice = 2,
  eModifierType_Curve = 3,
  eModifierType_Build = 4,
  eModifierType_Mirror = 5,
  eModifierType_Decimate = 6,
  eModifierType_Wave = 7,
  eModifierType_Armature = 8,
  eModifierType_Hook = 9,
  eModifierType_Softbody = 10,
  eModifierType_Boolean = 11,
  eModifierType_Array = 12,
  eModifierType_EdgeSplit = 13,
  eModifierType_Displace = 14,
  eModifierType_UVProject = 15,
  eModifierType_Smooth = 16,
  eModifierType_Cast = 17,
  eModifierType_MeshDeform = 18,
  eModifierType_ParticleSystem = 19,
  eModifierType_ParticleInstance = 20,
  eModifierType_Explode = 21,
  eModifierType_Cloth = 22,
  eModifierType_Collision = 23,
  eModifierType_Bevel = 24,
  eModifierType_Shrinkwrap = 25,
  eModifierType_Fluidsim = 26,
  eModifierType_Mask = 27,
  eModifierType_SimpleDeform = 28,
  eModifierType_Multires = 29,
  eModifierType_Surface = 30,
#ifdef DNA_DEPRECATED_ALLOW
  eModifierType_Smoke = 31,
#endif
  eModifierType_ShapeKey = 32,
  eModifierType_Solidify = 33,
  eModifierType_Screw = 34,
  eModifierType_Warp = 35,
  eModifierType_WeightVGEdit = 36,
  eModifierType_WeightVGMix = 37,
  eModifierType_WeightVGProximity = 38,
  eModifierType_Ocean = 39,
  eModifierType_DynamicPaint = 40,
  eModifierType_Remesh = 41,
  eModifierType_Skin = 42,
  eModifierType_LaplacianSmooth = 43,
  eModifierType_Triangulate = 44,
  eModifierType_UVWarp = 45,
  eModifierType_MeshCache = 46,
  eModifierType_LaplacianDeform = 47,
  eModifierType_Wireframe = 48,
  eModifierType_DataTransfer = 49,
  eModifierType_NormalEdit = 50,
  eModifierType_CorrectiveSmooth = 51,
  eModifierType_MeshSequenceCache = 52,
  eModifierType_SurfaceDeform = 53,
  eModifierType_WeightedNormal = 54,
  eModifierType_Weld = 55,
  eModifierType_Fluid = 56,
  eModifierType_Nodes = 57,
  eModifierType_MeshToVolume = 58,
  eModifierType_VolumeDisplace = 59,
  eModifierType_VolumeToMesh = 60,
  eModifierType_GreasePencilOpacity = 61,
  eModifierType_GreasePencilSubdiv = 62,
  eModifierType_GreasePencilColor = 63,
  eModifierType_GreasePencilTint = 64,
  eModifierType_GreasePencilSmooth = 65,
  eModifierType_GreasePencilOffset = 66,
  eModifierType_GreasePencilNoise = 67,
  eModifierType_GreasePencilMirror = 68,
  eModifierType_GreasePencilThickness = 69,
  eModifierType_GreasePencilLattice = 70,
  eModifierType_GreasePencilDash = 71,
  eModifierType_GreasePencilMultiply = 72,
  eModifierType_GreasePencilLength = 73,
  eModifierType_GreasePencilWeightAngle = 74,
  eModifierType_GreasePencilArray = 75,
  eModifierType_GreasePencilWeightProximity = 76,
  eModifierType_GreasePencilHook = 77,
  eModifierType_GreasePencilLineart = 78,
  eModifierType_GreasePencilArmature = 79,
  eModifierType_GreasePencilTime = 80,
  eModifierType_GreasePencilEnvelope = 81,
  eModifierType_GreasePencilOutline = 82,
  eModifierType_GreasePencilShrinkwrap = 83,
  eModifierType_GreasePencilBuild = 84,
  eModifierType_GreasePencilSimplify = 85,
  eModifierType_GreasePencilTexture = 86,
  NUM_MODIFIER_TYPES,
} ModifierType;
 
typedef enum ModifierMode {
  eModifierMode_Realtime = (1 << 0),
  eModifierMode_Render = (1 << 1),
  eModifierMode_Editmode = (1 << 2),
  eModifierMode_OnCage = (1 << 3),
#ifdef DNA_DEPRECATED_ALLOW
  eModifierMode_Expanded_DEPRECATED = (1 << 4),
#endif
  eModifierMode_Virtual = (1 << 5),
  eModifierMode_ApplyOnSpline = (1 << 6),
  eModifierMode_DisableTemporary = (1u << 31),
} ModifierMode;
ENUM_OPERATORS(ModifierMode, eModifierMode_DisableTemporary);
 
typedef struct ModifierData {
  struct ModifierData *next, *prev;
 
  int type, mode;
  float execution_time;
  short flag;
  short ui_expand_flag;
  uint16_t layout_panel_open_flag;
  char _pad[2];
  int persistent_uid;
  char name[64];
 
  char *error;
 
  void *runtime;
} ModifierData;
 
typedef enum {
  eModifierFlag_OverrideLibrary_Local = (1 << 0),
  eModifierFlag_SharedCaches = (1 << 1),
  eModifierFlag_Active = (1 << 2),
  eModifierFlag_UserModified = (1 << 3),
  eModifierFlag_PinLast = (1 << 4),
} ModifierFlag;
 
typedef struct MappingInfoModifierData {
  ModifierData modifier;
 
  struct Tex *texture;
  struct Object *map_object;
  char map_bone[64];
  char uvlayer_name[68];
  char _pad1[4];
  int uvlayer_tmp;
  int texmapping;
} MappingInfoModifierData;
 
typedef enum {
  eSubsurfModifierFlag_Incremental = (1 << 0),
  eSubsurfModifierFlag_DebugIncr = (1 << 1),
  eSubsurfModifierFlag_ControlEdges = (1 << 2),
  /* DEPRECATED, ONLY USED FOR DO-VERSIONS */
  eSubsurfModifierFlag_SubsurfUv_DEPRECATED = (1 << 3),
  eSubsurfModifierFlag_UseCrease = (1 << 4),
  eSubsurfModifierFlag_UseCustomNormals = (1 << 5),
  eSubsurfModifierFlag_UseRecursiveSubdivision = (1 << 6),
} SubsurfModifierFlag;
 
typedef enum {
  SUBSURF_TYPE_CATMULL_CLARK = 0,
  SUBSURF_TYPE_SIMPLE = 1,
} eSubsurfModifierType;
 
typedef enum {
  SUBSURF_UV_SMOOTH_NONE = 0,
  SUBSURF_UV_SMOOTH_PRESERVE_CORNERS = 1,
  SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_AND_JUNCTIONS = 2,
  SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE = 3,
  SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES = 4,
  SUBSURF_UV_SMOOTH_ALL = 5,
} eSubsurfUVSmooth;
 
typedef enum {
  SUBSURF_BOUNDARY_SMOOTH_ALL = 0,
  SUBSURF_BOUNDARY_SMOOTH_PRESERVE_CORNERS = 1,
} eSubsurfBoundarySmooth;
 
typedef struct SubsurfModifierData {
  ModifierData modifier;
 
  short subdivType, levels, renderLevels, flags;
  short uv_smooth;
  short quality;
  short boundary_smooth;
  char _pad[2];
 
  /* TODO(sergey): Get rid of those with the old CCG subdivision code. */
  void *emCache, *mCache;
} SubsurfModifierData;
 
typedef struct LatticeModifierData {
  ModifierData modifier;
 
  struct Object *object;
  char name[64];
  float strength;
  short flag;
  char _pad[2];
  void *_pad1;
} LatticeModifierData;
 
enum {
  MOD_LATTICE_INVERT_VGROUP = (1 << 0),
};
 
typedef struct CurveModifierData {
  ModifierData modifier;
 
  struct Object *object;
  char name[64];
  short defaxis;
  short flag;
  char _pad[4];
  void *_pad1;
} CurveModifierData;
 
enum {
  MOD_CURVE_INVERT_VGROUP = (1 << 0),
};
 
enum {
  MOD_CURVE_POSX = 1,
  MOD_CURVE_POSY = 2,
  MOD_CURVE_POSZ = 3,
  MOD_CURVE_NEGX = 4,
  MOD_CURVE_NEGY = 5,
  MOD_CURVE_NEGZ = 6,
};
 
typedef struct BuildModifierData {
  ModifierData modifier;
 
  float start, length;
  short flag;
 
  short randomize;
  int seed;
} BuildModifierData;
 
enum {
  MOD_BUILD_FLAG_RANDOMIZE = (1 << 0),
  MOD_BUILD_FLAG_REVERSE = (1 << 1),
};
 
typedef struct MaskModifierData {
  ModifierData modifier;
 
  struct Object *ob_arm;
  char vgroup[64];
 
  short mode;
  short flag;
  float threshold;
  void *_pad1;
} MaskModifierData;
 
enum {
  MOD_MASK_MODE_VGROUP = 0,
  MOD_MASK_MODE_ARM = 1,
};
 
enum {
  MOD_MASK_INV = (1 << 0),
  MOD_MASK_SMOOTH = (1 << 1),
};
 
typedef struct ArrayModifierData {
  ModifierData modifier;
 
  struct Object *start_cap;
  struct Object *end_cap;
  struct Object *curve_ob;
  struct Object *offset_ob;
  float offset[3];
  float scale[3];
  float length;
  float merge_dist;
  int fit_type;
  int offset_type;
  int flags;
  int count;
  float uv_offset[2];
} ArrayModifierData;
 
enum {
  MOD_ARR_FIXEDCOUNT = 0,
  MOD_ARR_FITLENGTH = 1,
  MOD_ARR_FITCURVE = 2,
};
 
enum {
  MOD_ARR_OFF_CONST = (1 << 0),
  MOD_ARR_OFF_RELATIVE = (1 << 1),
  MOD_ARR_OFF_OBJ = (1 << 2),
};
 
enum {
  MOD_ARR_MERGE = (1 << 0),
  MOD_ARR_MERGEFINAL = (1 << 1),
};
 
typedef struct MirrorModifierData {
  ModifierData modifier;
 
  short axis DNA_DEPRECATED;
  short flag;
  float tolerance;
  float bisect_threshold;
 
  uint8_t use_correct_order_on_merge;
 
  char _pad[3];
  float uv_offset[2];
  float uv_offset_copy[2];
  struct Object *mirror_ob;
  void *_pad1;
} MirrorModifierData;
 
enum {
  MOD_MIR_CLIPPING = (1 << 0),
  MOD_MIR_MIRROR_U = (1 << 1),
  MOD_MIR_MIRROR_V = (1 << 2),
  MOD_MIR_AXIS_X = (1 << 3),
  MOD_MIR_AXIS_Y = (1 << 4),
  MOD_MIR_AXIS_Z = (1 << 5),
  MOD_MIR_VGROUP = (1 << 6),
  MOD_MIR_NO_MERGE = (1 << 7),
  MOD_MIR_BISECT_AXIS_X = (1 << 8),
  MOD_MIR_BISECT_AXIS_Y = (1 << 9),
  MOD_MIR_BISECT_AXIS_Z = (1 << 10),
  MOD_MIR_BISECT_FLIP_AXIS_X = (1 << 11),
  MOD_MIR_BISECT_FLIP_AXIS_Y = (1 << 12),
  MOD_MIR_BISECT_FLIP_AXIS_Z = (1 << 13),
  MOD_MIR_MIRROR_UDIM = (1 << 14),
};
 
typedef struct EdgeSplitModifierData {
  ModifierData modifier;
 
  float split_angle;
  int flags;
} EdgeSplitModifierData;
 
enum {
  MOD_EDGESPLIT_FROMANGLE = (1 << 1),
  MOD_EDGESPLIT_FROMFLAG = (1 << 2),
};
 
typedef struct BevelModifierData {
  ModifierData modifier;
 
  float value;
  int res;
  short flags;
  short val_flags;
  short profile_type;
  short lim_flags;
  short e_flags;
  short mat;
  short edge_flags;
  short face_str_mode;
  short miter_inner;
  short miter_outer;
  short vmesh_method;
  char affect_type;
  char _pad;
  float profile;
  float bevel_angle;
  float spread;
  char defgrp_name[64];
 
  char _pad1[4];
  struct CurveProfile *custom_profile;
 
  char edge_weight_name[64];
 
  char vertex_weight_name[64];
} BevelModifierData;
 
enum {
#ifdef DNA_DEPRECATED_ALLOW
  MOD_BEVEL_VERT_DEPRECATED = (1 << 1),
#endif
  MOD_BEVEL_INVERT_VGROUP = (1 << 2),
  MOD_BEVEL_ANGLE = (1 << 3),
  MOD_BEVEL_WEIGHT = (1 << 4),
  MOD_BEVEL_VGROUP = (1 << 5),
/* unused                  = (1 << 6), */
#ifdef DNA_DEPRECATED_ALLOW
  MOD_BEVEL_CUSTOM_PROFILE_DEPRECATED = (1 << 7),
#endif
  /* unused                  = (1 << 8), */
  /* unused                  = (1 << 9), */
  /* unused                  = (1 << 10), */
  /* unused                  = (1 << 11), */
  /* unused                  = (1 << 12), */
  MOD_BEVEL_OVERLAP_OK = (1 << 13),
  MOD_BEVEL_EVEN_WIDTHS = (1 << 14),
  MOD_BEVEL_HARDEN_NORMALS = (1 << 15),
};
 
enum {
  MOD_BEVEL_AMT_OFFSET = 0,
  MOD_BEVEL_AMT_WIDTH = 1,
  MOD_BEVEL_AMT_DEPTH = 2,
  MOD_BEVEL_AMT_PERCENT = 3,
  MOD_BEVEL_AMT_ABSOLUTE = 4,
};
 
enum {
  MOD_BEVEL_PROFILE_SUPERELLIPSE = 0,
  MOD_BEVEL_PROFILE_CUSTOM = 1,
};
 
enum {
  MOD_BEVEL_MARK_SEAM = (1 << 0),
  MOD_BEVEL_MARK_SHARP = (1 << 1),
};
 
enum {
  MOD_BEVEL_FACE_STRENGTH_NONE = 0,
  MOD_BEVEL_FACE_STRENGTH_NEW = 1,
  MOD_BEVEL_FACE_STRENGTH_AFFECTED = 2,
  MOD_BEVEL_FACE_STRENGTH_ALL = 3,
};
 
enum {
  MOD_BEVEL_MITER_SHARP = 0,
  MOD_BEVEL_MITER_PATCH = 1,
  MOD_BEVEL_MITER_ARC = 2,
};
 
enum {
  MOD_BEVEL_VMESH_ADJ = 0,
  MOD_BEVEL_VMESH_CUTOFF = 1,
};
 
enum {
  MOD_BEVEL_AFFECT_VERTICES = 0,
  MOD_BEVEL_AFFECT_EDGES = 1,
};
 
typedef struct FluidModifierData {
  ModifierData modifier;
 
  struct FluidDomainSettings *domain;
  struct FluidFlowSettings *flow;
  struct FluidEffectorSettings *effector;
  float time;
  int type;
  void *_pad1;
} FluidModifierData;
 
enum {
  MOD_FLUID_TYPE_DOMAIN = (1 << 0),
  MOD_FLUID_TYPE_FLOW = (1 << 1),
  MOD_FLUID_TYPE_EFFEC = (1 << 2),
};
 
typedef struct DisplaceModifierData {
  ModifierData modifier;
 
  /* Keep in sync with #MappingInfoModifierData. */
 
  struct Tex *texture;
  struct Object *map_object;
  char map_bone[64];
  char uvlayer_name[68];
  char _pad1[4];
  int uvlayer_tmp;
  int texmapping;
  /* end MappingInfoModifierData */
 
  float strength;
  int direction;
  char defgrp_name[64];
  float midlevel;
  int space;
  short flag;
  char _pad2[6];
} DisplaceModifierData;
 
enum {
  MOD_DISP_INVERT_VGROUP = (1 << 0),
};
 
enum {
  MOD_DISP_DIR_X = 0,
  MOD_DISP_DIR_Y = 1,
  MOD_DISP_DIR_Z = 2,
  MOD_DISP_DIR_NOR = 3,
  MOD_DISP_DIR_RGB_XYZ = 4,
  MOD_DISP_DIR_CLNOR = 5,
};
 
enum {
  MOD_DISP_MAP_LOCAL = 0,
  MOD_DISP_MAP_GLOBAL = 1,
  MOD_DISP_MAP_OBJECT = 2,
  MOD_DISP_MAP_UV = 3,
};
 
enum {
  MOD_DISP_SPACE_LOCAL = 0,
  MOD_DISP_SPACE_GLOBAL = 1,
};
 
typedef struct UVProjectModifierData {
  ModifierData modifier;
  struct Object *projectors[10];
  char _pad2[4];
  int projectors_num;
  float aspectx, aspecty;
  float scalex, scaley;
  char uvlayer_name[68];
  int uvlayer_tmp;
} UVProjectModifierData;
 
#define MOD_UVPROJECT_MAXPROJECTORS 10
 
typedef struct DecimateModifierData {
  ModifierData modifier;
 
  float percent;
  short iter;
  char delimit;
  char symmetry_axis;
  float angle;
 
  char defgrp_name[64];
  float defgrp_factor;
  short flag, mode;
 
  int face_count;
} DecimateModifierData;
 
enum {
  MOD_DECIM_FLAG_INVERT_VGROUP = (1 << 0),
  MOD_DECIM_FLAG_TRIANGULATE = (1 << 1),
  MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS = (1 << 2),
  MOD_DECIM_FLAG_SYMMETRY = (1 << 3),
};
 
enum {
  MOD_DECIM_MODE_COLLAPSE = 0,
  MOD_DECIM_MODE_UNSUBDIV = 1,
  MOD_DECIM_MODE_DISSOLVE = 2,
};
 
typedef struct SmoothModifierData {
  ModifierData modifier;
  float fac;
  char defgrp_name[64];
  short flag, repeat;
 
} SmoothModifierData;
 
enum {
  MOD_SMOOTH_INVERT_VGROUP = (1 << 0),
  MOD_SMOOTH_X = (1 << 1),
  MOD_SMOOTH_Y = (1 << 2),
  MOD_SMOOTH_Z = (1 << 3),
};
 
typedef struct CastModifierData {
  ModifierData modifier;
 
  struct Object *object;
  float fac;
  float radius;
  float size;
  char defgrp_name[64];
  short flag;
  short type;
  void *_pad1;
} CastModifierData;
 
enum {
  /* And what bout (1 << 0) flag? ;) */
  MOD_CAST_INVERT_VGROUP = (1 << 0),
  MOD_CAST_X = (1 << 1),
  MOD_CAST_Y = (1 << 2),
  MOD_CAST_Z = (1 << 3),
  MOD_CAST_USE_OB_TRANSFORM = (1 << 4),
  MOD_CAST_SIZE_FROM_RADIUS = (1 << 5),
};
 
enum {
  MOD_CAST_TYPE_SPHERE = 0,
  MOD_CAST_TYPE_CYLINDER = 1,
  MOD_CAST_TYPE_CUBOID = 2,
};
 
typedef struct WaveModifierData {
  ModifierData modifier;
 
  /* Keep in sync with #MappingInfoModifierData. */
 
  struct Tex *texture;
  struct Object *map_object;
  char map_bone[64];
  char uvlayer_name[68];
  char _pad1[4];
  int uvlayer_tmp;
  int texmapping;
  /* End MappingInfoModifierData. */
 
  struct Object *objectcenter;
  char defgrp_name[64];
 
  short flag;
  char _pad2[2];
 
  float startx, starty, height, width;
  float narrow, speed, damp, falloff;
 
  float timeoffs, lifetime;
  char _pad3[4];
  void *_pad4;
} WaveModifierData;
 
enum {
  MOD_WAVE_INVERT_VGROUP = (1 << 0),
  MOD_WAVE_X = (1 << 1),
  MOD_WAVE_Y = (1 << 2),
  MOD_WAVE_CYCL = (1 << 3),
  MOD_WAVE_NORM = (1 << 4),
  MOD_WAVE_NORM_X = (1 << 5),
  MOD_WAVE_NORM_Y = (1 << 6),
  MOD_WAVE_NORM_Z = (1 << 7),
};
 
typedef struct ArmatureModifierData {
  ModifierData modifier;
 
  short deformflag, multi;
  char _pad2[4];
  struct Object *object;
  float (*vert_coords_prev)[3];
  char defgrp_name[64];
} ArmatureModifierData;
 
enum {
  MOD_HOOK_UNIFORM_SPACE = (1 << 0),
  MOD_HOOK_INVERT_VGROUP = (1 << 1),
};
 
typedef enum {
  eHook_Falloff_None = 0,
  eHook_Falloff_Curve = 1,
  eHook_Falloff_Sharp = 2,     /* PROP_SHARP */
  eHook_Falloff_Smooth = 3,    /* PROP_SMOOTH */
  eHook_Falloff_Root = 4,      /* PROP_ROOT */
  eHook_Falloff_Linear = 5,    /* PROP_LIN */
  eHook_Falloff_Const = 6,     /* PROP_CONST */
  eHook_Falloff_Sphere = 7,    /* PROP_SPHERE */
  eHook_Falloff_InvSquare = 8, /* PROP_INVSQUARE */
  /* PROP_RANDOM not used */
} HookModifierFalloff;
 
typedef struct HookModifierData {
  ModifierData modifier;
 
  struct Object *object;
  char subtarget[64];
 
  char flag;
  char falloff_type;
  char _pad[6];
  float parentinv[4][4];
  float cent[3];
  float falloff;
 
  struct CurveMapping *curfalloff;
 
  int *indexar;
  int indexar_num;
  float force;
  char name[64];
  void *_pad1;
} HookModifierData;
 
typedef struct SoftbodyModifierData {
  ModifierData modifier;
} SoftbodyModifierData;
 
typedef struct ClothModifierData {
  ModifierData modifier;
 
  struct Cloth *clothObject;
  struct ClothSimSettings *sim_parms;
  struct ClothCollSettings *coll_parms;
 
  struct PointCache *point_cache;
  struct ListBase ptcaches;
 
  struct ClothHairData *hairdata;
  float hair_grid_min[3];
  float hair_grid_max[3];
  int hair_grid_res[3];
  float hair_grid_cellsize;
 
  struct ClothSolverResult *solver_result;
} ClothModifierData;
 
typedef struct CollisionModifierData {
  ModifierData modifier;
 
  float (*x)[3];
  float (*xnew)[3];
  float (*xold)[3];
  float (*current_xnew)[3];
  float (*current_x)[3];
  float (*current_v)[3];
 
  int (*vert_tris)[3];
 
  unsigned int mvert_num;
  unsigned int tri_num;
  float time_x, time_xnew;
  char is_static;
  char _pad[7];
 
  struct BVHTree *bvhtree;
} CollisionModifierData;
 
typedef struct SurfaceModifierData_Runtime {
 
  float (*vert_positions_prev)[3];
  float (*vert_velocities)[3];
 
  struct Mesh *mesh;
 
  struct BVHTreeFromMesh *bvhtree;
 
  int cfra_prev, verts_num;
 
} SurfaceModifierData_Runtime;
 
typedef struct SurfaceModifierData {
  ModifierData modifier;
 
  SurfaceModifierData_Runtime runtime;
} SurfaceModifierData;
 
typedef struct BooleanModifierData {
  ModifierData modifier;
 
  struct Object *object;
  struct Collection *collection;
  float double_threshold;
  char operation;
  char solver;
  char material_mode;
  char flag;
  char bm_flag;
  char _pad[7];
} BooleanModifierData;
 
typedef enum BooleanModifierMaterialMode {
  eBooleanModifierMaterialMode_Index = 0,
  eBooleanModifierMaterialMode_Transfer = 1,
} BooleanModifierMaterialMode;
 
typedef enum {
  eBooleanModifierOp_Intersect = 0,
  eBooleanModifierOp_Union = 1,
  eBooleanModifierOp_Difference = 2,
} BooleanModifierOp;
 
typedef enum {
  eBooleanModifierSolver_Float = 0,
  eBooleanModifierSolver_Mesh_Arr = 1,
} BooleanModifierSolver;
 
enum {
  eBooleanModifierFlag_Self = (1 << 0),
  eBooleanModifierFlag_Object = (1 << 1),
  eBooleanModifierFlag_Collection = (1 << 2),
  eBooleanModifierFlag_HoleTolerant = (1 << 3),
};
 
enum {
  eBooleanModifierBMeshFlag_BMesh_Separate = (1 << 0),
  eBooleanModifierBMeshFlag_BMesh_NoDissolve = (1 << 1),
  eBooleanModifierBMeshFlag_BMesh_NoConnectRegions = (1 << 2),
};
 
typedef struct MDefInfluence {
  int vertex;
  float weight;
} MDefInfluence;
 
typedef struct MDefCell {
  int offset;
  int influences_num;
} MDefCell;
 
typedef struct MeshDeformModifierData {
  ModifierData modifier;
 
  struct Object *object;
  char defgrp_name[64];
 
  short gridsize, flag;
  char _pad[4];
 
  /* result of static binding */
  MDefInfluence *bindinfluences;
  int *bindoffsets;
  float *bindcagecos;
  int verts_num, cage_verts_num;
 
  /* result of dynamic binding */
  MDefCell *dyngrid;
  MDefInfluence *dyninfluences;
  int *dynverts;
  int dyngridsize;
  int influences_num;
  float dyncellmin[3];
  float dyncellwidth;
  float bindmat[4][4];
 
  /* deprecated storage */
  float *bindweights;
  float *bindcos;
 
  /* runtime */
  void (*bindfunc)(struct Object *object,
                   struct MeshDeformModifierData *mmd,
                   struct Mesh *cagemesh,
                   float *vertexcos,
                   int verts_num,
                   float cagemat[4][4]);
} MeshDeformModifierData;
 
enum {
  MOD_MDEF_INVERT_VGROUP = (1 << 0),
  MOD_MDEF_DYNAMIC_BIND = (1 << 1),
};
 
typedef struct ParticleSystemModifierData {
  ModifierData modifier;
 
  struct ParticleSystem *psys;
  struct Mesh *mesh_final;
  struct Mesh *mesh_original;
  int totdmvert, totdmedge, totdmface;
  short flag;
  char _pad[2];
  void *_pad1;
} ParticleSystemModifierData;
 
typedef enum {
  eParticleSystemFlag_Pars = (1 << 0),
  eParticleSystemFlag_psys_updated = (1 << 1),
  eParticleSystemFlag_file_loaded = (1 << 2),
} ParticleSystemModifierFlag;
 
typedef enum {
  eParticleInstanceFlag_Parents = (1 << 0),
  eParticleInstanceFlag_Children = (1 << 1),
  eParticleInstanceFlag_Path = (1 << 2),
  eParticleInstanceFlag_Unborn = (1 << 3),
  eParticleInstanceFlag_Alive = (1 << 4),
  eParticleInstanceFlag_Dead = (1 << 5),
  eParticleInstanceFlag_KeepShape = (1 << 6),
  eParticleInstanceFlag_UseSize = (1 << 7),
} ParticleInstanceModifierFlag;
 
typedef enum {
  eParticleInstanceSpace_World = 0,
  eParticleInstanceSpace_Local = 1,
} ParticleInstanceModifierSpace;
 
typedef struct ParticleInstanceModifierData {
  ModifierData modifier;
 
  struct Object *ob;
  short psys, flag, axis, space;
  float position, random_position;
  float rotation, random_rotation;
  float particle_amount, particle_offset;
  char index_layer_name[68];
  char value_layer_name[68];
  void *_pad1;
} ParticleInstanceModifierData;
 
typedef enum {
  eExplodeFlag_CalcFaces = (1 << 0),
  eExplodeFlag_PaSize = (1 << 1),
  eExplodeFlag_EdgeCut = (1 << 2),
  eExplodeFlag_Unborn = (1 << 3),
  eExplodeFlag_Alive = (1 << 4),
  eExplodeFlag_Dead = (1 << 5),
  eExplodeFlag_INVERT_VGROUP = (1 << 6),
} ExplodeModifierFlag;
 
typedef struct ExplodeModifierData {
  ModifierData modifier;
 
  int *facepa;
  short flag, vgroup;
  float protect;
  char uvname[68];
  char _pad1[4];
  void *_pad2;
} ExplodeModifierData;
 
typedef struct MultiresModifierData {
  DNA_DEFINE_CXX_METHODS(MultiresModifierData)
 
  ModifierData modifier;
 
  char lvl, sculptlvl, renderlvl, totlvl;
  char simple DNA_DEPRECATED;
  char flags, _pad[2];
  short quality;
  short uv_smooth;
  short boundary_smooth;
  char _pad2[2];
} MultiresModifierData;
 
typedef enum {
  eMultiresModifierFlag_ControlEdges = (1 << 0),
  /* DEPRECATED, only used for versioning. */
  eMultiresModifierFlag_PlainUv_DEPRECATED = (1 << 1),
  eMultiresModifierFlag_UseCrease = (1 << 2),
  eMultiresModifierFlag_UseCustomNormals = (1 << 3),
  eMultiresModifierFlag_UseSculptBaseMesh = (1 << 4),
} MultiresModifierFlag;
 
typedef struct FluidsimModifierData {
  ModifierData modifier;
 
  struct FluidsimSettings *fss;
  void *_pad1;
} FluidsimModifierData;
 
typedef struct SmokeModifierData {
  ModifierData modifier;
 
  int type;
  int _pad;
} SmokeModifierData;
 
typedef struct ShrinkwrapModifierData {
  ModifierData modifier;
 
  struct Object *target;
  struct Object *auxTarget;
  char vgroup_name[64];
  float keepDist;
  short shrinkType;
  char shrinkOpts;
  char shrinkMode;
  float projLimit;
  char projAxis;
 
  char subsurfLevels;
 
  char _pad[2];
} ShrinkwrapModifierData;
 
enum {
  MOD_SHRINKWRAP_NEAREST_SURFACE = 0,
  MOD_SHRINKWRAP_PROJECT = 1,
  MOD_SHRINKWRAP_NEAREST_VERTEX = 2,
  MOD_SHRINKWRAP_TARGET_PROJECT = 3,
};
 
enum {
  MOD_SHRINKWRAP_ON_SURFACE = 0,
  MOD_SHRINKWRAP_INSIDE = 1,
  MOD_SHRINKWRAP_OUTSIDE = 2,
  MOD_SHRINKWRAP_OUTSIDE_SURFACE = 3,
  MOD_SHRINKWRAP_ABOVE_SURFACE = 4,
};
 
enum {
  MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR = (1 << 0),
  MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR = (1 << 1),
 
  MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE = (1 << 3),
  MOD_SHRINKWRAP_CULL_TARGET_BACKFACE = (1 << 4),
 
#ifdef DNA_DEPRECATED_ALLOW
  MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE = (1 << 5),
#endif
 
  MOD_SHRINKWRAP_INVERT_VGROUP = (1 << 6),
  MOD_SHRINKWRAP_INVERT_CULL_TARGET = (1 << 7),
};
 
#define MOD_SHRINKWRAP_CULL_TARGET_MASK \
  (MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE | MOD_SHRINKWRAP_CULL_TARGET_BACKFACE)
 
enum {
  MOD_SHRINKWRAP_PROJECT_OVER_NORMAL = 0,
  MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS = (1 << 0),
  MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS = (1 << 1),
  MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS = (1 << 2),
};
 
typedef struct SimpleDeformModifierData {
  ModifierData modifier;
 
  struct Object *origin;
  char vgroup_name[64];
  float factor;
  float limit[2];
 
  char mode;
  char axis;
  char deform_axis;
  char flag;
 
  void *_pad1;
} SimpleDeformModifierData;
 
enum {
  MOD_SIMPLEDEFORM_FLAG_INVERT_VGROUP = (1 << 0),
};
 
enum {
  MOD_SIMPLEDEFORM_MODE_TWIST = 1,
  MOD_SIMPLEDEFORM_MODE_BEND = 2,
  MOD_SIMPLEDEFORM_MODE_TAPER = 3,
  MOD_SIMPLEDEFORM_MODE_STRETCH = 4,
};
 
enum {
  MOD_SIMPLEDEFORM_LOCK_AXIS_X = (1 << 0),
  MOD_SIMPLEDEFORM_LOCK_AXIS_Y = (1 << 1),
  MOD_SIMPLEDEFORM_LOCK_AXIS_Z = (1 << 2),
};
 
typedef struct ShapeKeyModifierData {
  ModifierData modifier;
} ShapeKeyModifierData;
 
typedef struct SolidifyModifierData {
  ModifierData modifier;
 
  char defgrp_name[64];
  char shell_defgrp_name[64];
  char rim_defgrp_name[64];
  float offset;
  float offset_fac;
  float offset_fac_vg;
  float offset_clamp;
  char mode;
 
  char nonmanifold_offset_mode;
  char nonmanifold_boundary_mode;
 
  char _pad;
  float crease_inner;
  float crease_outer;
  float crease_rim;
  int flag;
  short mat_ofs;
  short mat_ofs_rim;
 
  float merge_tolerance;
  float bevel_convex;
} SolidifyModifierData;
 
enum {
  MOD_SOLIDIFY_RIM = (1 << 0),
  MOD_SOLIDIFY_EVEN = (1 << 1),
  MOD_SOLIDIFY_NORMAL_CALC = (1 << 2),
  MOD_SOLIDIFY_VGROUP_INV = (1 << 3),
#ifdef DNA_DEPRECATED_ALLOW
  MOD_SOLIDIFY_RIM_MATERIAL = (1 << 4), /* deprecated, used in do_versions */
#endif
  MOD_SOLIDIFY_FLIP = (1 << 5),
  MOD_SOLIDIFY_NOSHELL = (1 << 6),
  MOD_SOLIDIFY_OFFSET_ANGLE_CLAMP = (1 << 7),
  MOD_SOLIDIFY_NONMANIFOLD_FLAT_FACES = (1 << 8),
};
 
enum {
  MOD_SOLIDIFY_MODE_EXTRUDE = 0,
  MOD_SOLIDIFY_MODE_NONMANIFOLD = 1,
};
 
enum {
  MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_FIXED = 0,
  MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_EVEN = 1,
  MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_CONSTRAINTS = 2,
};
 
enum {
  MOD_SOLIDIFY_NONMANIFOLD_BOUNDARY_MODE_NONE = 0,
  MOD_SOLIDIFY_NONMANIFOLD_BOUNDARY_MODE_ROUND = 1,
  MOD_SOLIDIFY_NONMANIFOLD_BOUNDARY_MODE_FLAT = 2,
};
 
typedef struct ScrewModifierData {
  ModifierData modifier;
 
  struct Object *ob_axis;
  unsigned int steps;
  unsigned int render_steps;
  unsigned int iter;
  float screw_ofs;
  float angle;
  float merge_dist;
  short flag;
  char axis;
  char _pad[5];
  void *_pad1;
} ScrewModifierData;
 
enum {
  MOD_SCREW_NORMAL_FLIP = (1 << 0),
  MOD_SCREW_NORMAL_CALC = (1 << 1),
  MOD_SCREW_OBJECT_OFFSET = (1 << 2),
  /*  MOD_SCREW_OBJECT_ANGLE   = (1 << 4), */
  MOD_SCREW_SMOOTH_SHADING = (1 << 5),
  MOD_SCREW_UV_STRETCH_U = (1 << 6),
  MOD_SCREW_UV_STRETCH_V = (1 << 7),
  MOD_SCREW_MERGE = (1 << 8),
};
 
typedef struct OceanModifierData {
  ModifierData modifier;
 
  struct Ocean *ocean;
  struct OceanCache *oceancache;
 
  int resolution;
  int viewport_resolution;
 
  int spatial_size;
 
  float wind_velocity;
 
  float damp;
  float smallest_wave;
  float depth;
 
  float wave_alignment;
  float wave_direction;
  float wave_scale;
 
  float chop_amount;
  float foam_coverage;
  float time;
 
  /* Spectrum being used. */
  int spectrum;
 
  /* Common JONSWAP parameters. */
  float fetch_jonswap;
  float sharpen_peak_jonswap;
 
  int bakestart;
  int bakeend;
 
  char cachepath[1024];
  char foamlayername[68];
  char spraylayername[68];
  char cached;
  char geometry_mode;
 
  char flag;
  char _pad2;
 
  short repeat_x;
  short repeat_y;
 
  int seed;
 
  float size;
 
  float foam_fade;
 
  char _pad[4];
} OceanModifierData;
 
enum {
  MOD_OCEAN_GEOM_GENERATE = 0,
  MOD_OCEAN_GEOM_DISPLACE = 1,
  MOD_OCEAN_GEOM_SIM_ONLY = 2,
};
 
enum {
  MOD_OCEAN_SPECTRUM_PHILLIPS = 0,
  MOD_OCEAN_SPECTRUM_PIERSON_MOSKOWITZ = 1,
  MOD_OCEAN_SPECTRUM_JONSWAP = 2,
  MOD_OCEAN_SPECTRUM_TEXEL_MARSEN_ARSLOE = 3,
};
 
enum {
  MOD_OCEAN_GENERATE_FOAM = (1 << 0),
  MOD_OCEAN_GENERATE_NORMALS = (1 << 1),
  MOD_OCEAN_GENERATE_SPRAY = (1 << 2),
  MOD_OCEAN_INVERT_SPRAY = (1 << 3),
};
 
typedef struct WarpModifierData {
  ModifierData modifier;
 
  /* Keep in sync with #MappingInfoModifierData. */
 
  struct Tex *texture;
  struct Object *map_object;
  char map_bone[64];
  char uvlayer_name[68];
  char _pad1[4];
  int uvlayer_tmp;
  int texmapping;
  /* End #MappingInfoModifierData. */
 
  struct Object *object_from;
  struct Object *object_to;
  char bone_from[64];
  char bone_to[64];
 
  struct CurveMapping *curfalloff;
  char defgrp_name[64];
  float strength;
  float falloff_radius;
  char flag;
  char falloff_type;
  char _pad2[6];
  void *_pad3;
} WarpModifierData;
 
enum {
  MOD_WARP_VOLUME_PRESERVE = (1 << 0),
  MOD_WARP_INVERT_VGROUP = (1 << 1),
};
 
typedef enum {
  eWarp_Falloff_None = 0,
  eWarp_Falloff_Curve = 1,
  eWarp_Falloff_Sharp = 2,     /* PROP_SHARP */
  eWarp_Falloff_Smooth = 3,    /* PROP_SMOOTH */
  eWarp_Falloff_Root = 4,      /* PROP_ROOT */
  eWarp_Falloff_Linear = 5,    /* PROP_LIN */
  eWarp_Falloff_Const = 6,     /* PROP_CONST */
  eWarp_Falloff_Sphere = 7,    /* PROP_SPHERE */
  eWarp_Falloff_InvSquare = 8, /* PROP_INVSQUARE */
  /* PROP_RANDOM not used */
} WarpModifierFalloff;
 
typedef struct WeightVGEditModifierData {
  ModifierData modifier;
 
  char defgrp_name[64];
 
  short edit_flags;
  short falloff_type;
  float default_weight;
 
  /* Mapping stuff. */
  struct CurveMapping *cmap_curve;
 
  /* The add/remove vertices weight thresholds. */
  float add_threshold, rem_threshold;
 
  /* Masking options. */
  float mask_constant;
  char mask_defgrp_name[64];
 
  /* Texture masking. */
  int mask_tex_use_channel;
  struct Tex *mask_texture;
  struct Object *mask_tex_map_obj;
  char mask_tex_map_bone[64];
  int mask_tex_mapping;
  char mask_tex_uvlayer_name[68];
 
  /* Padding... */
  void *_pad1;
} WeightVGEditModifierData;
 
enum {
  MOD_WVG_EDIT_WEIGHTS_NORMALIZE = (1 << 0),
  MOD_WVG_INVERT_FALLOFF = (1 << 1),
  MOD_WVG_EDIT_INVERT_VGROUP_MASK = (1 << 2),
  MOD_WVG_EDIT_ADD2VG = (1 << 3),
  MOD_WVG_EDIT_REMFVG = (1 << 4),
};
 
typedef struct WeightVGMixModifierData {
  ModifierData modifier;
 
  char defgrp_name_a[64];
  char defgrp_name_b[64];
  float default_weight_a;
  float default_weight_b;
  char mix_mode;
  char mix_set;
 
  char _pad0[6];
 
  /* Masking options. */
  float mask_constant;
  char mask_defgrp_name[64];
 
  /* Texture masking. */
  int mask_tex_use_channel;
  struct Tex *mask_texture;
  struct Object *mask_tex_map_obj;
  char mask_tex_map_bone[64];
  int mask_tex_mapping;
  char mask_tex_uvlayer_name[68];
  char _pad1[4];
 
  char flag;
 
  /* Padding... */
  char _pad2[3];
} WeightVGMixModifierData;
 
enum {
  MOD_WVG_MIX_SET = 1,
  MOD_WVG_MIX_ADD = 2,
  MOD_WVG_MIX_SUB = 3,
  MOD_WVG_MIX_MUL = 4,
  MOD_WVG_MIX_DIV = 5,
  MOD_WVG_MIX_DIF = 6,
  MOD_WVG_MIX_AVG = 7,
  MOD_WVG_MIX_MIN = 8,
  MOD_WVG_MIX_MAX = 9,
};
 
enum {
  MOD_WVG_SET_ALL = 1,
  MOD_WVG_SET_A = 2,
  MOD_WVG_SET_B = 3,
  MOD_WVG_SET_OR = 4,
  MOD_WVG_SET_AND = 5,
};
 
enum {
  MOD_WVG_MIX_INVERT_VGROUP_MASK = (1 << 0),
  MOD_WVG_MIX_WEIGHTS_NORMALIZE = (1 << 1),
  MOD_WVG_MIX_INVERT_VGROUP_A = (1 << 2),
  MOD_WVG_MIX_INVERT_VGROUP_B = (1 << 3),
};
 
typedef struct WeightVGProximityModifierData {
  ModifierData modifier;
 
  char defgrp_name[64];
 
  /* Mapping stuff. */
  struct CurveMapping *cmap_curve;
 
  int proximity_mode;
  int proximity_flags;
 
  /* Target object from which to calculate vertices distances. */
  struct Object *proximity_ob_target;
 
  /* Masking options. */
  float mask_constant;
  char mask_defgrp_name[64];
 
  /* Texture masking. */
  int mask_tex_use_channel;
  struct Tex *mask_texture;
  struct Object *mask_tex_map_obj;
  char mask_tex_map_bone[64];
  int mask_tex_mapping;
  char mask_tex_uvlayer_name[68];
  char _pad1[4];
 
  float min_dist, max_dist;
 
  /* Put here to avoid breaking existing struct... */
  short falloff_type;
 
  /* Padding... */
  char _pad0[2];
} WeightVGProximityModifierData;
 
enum {
  MOD_WVG_PROXIMITY_OBJECT = 1,   /* source vertex to other location */
  MOD_WVG_PROXIMITY_GEOMETRY = 2, /* source vertex to other geometry */
};
 
enum {
  /* Use nearest vertices of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
  MOD_WVG_PROXIMITY_GEOM_VERTS = (1 << 0),
  /* Use nearest edges of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
  MOD_WVG_PROXIMITY_GEOM_EDGES = (1 << 1),
  /* Use nearest faces of target obj, in MOD_WVG_PROXIMITY_GEOMETRY mode. */
  MOD_WVG_PROXIMITY_GEOM_FACES = (1 << 2),
  MOD_WVG_PROXIMITY_INVERT_VGROUP_MASK = (1 << 3),
  MOD_WVG_PROXIMITY_INVERT_FALLOFF = (1 << 4),
  MOD_WVG_PROXIMITY_WEIGHTS_NORMALIZE = (1 << 5),
};
 
/* Defines common to all WeightVG modifiers. */
 
enum {
  MOD_WVG_MAPPING_NONE = 0,
  MOD_WVG_MAPPING_CURVE = 1,
  MOD_WVG_MAPPING_SHARP = 2,  /* PROP_SHARP */
  MOD_WVG_MAPPING_SMOOTH = 3, /* PROP_SMOOTH */
  MOD_WVG_MAPPING_ROOT = 4,   /* PROP_ROOT */
  /* PROP_LIN not used (same as NONE, here...). */
  /* PROP_CONST not used. */
  MOD_WVG_MAPPING_SPHERE = 7, /* PROP_SPHERE */
  MOD_WVG_MAPPING_RANDOM = 8, /* PROP_RANDOM */
  MOD_WVG_MAPPING_STEP = 9,   /* Median Step. */
};
 
enum {
  MOD_WVG_MASK_TEX_USE_INT = 1,
  MOD_WVG_MASK_TEX_USE_RED = 2,
  MOD_WVG_MASK_TEX_USE_GREEN = 3,
  MOD_WVG_MASK_TEX_USE_BLUE = 4,
  MOD_WVG_MASK_TEX_USE_HUE = 5,
  MOD_WVG_MASK_TEX_USE_SAT = 6,
  MOD_WVG_MASK_TEX_USE_VAL = 7,
  MOD_WVG_MASK_TEX_USE_ALPHA = 8,
};
 
typedef struct DynamicPaintModifierData {
  ModifierData modifier;
 
  struct DynamicPaintCanvasSettings *canvas;
  struct DynamicPaintBrushSettings *brush;
  int type;
  char _pad[4];
} DynamicPaintModifierData;
 
enum {
  MOD_DYNAMICPAINT_TYPE_CANVAS = (1 << 0),
  MOD_DYNAMICPAINT_TYPE_BRUSH = (1 << 1),
};
 
typedef enum eRemeshModifierFlags {
  MOD_REMESH_FLOOD_FILL = (1 << 0),
  MOD_REMESH_SMOOTH_SHADING = (1 << 1),
} RemeshModifierFlags;
 
typedef enum eRemeshModifierMode {
  /* blocky */
  MOD_REMESH_CENTROID = 0,
  /* smooth */
  MOD_REMESH_MASS_POINT = 1,
  /* keeps sharp edges */
  MOD_REMESH_SHARP_FEATURES = 2,
  /* Voxel remesh */
  MOD_REMESH_VOXEL = 3,
} eRemeshModifierMode;
 
typedef struct RemeshModifierData {
  ModifierData modifier;
 
  float threshold;
 
  /* ratio between size of model and grid */
  float scale;
 
  float hermite_num;
 
  /* octree depth */
  char depth;
  char flag;
  char mode;
  char _pad;
 
  /* OpenVDB Voxel remesh properties. */
  float voxel_size;
  float adaptivity;
} RemeshModifierData;
 
typedef struct SkinModifierData {
  ModifierData modifier;
 
  float branch_smoothing;
 
  char flag;
 
  char symmetry_axes;
 
  char _pad[2];
} SkinModifierData;
 
enum {
  MOD_SKIN_SYMM_X = (1 << 0),
  MOD_SKIN_SYMM_Y = (1 << 1),
  MOD_SKIN_SYMM_Z = (1 << 2),
};
 
enum {
  MOD_SKIN_SMOOTH_SHADING = 1,
};
 
typedef struct TriangulateModifierData {
  ModifierData modifier;
 
  int flag;
  int quad_method;
  int ngon_method;
  int min_vertices;
} TriangulateModifierData;
 
enum {
#ifdef DNA_DEPRECATED_ALLOW
  MOD_TRIANGULATE_BEAUTY = (1 << 0), /* deprecated */
#endif
  MOD_TRIANGULATE_KEEP_CUSTOMLOOP_NORMALS = 1 << 1,
};
 
enum {
  MOD_TRIANGULATE_NGON_BEAUTY = 0,
  MOD_TRIANGULATE_NGON_EARCLIP = 1,
};
 
enum {
  MOD_TRIANGULATE_QUAD_BEAUTY = 0,
  MOD_TRIANGULATE_QUAD_FIXED = 1,
  MOD_TRIANGULATE_QUAD_ALTERNATE = 2,
  MOD_TRIANGULATE_QUAD_SHORTEDGE = 3,
  MOD_TRIANGULATE_QUAD_LONGEDGE = 4,
};
 
typedef struct LaplacianSmoothModifierData {
  ModifierData modifier;
 
  float lambda, lambda_border;
  char _pad1[4];
  char defgrp_name[64];
  short flag, repeat;
} LaplacianSmoothModifierData;
 
enum {
  MOD_LAPLACIANSMOOTH_X = (1 << 1),
  MOD_LAPLACIANSMOOTH_Y = (1 << 2),
  MOD_LAPLACIANSMOOTH_Z = (1 << 3),
  MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME = (1 << 4),
  MOD_LAPLACIANSMOOTH_NORMALIZED = (1 << 5),
  MOD_LAPLACIANSMOOTH_INVERT_VGROUP = (1 << 6),
};
 
typedef struct CorrectiveSmoothDeltaCache {
  float (*deltas)[3];
  unsigned int deltas_num;
 
  /* Value of settings when creating the cache.
   * These are used to check if the cache should be recomputed. */
  float lambda, scale;
  short repeat, flag;
  char smooth_type, rest_source;
  char _pad[6];
} CorrectiveSmoothDeltaCache;
 
typedef struct CorrectiveSmoothModifierData {
  ModifierData modifier;
 
  /* positions set during 'bind' operator
   * use for MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND */
  float (*bind_coords)[3];
 
  /* NOTE: -1 is used to bind. */
  unsigned int bind_coords_num;
 
  float lambda, scale;
  short repeat, flag;
  char smooth_type, rest_source;
  char _pad[6];
 
  char defgrp_name[64];
 
  /* runtime-only cache */
  CorrectiveSmoothDeltaCache delta_cache;
} CorrectiveSmoothModifierData;
 
enum {
  MOD_CORRECTIVESMOOTH_SMOOTH_SIMPLE = 0,
  MOD_CORRECTIVESMOOTH_SMOOTH_LENGTH_WEIGHT = 1,
};
 
enum {
  MOD_CORRECTIVESMOOTH_RESTSOURCE_ORCO = 0,
  MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND = 1,
};
 
enum {
  MOD_CORRECTIVESMOOTH_INVERT_VGROUP = (1 << 0),
  MOD_CORRECTIVESMOOTH_ONLY_SMOOTH = (1 << 1),
  MOD_CORRECTIVESMOOTH_PIN_BOUNDARY = (1 << 2),
};
 
typedef struct UVWarpModifierData {
  ModifierData modifier;
 
  char axis_u, axis_v;
  short flag;
  float center[2];
 
  float offset[2];
  float scale[2];
  float rotation;
 
  struct Object *object_src;
  char bone_src[64];
  struct Object *object_dst;
  char bone_dst[64];
 
  char vgroup_name[64];
  char uvlayer_name[68];
  char _pad[4];
} UVWarpModifierData;
 
enum {
  MOD_UVWARP_INVERT_VGROUP = 1 << 0,
};
 
typedef struct MeshCacheModifierData {
  ModifierData modifier;
 
  char flag;
  char type;
  char time_mode;
  char play_mode;
 
  /* axis conversion */
  char forward_axis;
  char up_axis;
  char flip_axis;
 
  char interp;
 
  float factor;
  char deform_mode;
  char defgrp_name[64];
  char _pad[7];
 
  /* play_mode == MOD_MESHCACHE_PLAY_CFEA */
  float frame_start;
  float frame_scale;
 
  /* play_mode == MOD_MESHCACHE_PLAY_EVAL */
  /* we could use one float for all these but their purpose is very different */
  float eval_frame;
  float eval_time;
  float eval_factor;
 
  char filepath[1024];
} MeshCacheModifierData;
 
enum {
  MOD_MESHCACHE_INVERT_VERTEX_GROUP = 1 << 0,
};
 
enum {
  MOD_MESHCACHE_TYPE_MDD = 1,
  MOD_MESHCACHE_TYPE_PC2 = 2,
};
 
enum {
  MOD_MESHCACHE_DEFORM_OVERWRITE = 0,
  MOD_MESHCACHE_DEFORM_INTEGRATE = 1,
};
 
enum {
  MOD_MESHCACHE_INTERP_NONE = 0,
  MOD_MESHCACHE_INTERP_LINEAR = 1,
  /*  MOD_MESHCACHE_INTERP_CARDINAL  = 2, */
};
 
enum {
  MOD_MESHCACHE_TIME_FRAME = 0,
  MOD_MESHCACHE_TIME_SECONDS = 1,
  MOD_MESHCACHE_TIME_FACTOR = 2,
};
 
enum {
  MOD_MESHCACHE_PLAY_CFEA = 0,
  MOD_MESHCACHE_PLAY_EVAL = 1,
};
 
typedef struct LaplacianDeformModifierData {
  ModifierData modifier;
  char anchor_grp_name[64];
  int verts_num, repeat;
  float *vertexco;
  void *cache_system;
  short flag;
  char _pad[6];
 
} LaplacianDeformModifierData;
 
enum {
  MOD_LAPLACIANDEFORM_BIND = 1 << 0,
  MOD_LAPLACIANDEFORM_INVERT_VGROUP = 1 << 1,
};
 
typedef struct WireframeModifierData {
  ModifierData modifier;
  char defgrp_name[64];
  float offset;
  float offset_fac;
  float offset_fac_vg;
  float crease_weight;
  short flag, mat_ofs;
  char _pad[4];
} WireframeModifierData;
 
enum {
  MOD_WIREFRAME_INVERT_VGROUP = (1 << 0),
  MOD_WIREFRAME_REPLACE = (1 << 1),
  MOD_WIREFRAME_BOUNDARY = (1 << 2),
  MOD_WIREFRAME_OFS_EVEN = (1 << 3),
  MOD_WIREFRAME_OFS_RELATIVE = (1 << 4),
  MOD_WIREFRAME_CREASE = (1 << 5),
};
 
typedef struct WeldModifierData {
  ModifierData modifier;
 
  /* The limit below which to merge vertices. */
  float merge_dist;
  char defgrp_name[64];
 
  char mode;
  char flag;
  char _pad[2];
} WeldModifierData;
 
enum {
  MOD_WELD_INVERT_VGROUP = (1 << 0),
  MOD_WELD_LOOSE_EDGES = (1 << 1),
};
 
enum {
  MOD_WELD_MODE_ALL = 0,
  MOD_WELD_MODE_CONNECTED = 1,
};
 
typedef struct DataTransferModifierData {
  ModifierData modifier;
 
  struct Object *ob_source;
 
  int data_types;
 
  /* See MREMAP_MODE_ enum in BKE_mesh_mapping.hh */
  int vmap_mode;
  int emap_mode;
  int lmap_mode;
  int pmap_mode;
 
  float map_max_distance;
  float map_ray_radius;
  float islands_precision;
 
  char _pad1[4];
 
  int layers_select_src[5];
  int layers_select_dst[5];
 
  int mix_mode;
  float mix_factor;
  char defgrp_name[64];
 
  int flags;
  void *_pad2;
} DataTransferModifierData;
 
enum {
  MOD_DATATRANSFER_OBSRC_TRANSFORM = 1 << 0,
  MOD_DATATRANSFER_MAP_MAXDIST = 1 << 1,
  MOD_DATATRANSFER_INVERT_VGROUP = 1 << 2,
 
  /* Only for UI really. */
  MOD_DATATRANSFER_USE_VERT = 1 << 28,
  MOD_DATATRANSFER_USE_EDGE = 1 << 29,
  MOD_DATATRANSFER_USE_LOOP = 1 << 30,
  MOD_DATATRANSFER_USE_POLY = 1u << 31,
};
 
typedef struct NormalEditModifierData {
  ModifierData modifier;
  char defgrp_name[64];
  struct Object *target;
  short mode;
  short flag;
  short mix_mode;
  char _pad[2];
  float mix_factor;
  float mix_limit;
  float offset[3];
  char _pad0[4];
  void *_pad1;
} NormalEditModifierData;
 
enum {
  MOD_NORMALEDIT_MODE_RADIAL = 0,
  MOD_NORMALEDIT_MODE_DIRECTIONAL = 1,
};
 
enum {
  MOD_NORMALEDIT_INVERT_VGROUP = (1 << 0),
  MOD_NORMALEDIT_USE_DIRECTION_PARALLEL = (1 << 1),
  MOD_NORMALEDIT_NO_POLYNORS_FIX = (1 << 2),
};
 
enum {
  MOD_NORMALEDIT_MIX_COPY = 0,
  MOD_NORMALEDIT_MIX_ADD = 1,
  MOD_NORMALEDIT_MIX_SUB = 2,
  MOD_NORMALEDIT_MIX_MUL = 3,
};
 
typedef struct MeshSeqCacheModifierData {
  ModifierData modifier;
 
  struct CacheFile *cache_file;
  char object_path[1024];
 
  char read_flag;
  char _pad[3];
 
  float velocity_scale;
 
  /* Runtime. */
  struct CacheReader *reader;
  char reader_object_path[1024];
} MeshSeqCacheModifierData;
 
enum {
  MOD_MESHSEQ_READ_VERT = (1 << 0),
  MOD_MESHSEQ_READ_POLY = (1 << 1),
  MOD_MESHSEQ_READ_UV = (1 << 2),
  MOD_MESHSEQ_READ_COLOR = (1 << 3),
 
  /* Allow interpolation of mesh vertex positions. There is a heuristic to avoid interpolation when
   * the mesh topology changes, but this heuristic sometimes fails. In these cases, users can
   * disable interpolation with this flag. */
  MOD_MESHSEQ_INTERPOLATE_VERTICES = (1 << 4),
 
  /* Read animated custom attributes from point cache files. */
  MOD_MESHSEQ_READ_ATTRIBUTES = (1 << 5),
};
 
typedef struct SDefBind {
  unsigned int *vert_inds;
  unsigned int verts_num;
  int mode;
  float *vert_weights;
  float normal_dist;
  float influence;
} SDefBind;
 
typedef struct SDefVert {
  SDefBind *binds;
  unsigned int binds_num;
  unsigned int vertex_idx;
} SDefVert;
 
typedef struct SurfaceDeformModifierData {
  ModifierData modifier;
 
  struct Depsgraph *depsgraph;
  struct Object *target;
  SDefVert *verts;
  void *_pad1;
  float falloff;
  /* Number of vertices on the deformed mesh upon the bind process. */
  unsigned int mesh_verts_num;
  /* Number of vertices in the `verts` array of this modifier. */
  unsigned int bind_verts_num;
  /* Number of vertices and polygons on the target mesh upon bind process. */
  unsigned int target_verts_num, target_polys_num;
  int flags;
  float mat[4][4];
  float strength;
  char defgrp_name[64];
  int _pad2;
} SurfaceDeformModifierData;
 
enum {
  /* This indicates "do bind on next modifier evaluation" as well as "is bound". */
  MOD_SDEF_BIND = (1 << 0),
  MOD_SDEF_INVERT_VGROUP = (1 << 1),
  /* Only store bind data for nonzero vgroup weights at the time of bind. */
  MOD_SDEF_SPARSE_BIND = (1 << 2),
};
 
enum {
  MOD_SDEF_MODE_CORNER_TRIS = 0,
  MOD_SDEF_MODE_NGONS = 1,
  MOD_SDEF_MODE_CENTROID = 2,
};
 
typedef struct WeightedNormalModifierData {
  ModifierData modifier;
 
  char defgrp_name[64];
  char mode, flag;
  short weight;
  float thresh;
} WeightedNormalModifierData;
 
/* Name/id of the generic PROP_INT cdlayer storing face weights. */
#define MOD_WEIGHTEDNORMALS_FACEWEIGHT_CDLAYER_ID "__mod_weightednormals_faceweight"
 
enum {
  MOD_WEIGHTEDNORMAL_MODE_FACE = 0,
  MOD_WEIGHTEDNORMAL_MODE_ANGLE = 1,
  MOD_WEIGHTEDNORMAL_MODE_FACE_ANGLE = 2,
};
 
enum {
  MOD_WEIGHTEDNORMAL_KEEP_SHARP = (1 << 0),
  MOD_WEIGHTEDNORMAL_INVERT_VGROUP = (1 << 1),
  MOD_WEIGHTEDNORMAL_FACE_INFLUENCE = (1 << 2),
};
 
#define MOD_MESHSEQ_READ_ALL \
  (MOD_MESHSEQ_READ_VERT | MOD_MESHSEQ_READ_POLY | MOD_MESHSEQ_READ_UV | MOD_MESHSEQ_READ_COLOR)
 
typedef struct NodesModifierSettings {
  /* This stores data that is passed into the node group. */
  struct IDProperty *properties;
} NodesModifierSettings;
 
typedef struct NodesModifierDataBlock {
  char *id_name;
  char *lib_name;
  struct ID *id;
  int id_type;
  char _pad[4];
} NodesModifierDataBlock;
 
typedef struct NodesModifierBakeFile {
  const char *name;
  /* May be null if the file is empty. */
  PackedFile *packed_file;
 
#ifdef __cplusplus
  blender::Span<std::byte> data() const
  {
    if (this->packed_file) {
      return blender::Span{static_cast<const std::byte *>(this->packed_file->data),
                           this->packed_file->size};
    }
    return {};
  }
#endif
} NodesModifierBakeFile;
 
typedef struct NodesModifierPackedBake {
  int meta_files_num;
  int blob_files_num;
  NodesModifierBakeFile *meta_files;
  NodesModifierBakeFile *blob_files;
} NodesModifierPackedBake;
 
typedef struct NodesModifierBake {
  int id;
  uint32_t flag;
  uint8_t bake_mode;
  int8_t bake_target;
  char _pad[6];
  char *directory;
  int frame_start;
  int frame_end;
 
  int data_blocks_num;
  int active_data_block;
  NodesModifierDataBlock *data_blocks;
  NodesModifierPackedBake *packed;
 
  void *_pad2;
  int64_t bake_size;
} NodesModifierBake;
 
typedef struct NodesModifierPanel {
  int id;
  uint32_t flag;
} NodesModifierPanel;
 
typedef enum NodesModifierPanelFlag {
  NODES_MODIFIER_PANEL_OPEN = 1 << 0,
} NodesModifierPanelFlag;
 
typedef enum NodesModifierBakeFlag {
  NODES_MODIFIER_BAKE_CUSTOM_SIMULATION_FRAME_RANGE = 1 << 0,
  NODES_MODIFIER_BAKE_CUSTOM_PATH = 1 << 1,
} NodesModifierBakeFlag;
 
typedef enum NodesModifierBakeTarget {
  NODES_MODIFIER_BAKE_TARGET_INHERIT = 0,
  NODES_MODIFIER_BAKE_TARGET_PACKED = 1,
  NODES_MODIFIER_BAKE_TARGET_DISK = 2,
} NodesModifierBakeTarget;
 
typedef enum NodesModifierBakeMode {
  NODES_MODIFIER_BAKE_MODE_ANIMATION = 0,
  NODES_MODIFIER_BAKE_MODE_STILL = 1,
} NodesModifierBakeMode;
 
typedef enum GeometryNodesModifierPanel {
  NODES_MODIFIER_PANEL_OUTPUT_ATTRIBUTES = 0,
  NODES_MODIFIER_PANEL_MANAGE = 1,
  NODES_MODIFIER_PANEL_BAKE = 2,
  NODES_MODIFIER_PANEL_NAMED_ATTRIBUTES = 3,
  NODES_MODIFIER_PANEL_BAKE_DATA_BLOCKS = 4,
  NODES_MODIFIER_PANEL_WARNINGS = 5,
} GeometryNodesModifierPanel;
 
typedef struct NodesModifierData {
  ModifierData modifier;
  struct bNodeTree *node_group;
  struct NodesModifierSettings settings;
  char *bake_directory;
  int8_t flag;
  int8_t bake_target;
 
  char _pad[2];
  int bakes_num;
  NodesModifierBake *bakes;
 
  char _pad2[4];
  int panels_num;
  NodesModifierPanel *panels;
 
  NodesModifierRuntimeHandle *runtime;
 
#ifdef __cplusplus
  NodesModifierBake *find_bake(int id);
  const NodesModifierBake *find_bake(int id) const;
#endif
} NodesModifierData;
 
typedef enum NodesModifierFlag {
  NODES_MODIFIER_HIDE_DATABLOCK_SELECTOR = (1 << 0),
} NodesModifierFlag;
 
typedef struct MeshToVolumeModifierData {
  ModifierData modifier;
 
  struct Object *object;
 
  int resolution_mode;
  float voxel_size;
  int voxel_amount;
 
  float interior_band_width;
 
  float density;
  char _pad2[4];
  void *_pad3;
} MeshToVolumeModifierData;
 
typedef enum MeshToVolumeModifierResolutionMode {
  MESH_TO_VOLUME_RESOLUTION_MODE_VOXEL_AMOUNT = 0,
  MESH_TO_VOLUME_RESOLUTION_MODE_VOXEL_SIZE = 1,
} MeshToVolumeModifierResolutionMode;
 
typedef struct VolumeDisplaceModifierData {
  ModifierData modifier;
 
  struct Tex *texture;
  struct Object *texture_map_object;
  int texture_map_mode;
 
  float strength;
  float texture_mid_level[3];
  float texture_sample_radius;
} VolumeDisplaceModifierData;
 
enum {
  MOD_VOLUME_DISPLACE_MAP_LOCAL = 0,
  MOD_VOLUME_DISPLACE_MAP_GLOBAL = 1,
  MOD_VOLUME_DISPLACE_MAP_OBJECT = 2,
};
 
typedef struct VolumeToMeshModifierData {
  ModifierData modifier;
 
  struct Object *object;
 
  float threshold;
  float adaptivity;
 
  uint32_t flag;
 
  int resolution_mode;
  float voxel_size;
  int voxel_amount;
 
  char grid_name[64];
  void *_pad1;
} VolumeToMeshModifierData;
 
typedef enum VolumeToMeshResolutionMode {
  VOLUME_TO_MESH_RESOLUTION_MODE_GRID = 0,
  VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_AMOUNT = 1,
  VOLUME_TO_MESH_RESOLUTION_MODE_VOXEL_SIZE = 2,
} VolumeToMeshResolutionMode;
 
typedef enum VolumeToMeshFlag {
  VOLUME_TO_MESH_USE_SMOOTH_SHADE = 1 << 0,
} VolumeToMeshFlag;
 
typedef struct GreasePencilModifierInfluenceData {
  int flag;
  char _pad1[4];
  char layer_name[64];
  struct Material *material;
  int layer_pass;
  int material_pass;
  char vertex_group_name[64];
  struct CurveMapping *custom_curve;
  void *_pad2;
} GreasePencilModifierInfluenceData;
 
typedef enum GreasePencilModifierInfluenceFlag {
  GREASE_PENCIL_INFLUENCE_INVERT_LAYER_FILTER = (1 << 0),
  GREASE_PENCIL_INFLUENCE_USE_LAYER_PASS_FILTER = (1 << 1),
  GREASE_PENCIL_INFLUENCE_INVERT_LAYER_PASS_FILTER = (1 << 2),
  GREASE_PENCIL_INFLUENCE_INVERT_MATERIAL_FILTER = (1 << 3),
  GREASE_PENCIL_INFLUENCE_USE_MATERIAL_PASS_FILTER = (1 << 4),
  GREASE_PENCIL_INFLUENCE_INVERT_MATERIAL_PASS_FILTER = (1 << 5),
  GREASE_PENCIL_INFLUENCE_INVERT_VERTEX_GROUP = (1 << 6),
  GREASE_PENCIL_INFLUENCE_USE_CUSTOM_CURVE = (1 << 7),
} GreasePencilModifierInfluenceFlag;
 
typedef struct GreasePencilOpacityModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int flag;
  char color_mode;
  char _pad1[3];
  float color_factor;
  float hardness_factor;
  void *_pad2;
} GreasePencilOpacityModifierData;
 
typedef enum GreasePencilModifierColorMode {
  MOD_GREASE_PENCIL_COLOR_STROKE = 0,
  MOD_GREASE_PENCIL_COLOR_FILL = 1,
  MOD_GREASE_PENCIL_COLOR_BOTH = 2,
  MOD_GREASE_PENCIL_COLOR_HARDNESS = 3,
} GreasePencilModifierColorMode;
 
typedef enum GreasePencilOpacityModifierFlag {
  /* Use vertex group as opacity factors instead of influence. */
  MOD_GREASE_PENCIL_OPACITY_USE_WEIGHT_AS_FACTOR = (1 << 0),
  /* Set the opacity for every point in a stroke, otherwise multiply existing opacity. */
  MOD_GREASE_PENCIL_OPACITY_USE_UNIFORM_OPACITY = (1 << 1),
} GreasePencilOpacityModifierFlag;
 
typedef struct GreasePencilSubdivModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int type;
  int level;
 
  char _pad[8];
  void *_pad1;
} GreasePencilSubdivModifierData;
 
typedef enum GreasePencilSubdivideType {
  MOD_GREASE_PENCIL_SUBDIV_CATMULL = 0,
  MOD_GREASE_PENCIL_SUBDIV_SIMPLE = 1,
} GreasePencilSubdivideType;
 
typedef struct GreasePencilColorModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  char color_mode;
  char _pad1[3];
  float hsv[3];
  void *_pad2;
} GreasePencilColorModifierData;
 
typedef struct GreasePencilTintModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  short flag;
  char color_mode;
  char tint_mode;
  float factor;
  float radius;
  float color[3];
  struct Object *object;
  struct ColorBand *color_ramp;
  void *_pad;
} GreasePencilTintModifierData;
 
typedef enum GreasePencilTintModifierMode {
  MOD_GREASE_PENCIL_TINT_UNIFORM = 0,
  MOD_GREASE_PENCIL_TINT_GRADIENT = 1,
} GreasePencilTintModifierMode;
 
typedef enum GreasePencilTintModifierFlag {
  /* Use vertex group as factors instead of influence. */
  MOD_GREASE_PENCIL_TINT_USE_WEIGHT_AS_FACTOR = (1 << 0),
} GreasePencilTintModifierFlag;
 
/* Enum definitions for length modifier stays in the old DNA for the moment. */
typedef struct GreasePencilSmoothModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int flag;
  float factor;
  int step;
  char _pad[4];
  void *_pad1;
} GreasePencilSmoothModifierData;
 
typedef enum eGreasePencilSmooth_Flag {
  MOD_GREASE_PENCIL_SMOOTH_MOD_LOCATION = (1 << 0),
  MOD_GREASE_PENCIL_SMOOTH_MOD_STRENGTH = (1 << 1),
  MOD_GREASE_PENCIL_SMOOTH_MOD_THICKNESS = (1 << 2),
  MOD_GREASE_PENCIL_SMOOTH_MOD_UV = (1 << 3),
  MOD_GREASE_PENCIL_SMOOTH_KEEP_SHAPE = (1 << 4),
  MOD_GREASE_PENCIL_SMOOTH_SMOOTH_ENDS = (1 << 5),
} eGreasePencilSmooth_Flag;
 
typedef struct GreasePencilOffsetModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int flag;
  int offset_mode;
  float loc[3];
  float rot[3];
  float scale[3];
  float stroke_loc[3];
  float stroke_rot[3];
  float stroke_scale[3];
  int seed;
  int stroke_step;
  int stroke_start_offset;
  char _pad1[4];
  void *_pad2;
} GreasePencilOffsetModifierData;
 
typedef enum GreasePencilOffsetModifierFlag {
  MOD_GREASE_PENCIL_OFFSET_UNIFORM_RANDOM_SCALE = (1 << 0),
} GreasePencilOffsetModifierFlag;
 
typedef enum GreasePencilOffsetModifierMode {
  MOD_GREASE_PENCIL_OFFSET_RANDOM = 0,
  MOD_GREASE_PENCIL_OFFSET_LAYER = 1,
  MOD_GREASE_PENCIL_OFFSET_MATERIAL = 2,
  MOD_GREASE_PENCIL_OFFSET_STROKE = 3,
} GreasePencilOffsetModifierMode;
 
typedef struct GreasePencilNoiseModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  int flag;
 
  float factor;
  float factor_strength;
  float factor_thickness;
  float factor_uvs;
  float noise_scale;
  float noise_offset;
  short noise_mode;
  char _pad[2];
  int step;
  int seed;
 
  void *_pad1;
} GreasePencilNoiseModifierData;
 
typedef struct GreasePencilMirrorModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  struct Object *object;
  int flag;
  char _pad[4];
} GreasePencilMirrorModifierData;
 
typedef enum GreasePencilMirrorModifierFlag {
  MOD_GREASE_PENCIL_MIRROR_AXIS_X = (1 << 0),
  MOD_GREASE_PENCIL_MIRROR_AXIS_Y = (1 << 1),
  MOD_GREASE_PENCIL_MIRROR_AXIS_Z = (1 << 2),
} GreasePencilMirrorModifierFlag;
 
typedef struct GreasePencilThickModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int flag;
  float thickness_fac;
  float thickness;
  char _pad[4];
  void *_pad1;
} GreasePencilThickModifierData;
 
typedef enum GreasePencilThicknessModifierFlag {
  MOD_GREASE_PENCIL_THICK_NORMALIZE = (1 << 0),
  MOD_GREASE_PENCIL_THICK_WEIGHT_FACTOR = (1 << 1),
} GreasePencilThicknessModifierFlag;
 
typedef struct GreasePencilLatticeModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  struct Object *object;
  float strength;
  char _pad[4];
} GreasePencilLatticeModifierData;
 
typedef struct GreasePencilDashModifierSegment {
  char name[64];
  int dash;
  int gap;
  float radius;
  float opacity;
  int mat_nr;
  int flag;
} GreasePencilDashModifierSegment;
 
typedef struct GreasePencilDashModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  GreasePencilDashModifierSegment *segments_array;
  int segments_num;
  int segment_active_index;
 
  int dash_offset;
  char _pad[4];
 
#ifdef __cplusplus
  blender::Span<GreasePencilDashModifierSegment> segments() const;
  blender::MutableSpan<GreasePencilDashModifierSegment> segments();
#endif
} GreasePencilDashModifierData;
 
typedef enum GreasePencilDashModifierFlag {
  MOD_GREASE_PENCIL_DASH_USE_CYCLIC = (1 << 0),
} GreasePencilDashModifierFlag;
 
typedef struct GreasePencilMultiModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  /* #GreasePencilMultiplyModifierFlag */
  int flag;
 
  int duplications;
  float distance;
  /* -1:inner 0:middle 1:outer */
  float offset;
 
  float fading_center;
  float fading_thickness;
  float fading_opacity;
 
  int _pad0;
 
  void *_pad;
} GreasePencilMultiModifierData;
 
typedef enum GreasePencilMultiplyModifierFlag {
  /* GP_MULTIPLY_ENABLE_ANGLE_SPLITTING = (1 << 1),  Deprecated. */
  MOD_GREASE_PENCIL_MULTIPLY_ENABLE_FADING = (1 << 2),
} GreasePencilMultiplyModifierFlag;
 
typedef struct GreasePencilLengthModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int flag;
  float start_fac, end_fac;
  float rand_start_fac, rand_end_fac, rand_offset;
  float overshoot_fac;
  int seed;
  int step;
  int mode;
  char _pad[4];
  /* Curvature parameters. */
  float point_density;
  float segment_influence;
  float max_angle;
 
  void *_pad1;
} GreasePencilLengthModifierData;
 
typedef struct GreasePencilWeightAngleModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int flag;
  float min_weight;
  int16_t axis;
  int16_t space;
  float angle;
  char target_vgname[64];
 
  void *_pad;
} GreasePencilWeightAngleModifierData;
 
typedef enum GreasePencilWeightAngleModifierFlag {
  MOD_GREASE_PENCIL_WEIGHT_ANGLE_MULTIPLY_DATA = (1 << 5),
  MOD_GREASE_PENCIL_WEIGHT_ANGLE_INVERT_OUTPUT = (1 << 6),
} GreasePencilWeightAngleModifierFlag;
 
typedef enum GreasePencilWeightAngleModifierSpace {
  MOD_GREASE_PENCIL_WEIGHT_ANGLE_SPACE_LOCAL = 0,
  MOD_GREASE_PENCIL_WEIGHT_ANGLE_SPACE_WORLD = 1,
} GreasePencilWeightAngleModifierSpace;
 
typedef struct GreasePencilArrayModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  struct Object *object;
  int count;
  int flag;
  float offset[3];
  float shift[3];
 
  float rnd_offset[3];
  float rnd_rot[3];
  float rnd_scale[3];
 
  char _pad[4];
  int seed;
 
  /* Replacement material index. */
  int mat_rpl;
} GreasePencilArrayModifierData;
 
typedef enum GreasePencilArrayModifierFlag {
  MOD_GREASE_PENCIL_ARRAY_USE_OFFSET = (1 << 7),
  MOD_GREASE_PENCIL_ARRAY_USE_RELATIVE = (1 << 8),
  MOD_GREASE_PENCIL_ARRAY_USE_OB_OFFSET = (1 << 9),
  MOD_GREASE_PENCIL_ARRAY_UNIFORM_RANDOM_SCALE = (1 << 10),
} GreasePencilArrayModifierFlag;
 
typedef struct GreasePencilWeightProximityModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  /* #GreasePencilWeightProximityFlag. */
  int flag;
  char target_vgname[64];
  float min_weight;
 
  float dist_start;
  float dist_end;
 
  struct Object *object;
} GreasePencilWeightProximityModifierData;
 
typedef enum GreasePencilWeightProximityFlag {
  MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_INVERT_OUTPUT = (1 << 0),
  MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_MULTIPLY_DATA = (1 << 1),
} GreasePencilWeightProximityFlag;
 
typedef struct GreasePencilHookModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  struct Object *object;
  char subtarget[64];
  char _pad[4];
 
  int flag;
  char falloff_type;
  char _pad1[3];
  float parentinv[4][4];
  float cent[3];
  float falloff;
  float force;
} GreasePencilHookModifierData;
 
typedef enum GreasePencilHookFlag {
  MOD_GREASE_PENCIL_HOOK_UNIFORM_SPACE = (1 << 0),
} GreasePencilHookFlag;
 
typedef enum GreasePencilHookFalloff {
  MOD_GREASE_PENCIL_HOOK_Falloff_None = 0,
  MOD_GREASE_PENCIL_HOOK_Falloff_Curve = 1,
  MOD_GREASE_PENCIL_HOOK_Falloff_Sharp = 2,
  MOD_GREASE_PENCIL_HOOK_Falloff_Smooth = 3,
  MOD_GREASE_PENCIL_HOOK_Falloff_Root = 4,
  MOD_GREASE_PENCIL_HOOK_Falloff_Linear = 5,
  MOD_GREASE_PENCIL_HOOK_Falloff_Const = 6,
  MOD_GREASE_PENCIL_HOOK_Falloff_Sphere = 7,
  MOD_GREASE_PENCIL_HOOK_Falloff_InvSquare = 8,
} GreasePencilHookFalloff;
 
/* This enum is for modifier internal state only. */
typedef enum eGreasePencilLineartFlags {
  /* These two moved to #eLineartMainFlags to keep consistent with flag variable purpose. */
  /* LINEART_GPENCIL_INVERT_SOURCE_VGROUP = (1 << 0), */
  /* LINEART_GPENCIL_MATCH_OUTPUT_VGROUP = (1 << 1), */
  LINEART_GPENCIL_BINARY_WEIGHTS = (1
                                    << 2) /* Deprecated, this is removed for lack of use case. */,
  LINEART_GPENCIL_IS_BAKED = (1 << 3),
  LINEART_GPENCIL_USE_CACHE = (1 << 4),
  LINEART_GPENCIL_OFFSET_TOWARDS_CUSTOM_CAMERA = (1 << 5),
  LINEART_GPENCIL_INVERT_COLLECTION = (1 << 6),
  LINEART_GPENCIL_INVERT_SILHOUETTE_FILTER = (1 << 7),
} eGreasePencilLineartFlags;
 
typedef enum GreasePencilLineartModifierSource {
  LINEART_SOURCE_COLLECTION = 0,
  LINEART_SOURCE_OBJECT = 1,
  LINEART_SOURCE_SCENE = 2,
} GreasePencilLineartModifierSource;
 
typedef enum GreasePencilLineartModifierShadowFilter {
  /* These options need to be ordered in this way because those latter options requires line art to
   * run a few extra stages. Having those values set up this way will allow
   * #BKE_gpencil_get_lineart_modifier_limits() to find out maximum stages needed in multiple
   * cached line art modifiers. */
  LINEART_SHADOW_FILTER_NONE = 0,
  LINEART_SHADOW_FILTER_ILLUMINATED = 1,
  LINEART_SHADOW_FILTER_SHADED = 2,
  LINEART_SHADOW_FILTER_ILLUMINATED_ENCLOSED_SHAPES = 3,
} GreasePencilLineartModifierShadowFilter;
 
/* This enum is for modifier internal state only. */
typedef enum eLineArtGPencilModifierFlags {
  /* These two moved to #eLineartMainFlags to keep consistent with flag variable purpose. */
  /* MOD_LINEART_INVERT_SOURCE_VGROUP = (1 << 0), */
  /* MOD_LINEART_MATCH_OUTPUT_VGROUP = (1 << 1), */
  MOD_LINEART_BINARY_WEIGHTS = (1 << 2) /* Deprecated, this is removed for lack of use case. */,
  MOD_LINEART_IS_BAKED = (1 << 3),
  MOD_LINEART_USE_CACHE = (1 << 4),
  MOD_LINEART_OFFSET_TOWARDS_CUSTOM_CAMERA = (1 << 5),
  MOD_LINEART_INVERT_COLLECTION = (1 << 6),
  MOD_LINEART_INVERT_SILHOUETTE_FILTER = (1 << 7),
} eLineArtGPencilModifierFlags;
 
typedef enum GreasePencilLineartMaskSwitches {
  MOD_LINEART_MATERIAL_MASK_ENABLE = (1 << 0),
  MOD_LINEART_MATERIAL_MASK_MATCH = (1 << 1),
  MOD_LINEART_INTERSECTION_MATCH = (1 << 2),
} GreasePencilLineartMaskSwitches;
 
typedef enum eGreasePencilLineartMaskSwitches {
  LINEART_GPENCIL_MATERIAL_MASK_ENABLE = (1 << 0),
  LINEART_GPENCIL_MATERIAL_MASK_MATCH = (1 << 1),
  LINEART_GPENCIL_INTERSECTION_MATCH = (1 << 2),
} eGreasePencilLineartMaskSwitches;
 
typedef enum eGreasePencilLineartSilhouetteFilter {
  LINEART_SILHOUETTE_FILTER_NONE = 0,
  LINEART_SILHOUETTE_FILTER_GROUP = (1 << 0),
  LINEART_SILHOUETTE_FILTER_INDIVIDUAL = (1 << 1),
} eGreasePencilLineartSilhouetteFilter;
 
struct LineartCache;
 
typedef struct GreasePencilLineartModifierData {
  ModifierData modifier;
 
  uint16_t edge_types; /* line type enable flags, bits in eLineartEdgeFlag */
 
  char source_type;
 
  char use_multiple_levels;
  short level_start;
  short level_end;
 
  struct Object *source_camera;
  struct Object *light_contour_object;
 
  struct Object *source_object;
  struct Collection *source_collection;
 
  struct Material *target_material;
  char target_layer[64];
 
  char source_vertex_group[64];
  char vgname[64];
 
  /* Camera focal length is divided by (1 + over-scan), before calculation, which give a wider FOV,
   * this doesn't change coordinates range internally (-1, 1), but makes the calculated frame
   * bigger than actual output. This is for the easier shifting calculation. A value of 0.5 means
   * the "internal" focal length become 2/3 of the actual camera. */
  float overscan;
 
  /* Values for point light and directional (sun) light. */
  /* For point light, fov always gonna be 120 deg horizontal, with 3 "cameras" covering 360 deg. */
  float shadow_camera_fov;
  float shadow_camera_size;
  float shadow_camera_near;
  float shadow_camera_far;
 
  float opacity;
  short thickness;
 
  unsigned char mask_switches; /* #eGreasePencilLineartMaskSwitches */
  unsigned char material_mask_bits;
  unsigned char intersection_mask;
 
  unsigned char shadow_selection;
  unsigned char silhouette_selection;
  char _pad[1];
 
  float crease_threshold;
 
  float angle_splitting_threshold;
 
  float chain_smooth_tolerance;
 
  /* CPU mode */
  float chaining_image_threshold;
 
  /* eLineartMainFlags, for one time calculation. */
  int calculation_flags;
 
  /* #eGreasePencilLineartFlags, modifier internal state. */
  int flags;
 
  /* Move strokes towards camera to avoid clipping while preserve depth for the viewport. */
  float stroke_depth_offset;
 
  /* Runtime data. */
 
  /* Because we can potentially only compute features lines once per modifier stack (Use Cache), we
   * need to have these override values to ensure that we have the data we need is computed and
   * stored in the cache. */
  char level_start_override;
  char level_end_override;
  short edge_types_override;
  char shadow_selection_override;
  char shadow_use_silhouette_override;
 
  char _pad2[6];
 
  /* Shared cache will only be on the first line art modifier in the stack, and will exist until
   * the end of modifier stack evaluation. If the object has line art modifiers, this variable is
   * then initialized in #grease_pencil_evaluate_modifiers(). */
  struct LineartCache *shared_cache;
 
  /* Cache for single execution of line art, when LINEART_GPENCIL_USE_CACHE is enabled, this is a
   * reference to first_lineart->shared_cache, otherwise it holds its own cache.  */
  struct LineartCache *cache;
 
  /* Keep a pointer to the render buffer so we can call destroy from #ModifierData. */
  struct LineartData *la_data_ptr;
 
  /* Points to a `LineartModifierRuntime`, which includes the object dependency list. */
  void *runtime;
} GreasePencilLineartModifierData;
 
typedef struct GreasePencilArmatureModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  struct Object *object;
  short deformflag;
  char _pad[6];
} GreasePencilArmatureModifierData;
 
typedef struct GreasePencilTimeModifierSegment {
  char name[64];
  int segment_start;
  int segment_end;
  int segment_mode;
  int segment_repeat;
} GreasePencilTimeModifierSegment;
 
typedef struct GreasePencilTimeModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  int flag;
  int offset;
  float frame_scale;
  int mode;
  int sfra, efra;
 
  GreasePencilTimeModifierSegment *segments_array;
  int segments_num;
  int segment_active_index;
 
#ifdef __cplusplus
  blender::Span<GreasePencilTimeModifierSegment> segments() const;
  blender::MutableSpan<GreasePencilTimeModifierSegment> segments();
#endif
} GreasePencilTimeModifierData;
 
typedef enum GreasePencilTimeModifierFlag {
  MOD_GREASE_PENCIL_TIME_KEEP_LOOP = (1 << 0),
  MOD_GREASE_PENCIL_TIME_CUSTOM_RANGE = (1 << 1),
} GreasePencilTimeModifierFlag;
 
typedef enum GreasePencilTimeModifierMode {
  MOD_GREASE_PENCIL_TIME_MODE_NORMAL = 0,
  MOD_GREASE_PENCIL_TIME_MODE_REVERSE = 1,
  MOD_GREASE_PENCIL_TIME_MODE_FIX = 2,
  MOD_GREASE_PENCIL_TIME_MODE_PINGPONG = 3,
  MOD_GREASE_PENCIL_TIME_MODE_CHAIN = 4,
} GreasePencilTimeModifierMode;
 
typedef enum GreasePencilTimeModifierSegmentMode {
  MOD_GREASE_PENCIL_TIME_SEG_MODE_NORMAL = 0,
  MOD_GREASE_PENCIL_TIME_SEG_MODE_REVERSE = 1,
  MOD_GREASE_PENCIL_TIME_SEG_MODE_PINGPONG = 2,
} GreasePencilTimeModifierSegmentMode;
 
typedef struct GreasePencilEnvelopeModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  /* #GreasePencilEnvelopeModifierMode. */
  int mode;
  int mat_nr;
  float thickness;
  float strength;
  int skip;
  /* Length of the envelope effect. */
  int spread;
} GreasePencilEnvelopeModifierData;
 
/* Texture->mode */
typedef enum GreasePencilEnvelopeModifierMode {
  MOD_GREASE_PENCIL_ENVELOPE_DEFORM = 0,
  MOD_GREASE_PENCIL_ENVELOPE_SEGMENTS = 1,
  MOD_GREASE_PENCIL_ENVELOPE_FILLS = 2,
} GreasePencilEnvelopeModifierMode;
 
typedef struct GreasePencilOutlineModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  struct Object *object;
  int flag;
  int thickness;
  float sample_length;
  int subdiv;
  struct Material *outline_material;
} GreasePencilOutlineModifierData;
 
typedef enum GreasePencilOutlineModifierFlag {
  MOD_GREASE_PENCIL_OUTLINE_KEEP_SHAPE = (1 << 0),
} GreasePencilOutlineModifierFlag;
 
typedef struct GreasePencilShrinkwrapModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  struct Object *target;
  struct Object *aux_target;
  float keep_dist;
  short shrink_type;
  char shrink_opts;
  char shrink_mode;
  float proj_limit;
  char proj_axis;
 
  char subsurf_levels;
  char _pad[2];
  float smooth_factor;
  int smooth_step;
 
  struct ShrinkwrapTreeData *cache_data;
} GreasePencilShrinkwrapModifierData;
 
typedef struct GreasePencilBuildModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  float start_frame;
  float end_frame;
 
  float start_delay;
  float length;
 
  short flag;
 
  short mode;
  short transition;
 
  short time_alignment;
 
  float speed_fac;
  float speed_maxgap;
  short time_mode;
  char _pad[6];
 
  struct Object *object;
 
  float percentage_fac;
 
  float fade_fac;
  char target_vgname[64];
  float fade_opacity_strength;
  float fade_thickness_strength;
} GreasePencilBuildModifierData;
 
typedef enum GreasePencilBuildMode {
  /* Strokes are shown one by one until all have appeared */
  MOD_GREASE_PENCIL_BUILD_MODE_SEQUENTIAL = 0,
  /* All strokes start at the same time */
  MOD_GREASE_PENCIL_BUILD_MODE_CONCURRENT = 1,
  /* Only the new strokes are built */
  MOD_GREASE_PENCIL_BUILD_MODE_ADDITIVE = 2,
} GreasePencilBuildMode;
 
typedef enum GreasePencilBuildTransition {
  /* Show in forward order */
  MOD_GREASE_PENCIL_BUILD_TRANSITION_GROW = 0,
  /* Hide in reverse order */
  MOD_GREASE_PENCIL_BUILD_TRANSITION_SHRINK = 1,
  /* Hide in forward order */
  MOD_GREASE_PENCIL_BUILD_TRANSITION_VANISH = 2,
} GreasePencilBuildTransition;
 
typedef enum GreasePencilBuildTimeAlignment {
  /* All strokes start at same time */
  MOD_GREASE_PENCIL_BUILD_TIMEALIGN_START = 0,
  /* All strokes end at same time */
  MOD_GREASE_PENCIL_BUILD_TIMEALIGN_END = 1,
 
  /* TODO: Random Offsets, Stretch-to-Fill */
} GreasePencilBuildTimeAlignment;
 
typedef enum GreasePencilBuildTimeMode {
  MOD_GREASE_PENCIL_BUILD_TIMEMODE_FRAMES = 0,
  MOD_GREASE_PENCIL_BUILD_TIMEMODE_PERCENTAGE = 1,
  MOD_GREASE_PENCIL_BUILD_TIMEMODE_DRAWSPEED = 2,
} GreasePencilBuildTimeMode;
 
typedef enum GreasePencilBuildFlag {
  /* Restrict modifier to only operating between the nominated frames */
  MOD_GREASE_PENCIL_BUILD_RESTRICT_TIME = (1 << 0),
  MOD_GREASE_PENCIL_BUILD_USE_FADING = (1 << 14),
} GreasePencilBuildFlag;
 
typedef struct GreasePencilSimplifyModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
 
  short mode;
  char _pad[4];
  short step;
  float factor;
  float length;
  float sharp_threshold;
 
  float distance;
} GreasePencilSimplifyModifierData;
 
typedef enum GreasePencilSimplifyModifierMode {
  MOD_GREASE_PENCIL_SIMPLIFY_FIXED = 0,
  MOD_GREASE_PENCIL_SIMPLIFY_ADAPTIVE = 1,
  MOD_GREASE_PENCIL_SIMPLIFY_SAMPLE = 2,
  MOD_GREASE_PENCIL_SIMPLIFY_MERGE = 3,
} GreasePencilSimplifyModifierMode;
 
typedef struct GreasePencilTextureModifierData {
  ModifierData modifier;
  GreasePencilModifierInfluenceData influence;
  /* Offset value to add to uv_fac. */
  float uv_offset;
  float uv_scale;
  float fill_rotation;
  float fill_offset[2];
  float fill_scale;
  /* Custom index for passes. */
  int layer_pass;
  /* Texture fit options. */
  short fit_method;
  short mode;
  /* Dot texture rotation. */
  float alignment_rotation;
  char _pad[4];
} GreasePencilTextureModifierData;
 
/* Texture->fit_method */
typedef enum GreasePencilTextureModifierFit {
  MOD_GREASE_PENCIL_TEXTURE_FIT_STROKE = 0,
  MOD_GREASE_PENCIL_TEXTURE_CONSTANT_LENGTH = 1,
} GreasePencilTextureModifierFit;
 
/* Texture->mode */
typedef enum GreasePencilTextureModifierMode {
  MOD_GREASE_PENCIL_TEXTURE_STROKE = 0,
  MOD_GREASE_PENCIL_TEXTURE_FILL = 1,
  MOD_GREASE_PENCIL_TEXTURE_STROKE_AND_FILL = 2,
} GreasePencilTextureModifierMode;