DNA_gpencil_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 "DNA_defs.h"
#include "DNA_listBase.h"
 
struct LatticeDeformData;
struct ShrinkwrapTreeData;
 
/* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE!
 * (ONLY ADD NEW ITEMS AT THE END)
 */
 
typedef enum GpencilModifierType {
  eGpencilModifierType_None = 0,
  eGpencilModifierType_Noise = 1,
  eGpencilModifierType_Subdiv = 2,
  eGpencilModifierType_Thick = 3,
  eGpencilModifierType_Tint = 4,
  eGpencilModifierType_Array = 5,
  eGpencilModifierType_Build = 6,
  eGpencilModifierType_Opacity = 7,
  eGpencilModifierType_Color = 8,
  eGpencilModifierType_Lattice = 9,
  eGpencilModifierType_Simplify = 10,
  eGpencilModifierType_Smooth = 11,
  eGpencilModifierType_Hook = 12,
  eGpencilModifierType_Offset = 13,
  eGpencilModifierType_Mirror = 14,
  eGpencilModifierType_Armature = 15,
  eGpencilModifierType_Time = 16,
  eGpencilModifierType_Multiply = 17,
  eGpencilModifierType_Texture = 18,
  eGpencilModifierType_Lineart = 19,
  eGpencilModifierType_Length = 20,
  eGpencilModifierType_WeightProximity = 21,
  eGpencilModifierType_Dash = 22,
  eGpencilModifierType_WeightAngle = 23,
  eGpencilModifierType_Shrinkwrap = 24,
  eGpencilModifierType_Envelope = 25,
  eGpencilModifierType_Outline = 26,
  /* Keep last. */
  NUM_GREASEPENCIL_MODIFIER_TYPES,
} GpencilModifierType;
 
typedef enum GpencilModifierMode {
  eGpencilModifierMode_Realtime = (1 << 0),
  eGpencilModifierMode_Render = (1 << 1),
  eGpencilModifierMode_Editmode = (1 << 2),
#ifdef DNA_DEPRECATED_ALLOW
  eGpencilModifierMode_Expanded_DEPRECATED = (1 << 3),
#endif
  eGpencilModifierMode_Virtual = (1 << 4),
} GpencilModifierMode;
 
typedef enum {
  /* This modifier has been inserted in local override, and hence can be fully edited. */
  eGpencilModifierFlag_OverrideLibrary_Local = (1 << 0),
} GpencilModifierFlag;
 
typedef struct GpencilModifierData {
  struct GpencilModifierData *next, *prev;
 
  int type, mode;
  char _pad0[4];
  short flag;
  /* An "expand" bit for each of the modifier's (sub)panels (uiPanelDataExpansion). */
  short ui_expand_flag;
  char name[64];
 
  char *error;
} GpencilModifierData;
 
typedef struct NoiseGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  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 layer_pass;
  int seed;
  struct CurveMapping *curve_intensity;
} NoiseGpencilModifierData;
 
typedef enum eNoiseGpencil_Flag {
  GP_NOISE_USE_RANDOM = (1 << 0),
  GP_NOISE_MOD_LOCATION = (1 << 1),  /* Deprecated (only for versioning). */
  GP_NOISE_MOD_STRENGTH = (1 << 2),  /* Deprecated (only for versioning). */
  GP_NOISE_MOD_THICKNESS = (1 << 3), /* Deprecated (only for versioning). */
  GP_NOISE_FULL_STROKE = (1 << 4),
  GP_NOISE_CUSTOM_CURVE = (1 << 5),
  GP_NOISE_INVERT_LAYER = (1 << 6),
  GP_NOISE_INVERT_PASS = (1 << 7),
  GP_NOISE_INVERT_VGROUP = (1 << 8),
  GP_NOISE_MOD_UV = (1 << 9), /* Deprecated (only for versioning). */
  GP_NOISE_INVERT_LAYERPASS = (1 << 10),
  GP_NOISE_INVERT_MATERIAL = (1 << 11),
} eNoiseGpencil_Flag;
 
typedef enum eNoiseRandomGpencil_Mode {
  GP_NOISE_RANDOM_STEP = 0,
  GP_NOISE_RANDOM_KEYFRAME = 1,
} eNoiseRandomGpencil_Mode;
 
typedef struct SubdivGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  int pass_index;
  int flag;
  int level;
  int layer_pass;
  short type;
  char _pad[6];
} SubdivGpencilModifierData;
 
typedef enum eSubdivGpencil_Flag {
  GP_SUBDIV_INVERT_LAYER = (1 << 1),
  GP_SUBDIV_INVERT_PASS = (1 << 2),
  GP_SUBDIV_INVERT_LAYERPASS = (1 << 3),
  GP_SUBDIV_INVERT_MATERIAL = (1 << 4),
} eSubdivGpencil_Flag;
 
typedef enum eSubdivGpencil_Type {
  GP_SUBDIV_CATMULL = 0,
  GP_SUBDIV_SIMPLE = 1,
} eSubdivGpencil_Type;
 
typedef struct ThickGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int flag;
  float thickness_fac;
  int thickness;
  int layer_pass;
  char _pad[4];
  struct CurveMapping *curve_thickness;
} ThickGpencilModifierData;
 
typedef enum eThickGpencil_Flag {
  GP_THICK_INVERT_LAYER = (1 << 0),
  GP_THICK_INVERT_PASS = (1 << 1),
  GP_THICK_INVERT_VGROUP = (1 << 2),
  GP_THICK_CUSTOM_CURVE = (1 << 3),
  GP_THICK_NORMALIZE = (1 << 4),
  GP_THICK_INVERT_LAYERPASS = (1 << 5),
  GP_THICK_INVERT_MATERIAL = (1 << 6),
  GP_THICK_WEIGHT_FACTOR = (1 << 7),
} eThickGpencil_Flag;
 
typedef struct TimeGpencilModifierSegment {
  char name[64];
  /* For path reference. */
  struct TimeGpencilModifierData *gpmd;
  int seg_start;
  int seg_end;
  int seg_mode;
  int seg_repeat;
} TimeGpencilModifierSegment;
typedef struct TimeGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  int layer_pass;
  int flag;
  int offset;
  float frame_scale;
  int mode;
  int sfra, efra;
 
  char _pad[4];
 
  TimeGpencilModifierSegment *segments;
  int segments_len;
  int segment_active_index;
 
} TimeGpencilModifierData;
 
typedef enum eTimeGpencil_Flag {
  GP_TIME_INVERT_LAYER = (1 << 0),
  GP_TIME_KEEP_LOOP = (1 << 1),
  GP_TIME_INVERT_LAYERPASS = (1 << 2),
  GP_TIME_CUSTOM_RANGE = (1 << 3),
} eTimeGpencil_Flag;
 
typedef enum eTimeGpencil_Mode {
  GP_TIME_MODE_NORMAL = 0,
  GP_TIME_MODE_REVERSE = 1,
  GP_TIME_MODE_FIX = 2,
  GP_TIME_MODE_PINGPONG = 3,
  GP_TIME_MODE_CHAIN = 4,
} eTimeGpencil_Mode;
 
typedef enum eTimeGpencil_Seg_Mode {
  GP_TIME_SEG_MODE_NORMAL = 0,
  GP_TIME_SEG_MODE_REVERSE = 1,
  GP_TIME_SEG_MODE_PINGPONG = 2,
} eTimeGpencil_Seg_Mode;
 
typedef enum eModifyColorGpencil_Flag {
  GP_MODIFY_COLOR_BOTH = 0,
  GP_MODIFY_COLOR_STROKE = 1,
  GP_MODIFY_COLOR_FILL = 2,
  GP_MODIFY_COLOR_HARDNESS = 3,
} eModifyColorGpencil_Flag;
 
typedef enum eOpacityModesGpencil_Flag {
  GP_OPACITY_MODE_MATERIAL = 0,
  GP_OPACITY_MODE_STRENGTH = 1,
} eOpacityModesGpencil_Flag;
 
typedef struct ColorGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  int pass_index;
  int flag;
  float hsv[3];
  char modify_color;
  char _pad[3];
  int layer_pass;
 
  char _pad1[4];
  struct CurveMapping *curve_intensity;
} ColorGpencilModifierData;
 
typedef enum eColorGpencil_Flag {
  GP_COLOR_INVERT_LAYER = (1 << 1),
  GP_COLOR_INVERT_PASS = (1 << 2),
  GP_COLOR_INVERT_LAYERPASS = (1 << 3),
  GP_COLOR_INVERT_MATERIAL = (1 << 4),
  GP_COLOR_CUSTOM_CURVE = (1 << 5),
} eColorGpencil_Flag;
 
typedef struct OpacityGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int flag;
  float factor;
  char modify_color;
  char _pad[3];
  int layer_pass;
 
  float hardness;
  struct CurveMapping *curve_intensity;
} OpacityGpencilModifierData;
 
typedef enum eOpacityGpencil_Flag {
  GP_OPACITY_INVERT_LAYER = (1 << 0),
  GP_OPACITY_INVERT_PASS = (1 << 1),
  GP_OPACITY_INVERT_VGROUP = (1 << 2),
  GP_OPACITY_INVERT_LAYERPASS = (1 << 4),
  GP_OPACITY_INVERT_MATERIAL = (1 << 5),
  GP_OPACITY_CUSTOM_CURVE = (1 << 6),
  GP_OPACITY_NORMALIZE = (1 << 7),
  GP_OPACITY_WEIGHT_FACTOR = (1 << 8),
} eOpacityGpencil_Flag;
 
typedef struct OutlineGpencilModifierData {
  GpencilModifierData modifier;
  struct Object *object;
  struct Material *material;
  char layername[64];
  int pass_index;
  int flag;
  int thickness;
  float sample_length;
  int subdiv;
  int layer_pass;
  struct Material *outline_material;
} OutlineGpencilModifierData;
 
typedef enum eOutlineGpencil_Flag {
  GP_OUTLINE_INVERT_LAYER = (1 << 0),
  GP_OUTLINE_INVERT_PASS = (1 << 1),
  GP_OUTLINE_INVERT_LAYERPASS = (1 << 2),
  GP_OUTLINE_INVERT_MATERIAL = (1 << 3),
  GP_OUTLINE_KEEP_SHAPE = (1 << 4),
} eOutlineGpencil_Flag;
 
typedef struct ArrayGpencilModifierData {
  GpencilModifierData modifier;
  struct Object *object;
  struct Material *material;
  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;
 
  int pass_index;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  int mat_rpl;
  int layer_pass;
} ArrayGpencilModifierData;
 
typedef enum eArrayGpencil_Flag {
  GP_ARRAY_INVERT_LAYER = (1 << 2),
  GP_ARRAY_INVERT_PASS = (1 << 3),
  GP_ARRAY_INVERT_LAYERPASS = (1 << 5),
  GP_ARRAY_INVERT_MATERIAL = (1 << 6),
  GP_ARRAY_USE_OFFSET = (1 << 7),
  GP_ARRAY_USE_RELATIVE = (1 << 8),
  GP_ARRAY_USE_OB_OFFSET = (1 << 9),
  GP_ARRAY_UNIFORM_RANDOM_SCALE = (1 << 10),
} eArrayGpencil_Flag;
 
typedef struct BuildGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
 
  char layername[64];
  int pass_index;
 
  char materialname[64] DNA_DEPRECATED;
 
  int layer_pass;
 
  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;
} BuildGpencilModifierData;
 
typedef enum eBuildGpencil_Mode {
  /* Strokes are shown one by one until all have appeared */
  GP_BUILD_MODE_SEQUENTIAL = 0,
  /* All strokes start at the same time */
  GP_BUILD_MODE_CONCURRENT = 1,
  /* Only the new strokes are built */
  GP_BUILD_MODE_ADDITIVE = 2,
} eBuildGpencil_Mode;
 
typedef enum eBuildGpencil_Transition {
  /* Show in forward order */
  GP_BUILD_TRANSITION_GROW = 0,
  /* Hide in reverse order */
  GP_BUILD_TRANSITION_SHRINK = 1,
  /* Hide in forward order */
  GP_BUILD_TRANSITION_VANISH = 2,
} eBuildGpencil_Transition;
 
typedef enum eBuildGpencil_TimeAlignment {
  /* All strokes start at same time */
  GP_BUILD_TIMEALIGN_START = 0,
  /* All strokes end at same time */
  GP_BUILD_TIMEALIGN_END = 1,
 
  /* TODO: Random Offsets, Stretch-to-Fill */
} eBuildGpencil_TimeAlignment;
 
typedef enum eBuildGpencil_TimeMode {
  GP_BUILD_TIMEMODE_FRAMES = 0,
  GP_BUILD_TIMEMODE_PERCENTAGE = 1,
  GP_BUILD_TIMEMODE_DRAWSPEED = 2,
} eBuildGpencil_TimeMode;
 
typedef enum eBuildGpencil_Flag {
  /* Restrict modifier to particular layer/passes? */
  GP_BUILD_INVERT_LAYER = (1 << 0),
  GP_BUILD_INVERT_PASS = (1 << 1),
 
  /* Restrict modifier to only operating between the nominated frames */
  GP_BUILD_RESTRICT_TIME = (1 << 2),
  GP_BUILD_INVERT_LAYERPASS = (1 << 3),
  GP_BUILD_USE_FADING = (1 << 4),
} eBuildGpencil_Flag;
 
typedef struct LatticeGpencilModifierData {
  GpencilModifierData modifier;
  struct Object *object;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int flag;
  float strength;
  int layer_pass;
  struct LatticeDeformData *cache_data;
} LatticeGpencilModifierData;
 
typedef enum eLatticeGpencil_Flag {
  GP_LATTICE_INVERT_LAYER = (1 << 0),
  GP_LATTICE_INVERT_PASS = (1 << 1),
  GP_LATTICE_INVERT_VGROUP = (1 << 2),
  GP_LATTICE_INVERT_LAYERPASS = (1 << 3),
  GP_LATTICE_INVERT_MATERIAL = (1 << 4),
} eLatticeGpencil_Flag;
 
typedef struct LengthGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  int pass_index;
  int flag;
  int layer_pass;
  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;
} LengthGpencilModifierData;
 
typedef enum eLengthGpencil_Flag {
  GP_LENGTH_INVERT_LAYER = (1 << 0),
  GP_LENGTH_INVERT_PASS = (1 << 1),
  GP_LENGTH_INVERT_LAYERPASS = (1 << 2),
  GP_LENGTH_INVERT_MATERIAL = (1 << 3),
  GP_LENGTH_USE_CURVATURE = (1 << 4),
  GP_LENGTH_INVERT_CURVATURE = (1 << 5),
  GP_LENGTH_USE_RANDOM = (1 << 6),
} eLengthGpencil_Flag;
 
typedef enum eLengthGpencil_Type {
  GP_LENGTH_RELATIVE = 0,
  GP_LENGTH_ABSOLUTE = 1,
} eLengthGpencil_Type;
 
typedef struct DashGpencilModifierSegment {
  char name[64];
  /* For path reference. */
  struct DashGpencilModifierData *dmd;
  int dash;
  int gap;
  float radius;
  float opacity;
  int mat_nr;
  int flag;
} DashGpencilModifierSegment;
 
typedef struct DashGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  int pass_index;
  int flag;
  int layer_pass;
 
  int dash_offset;
 
  DashGpencilModifierSegment *segments;
  int segments_len;
  int segment_active_index;
 
} DashGpencilModifierData;
 
typedef enum eDashGpencil_Flag {
  GP_DASH_INVERT_LAYER = (1 << 0),
  GP_DASH_INVERT_PASS = (1 << 1),
  GP_DASH_INVERT_LAYERPASS = (1 << 2),
  GP_DASH_INVERT_MATERIAL = (1 << 3),
  GP_DASH_USE_CYCLIC = (1 << 7),
} eDashGpencil_Flag;
 
typedef struct MirrorGpencilModifierData {
  GpencilModifierData modifier;
  struct Object *object;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  int pass_index;
  int flag;
  int layer_pass;
  char _pad[4];
} MirrorGpencilModifierData;
 
typedef enum eMirrorGpencil_Flag {
  GP_MIRROR_INVERT_LAYER = (1 << 0),
  GP_MIRROR_INVERT_PASS = (1 << 1),
  GP_MIRROR_CLIPPING = (1 << 2),
  GP_MIRROR_AXIS_X = (1 << 3),
  GP_MIRROR_AXIS_Y = (1 << 4),
  GP_MIRROR_AXIS_Z = (1 << 5),
  GP_MIRROR_INVERT_LAYERPASS = (1 << 6),
  GP_MIRROR_INVERT_MATERIAL = (1 << 7),
} eMirrorGpencil_Flag;
 
typedef struct HookGpencilModifierData {
  GpencilModifierData modifier;
 
  struct Object *object;
  struct Material *material;
  char subtarget[64];
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int layer_pass;
  char _pad[4];
 
  int flag;
  char falloff_type;
  char _pad1[3];
  float parentinv[4][4];
  float cent[3];
  float falloff;
  float force;
  struct CurveMapping *curfalloff;
} HookGpencilModifierData;
 
typedef enum eHookGpencil_Flag {
  GP_HOOK_INVERT_LAYER = (1 << 0),
  GP_HOOK_INVERT_PASS = (1 << 1),
  GP_HOOK_INVERT_VGROUP = (1 << 2),
  GP_HOOK_UNIFORM_SPACE = (1 << 3),
  GP_HOOK_INVERT_LAYERPASS = (1 << 4),
  GP_HOOK_INVERT_MATERIAL = (1 << 5),
} eHookGpencil_Flag;
 
typedef enum eHookGpencil_Falloff {
  eGPHook_Falloff_None = 0,
  eGPHook_Falloff_Curve = 1,
  eGPHook_Falloff_Sharp = 2,
  eGPHook_Falloff_Smooth = 3,
  eGPHook_Falloff_Root = 4,
  eGPHook_Falloff_Linear = 5,
  eGPHook_Falloff_Const = 6,
  eGPHook_Falloff_Sphere = 7,
  eGPHook_Falloff_InvSquare = 8,
} eHookGpencil_Falloff;
 
typedef struct SimplifyGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  int pass_index;
  int flag;
  float factor;
  short mode;
  short step;
  int layer_pass;
  float length;
  float sharp_threshold;
  float distance;
} SimplifyGpencilModifierData;
 
typedef enum eSimplifyGpencil_Flag {
  GP_SIMPLIFY_INVERT_LAYER = (1 << 0),
  GP_SIMPLIFY_INVERT_PASS = (1 << 1),
  GP_SIMPLIFY_INVERT_LAYERPASS = (1 << 2),
  GP_SIMPLIFY_INVERT_MATERIAL = (1 << 3),
} eSimplifyGpencil_Flag;
 
typedef enum eSimplifyGpencil_Mode {
  /* Keep only one vertex every n vertices */
  GP_SIMPLIFY_FIXED = 0,
  /* Use RDP algorithm */
  GP_SIMPLIFY_ADAPTIVE = 1,
  /* Sample the stroke using a fixed length */
  GP_SIMPLIFY_SAMPLE = 2,
  /* Sample the stroke doing vertex merge */
  GP_SIMPLIFY_MERGE = 3,
} eSimplifyGpencil_Mode;
 
typedef enum eOffsetGpencil_Mode {
  GP_OFFSET_RANDOM = 0,
  GP_OFFSET_LAYER = 1,
  GP_OFFSET_MATERIAL = 2,
  GP_OFFSET_STROKE = 3
 
} eOffsetGpencil_Mode;
 
typedef struct OffsetGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int flag;
  float loc[3];
  float rot[3];
  float scale[3];
  float rnd_offset[3];
  float rnd_rot[3];
  float rnd_scale[3];
  int seed;
  int mode;
  int stroke_step;
  int stroke_start_offset;
  int layer_pass;
  char _pad[4];
 
} OffsetGpencilModifierData;
 
typedef enum eOffsetGpencil_Flag {
  GP_OFFSET_INVERT_LAYER = (1 << 0),
  GP_OFFSET_INVERT_PASS = (1 << 1),
  GP_OFFSET_INVERT_VGROUP = (1 << 2),
  GP_OFFSET_INVERT_LAYERPASS = (1 << 3),
  GP_OFFSET_INVERT_MATERIAL = (1 << 4),
  GP_OFFSET_UNIFORM_RANDOM_SCALE = (1 << 5),
} eOffsetGpencil_Flag;
 
typedef struct SmoothGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int flag;
  float factor;
  int step;
  int layer_pass;
 
  char _pad1[4];
  struct CurveMapping *curve_intensity;
} SmoothGpencilModifierData;
 
typedef enum eSmoothGpencil_Flag {
  GP_SMOOTH_MOD_LOCATION = (1 << 0),
  GP_SMOOTH_MOD_STRENGTH = (1 << 1),
  GP_SMOOTH_MOD_THICKNESS = (1 << 2),
  GP_SMOOTH_INVERT_LAYER = (1 << 3),
  GP_SMOOTH_INVERT_PASS = (1 << 4),
  GP_SMOOTH_INVERT_VGROUP = (1 << 5),
  GP_SMOOTH_MOD_UV = (1 << 6),
  GP_SMOOTH_INVERT_LAYERPASS = (1 << 7),
  GP_SMOOTH_INVERT_MATERIAL = (1 << 4),
  GP_SMOOTH_CUSTOM_CURVE = (1 << 8),
  GP_SMOOTH_KEEP_SHAPE = (1 << 9),
} eSmoothGpencil_Flag;
 
typedef struct ArmatureGpencilModifierData {
  GpencilModifierData modifier;
  short deformflag, multi;
  int _pad;
  struct Object *object;
  float (*vert_coords_prev)[3];
  char vgname[64];
 
} ArmatureGpencilModifierData;
 
typedef struct MultiplyGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  int pass_index;
  int flag;
  int layer_pass;
 
  int flags;
 
  int duplications;
  float distance;
  /* -1:inner 0:middle 1:outer */
  float offset;
 
  float fading_center;
  float fading_thickness;
  float fading_opacity;
 
} MultiplyGpencilModifierData;
 
typedef enum eMultiplyGpencil_Flag {
  /* GP_MULTIPLY_ENABLE_ANGLE_SPLITTING = (1 << 1),  Deprecated. */
  GP_MULTIPLY_ENABLE_FADING = (1 << 2),
} eMultiplyGpencil_Flag;
 
typedef struct TintGpencilModifierData {
  GpencilModifierData modifier;
 
  struct Object *object;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int layer_pass;
  int flag;
  int mode;
 
  float factor;
  float radius;
  float rgb[3];
  int type;
 
  struct CurveMapping *curve_intensity;
 
  struct ColorBand *colorband;
} TintGpencilModifierData;
 
typedef enum eTintGpencil_Type {
  GP_TINT_UNIFORM = 0,
  GP_TINT_GRADIENT = 1,
} eTintGpencil_Type;
 
typedef enum eTintGpencil_Flag {
  GP_TINT_INVERT_LAYER = (1 << 0),
  GP_TINT_INVERT_PASS = (1 << 1),
  GP_TINT_INVERT_VGROUP = (1 << 2),
  GP_TINT_INVERT_LAYERPASS = (1 << 4),
  GP_TINT_INVERT_MATERIAL = (1 << 5),
  GP_TINT_CUSTOM_CURVE = (1 << 6),
  GP_TINT_WEIGHT_FACTOR = (1 << 7),
} eTintGpencil_Flag;
 
typedef struct TextureGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char materialname[64] DNA_DEPRECATED;
  char vgname[64];
  int pass_index;
  int flag;
  float uv_offset;
  float uv_scale;
  float fill_rotation;
  float fill_offset[2];
  float fill_scale;
  int layer_pass;
  short fit_method;
  short mode;
  float alignment_rotation;
  char _pad[4];
} TextureGpencilModifierData;
 
typedef enum eTextureGpencil_Flag {
  GP_TEX_INVERT_LAYER = (1 << 0),
  GP_TEX_INVERT_PASS = (1 << 1),
  GP_TEX_INVERT_VGROUP = (1 << 2),
  GP_TEX_INVERT_LAYERPASS = (1 << 3),
  GP_TEX_INVERT_MATERIAL = (1 << 4),
} eTextureGpencil_Flag;
 
/* Texture->fit_method */
typedef enum eTextureGpencil_Fit {
  GP_TEX_FIT_STROKE = 0,
  GP_TEX_CONSTANT_LENGTH = 1,
} eTextureGpencil_Fit;
 
/* Texture->mode */
typedef enum eTextureGpencil_Mode {
  STROKE = 0,
  FILL = 1,
  STROKE_AND_FILL = 2,
} eTextureGpencil_Mode;
 
typedef struct WeightProxGpencilModifierData {
  GpencilModifierData modifier;
  char target_vgname[64];
  struct Material *material;
  char layername[64];
  char vgname[64];
  int pass_index;
  int flag;
  float min_weight;
  int layer_pass;
  float dist_start;
  float dist_end;
 
  struct Object *object;
} WeightProxGpencilModifierData;
 
typedef struct WeightAngleGpencilModifierData {
  GpencilModifierData modifier;
  char target_vgname[64];
  struct Material *material;
  char layername[64];
  char vgname[64];
  int pass_index;
  int flag;
  float min_weight;
  int layer_pass;
  short axis;
  short space;
  float angle;
} WeightAngleGpencilModifierData;
 
typedef enum eWeightGpencil_Flag {
  GP_WEIGHT_INVERT_LAYER = (1 << 0),
  GP_WEIGHT_INVERT_PASS = (1 << 1),
  GP_WEIGHT_INVERT_VGROUP = (1 << 2),
  GP_WEIGHT_INVERT_LAYERPASS = (1 << 3),
  GP_WEIGHT_INVERT_MATERIAL = (1 << 4),
  GP_WEIGHT_MULTIPLY_DATA = (1 << 5),
  GP_WEIGHT_INVERT_OUTPUT = (1 << 6),
} eWeightGpencil_Flag;
 
typedef enum eGpencilModifierSpace {
  GP_SPACE_LOCAL = 0,
  GP_SPACE_WORLD = 1,
} eGpencilModifierSpace;
 
struct LineartCache;
 
typedef struct LineartGpencilModifierData {
  GpencilModifierData 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; /* #GreasePencilLineartMaskSwitches */
  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;
 
  /* #eLineArtGPencilModifierFlags, 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];
 
  struct LineartCache *cache;
  struct LineartData *la_data_ptr;
 
} LineartGpencilModifierData;
 
typedef struct ShrinkwrapGpencilModifierData {
  GpencilModifierData modifier;
  struct Object *target;
  struct Object *aux_target;
  struct Material *material;
  char layername[64];
  char vgname[64];
  int pass_index;
  int flag;
  int layer_pass;
  float keep_dist;
  short shrink_type;
  char shrink_opts;
  char shrink_mode;
  float proj_limit;
  char proj_axis;
 
  char subsurf_levels;
  char _pad[6];
  float smooth_factor;
  int smooth_step;
 
  struct ShrinkwrapTreeData *cache_data;
} ShrinkwrapGpencilModifierData;
 
typedef enum eShrinkwrapGpencil_Flag {
  GP_SHRINKWRAP_INVERT_LAYER = (1 << 0),
  GP_SHRINKWRAP_INVERT_PASS = (1 << 1),
  GP_SHRINKWRAP_INVERT_LAYERPASS = (1 << 3),
  GP_SHRINKWRAP_INVERT_MATERIAL = (1 << 4),
  /* Keep next bit as is to be equals to mesh modifier flag to reuse functions. */
  GP_SHRINKWRAP_INVERT_VGROUP = (1 << 6),
} eShrinkwrapGpencil_Flag;
 
typedef struct EnvelopeGpencilModifierData {
  GpencilModifierData modifier;
  struct Material *material;
  char layername[64];
  char vgname[64];
  int pass_index;
  int flag;
  int mode;
  int mat_nr;
  float thickness;
  float strength;
  int skip;
  int layer_pass;
  /* Length of the envelope effect. */
  int spread;
 
  char _pad[4];
} EnvelopeGpencilModifierData;
 
typedef enum eEnvelopeGpencil_Flag {
  GP_ENVELOPE_INVERT_LAYER = (1 << 0),
  GP_ENVELOPE_INVERT_PASS = (1 << 1),
  GP_ENVELOPE_INVERT_VGROUP = (1 << 2),
  GP_ENVELOPE_INVERT_LAYERPASS = (1 << 3),
  GP_ENVELOPE_INVERT_MATERIAL = (1 << 4),
} eEnvelopeGpencil_Flag;
 
/* Texture->mode */
typedef enum eEnvelopeGpencil_Mode {
  GP_ENVELOPE_DEFORM = 0,
  GP_ENVELOPE_SEGMENTS = 1,
  GP_ENVELOPE_FILLS = 2,
} eEnvelopeGpencil_Mode;