DNA_gpencil_legacy_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2008 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "DNA_ID.h"
#include "DNA_curve_types.h"
#include "DNA_listBase.h"
 
struct AnimData;
struct MDeformVert;
 
#define GP_DEFAULT_PIX_FACTOR 1.0f
#define GP_DEFAULT_GRID_LINES 4
#define GP_MAX_INPUT_SAMPLES 10
 
#define GP_DEFAULT_CURVE_RESOLUTION 32
#define GP_DEFAULT_CURVE_ERROR 0.1f
#define GP_DEFAULT_CURVE_EDIT_CORNER_ANGLE M_PI_2
 
#define GPENCIL_MIN_FILL_FAC 0.05f
#define GPENCIL_MAX_FILL_FAC 8.0f

typedef struct bGPDspoint {
  DNA_DEFINE_CXX_METHODS(bGPDspoint)
 
  
  float x, y, z;
  float pressure;
  float strength;
  float time;
  int flag;

  float uv_fac;
  float uv_rot;
  float uv_fill[2];

  float vert_color[4];

  char _pad2[4];
} bGPDspoint;

typedef enum eGPDspoint_Flag {
  /* stroke point is selected (for editing) */
  GP_SPOINT_SELECT = (1 << 0),
 
  /* stroke point is tagged (for some editing operation) */
  GP_SPOINT_TAG = (1 << 1),
} eGPSPoint_Flag;
 
/* ***************************************** */
/* GP Fill - Triangle Tessellation Data */
 
/* Grease-Pencil Annotations - 'Triangle'
 * -> A triangle contains the index of three vertices for filling the stroke
 *    This is only used if high quality fill is enabled
 */
typedef struct bGPDtriangle {
  /* indices for tessellated triangle used for GP Fill */
  unsigned int verts[3];
} bGPDtriangle;
 
/* ***************************************** */
 
/* ***************************************** */
/* GP Palettes (Deprecated - 2.78 - 2.79 only) */
 
/* color of palettes */
typedef struct bGPDpalettecolor {
  DNA_DEFINE_CXX_METHODS(bGPDpalettecolor)
 
  struct bGPDpalettecolor *next, *prev;
  char info[64];
  float color[4];
  float fill[4];
  short flag;
  char _pad[6];
} bGPDpalettecolor;

typedef enum eGPDpalettecolor_Flag {
  /* color is active */
  /* PC_COLOR_ACTIVE = (1 << 0), */ /* UNUSED */
  /* don't display color */
  PC_COLOR_HIDE = (1 << 1),
  /* protected from further editing */
  PC_COLOR_LOCKED = (1 << 2),
  /* do onion skinning */
  PC_COLOR_ONIONSKIN = (1 << 3),
  /* "volumetric" strokes */
  PC_COLOR_VOLUMETRIC = (1 << 4),
} eGPDpalettecolor_Flag;
 
/* palette of colors */
typedef struct bGPDpalette {
  DNA_DEFINE_CXX_METHODS(bGPDpalette)
 
  struct bGPDpalette *next, *prev;

  ListBase colors;
  char info[64];
 
  short flag;
  char _pad[6];
} bGPDpalette;

typedef enum eGPDpalette_Flag {
  /* palette is active */
  PL_PALETTE_ACTIVE = (1 << 0),
} eGPDpalette_Flag;
 
/* ***************************************** */
/* GP Curve Point */
 
typedef struct bGPDcurve_point {
  BezTriple bezt;
  float pressure;
  float strength;
  int point_index;

  int flag;

  float uv_fac;
  float uv_rot;
  float uv_fill[2];

  float vert_color[4];
  char _pad[4];
} bGPDcurve_point;
 
/* bGPDcurve_point->flag */
typedef enum eGPDcurve_point_Flag {
  GP_CURVE_POINT_SELECT = (1 << 0),
} eGPDcurve_point_Flag;
 
/* ***************************************** */
/* GP Curve */
 
/* Curve for Bezier Editing. */
typedef struct bGPDcurve {
  DNA_DEFINE_CXX_METHODS(bGPDcurve)
 
  
  bGPDcurve_point *curve_points;
  int tot_curve_points;
  short flag;
  char _pad[2];
} bGPDcurve;
 
/* bGPDcurve_Flag->flag */
typedef enum bGPDcurve_Flag {
  /* Flag to indicated that the stroke data has been changed and the curve needs to be refitted */
  GP_CURVE_NEEDS_STROKE_UPDATE = (1 << 0),
  /* Curve is selected */
  GP_CURVE_SELECT = (1 << 1),
} bGPDcurve_Flag;
 
/* ***************************************** */
/* GP Strokes */
 
/* Runtime temp data for bGPDstroke */
typedef struct bGPDstroke_Runtime {
  DNA_DEFINE_CXX_METHODS(bGPDstroke_Runtime)
 
  
  char tmp_layerinfo[128];

  float multi_frame_falloff;

  int stroke_start;
  int fill_start;
  int vertex_start;
  int curve_start;
  int _pad0;

  struct bGPDstroke *gps_orig;
  void *_pad2;
} bGPDstroke_Runtime;

typedef struct bGPDstroke {
  DNA_DEFINE_CXX_METHODS(bGPDstroke)
 
  struct bGPDstroke *next, *prev;

  bGPDspoint *points;
  bGPDtriangle *triangles;
  int totpoints;
  int tot_triangles;

  short thickness;
  short flag, _pad[2];

  double inittime;

  char colorname[128] DNA_DEPRECATED;

  int mat_nr;
  short caps[2];

  float hardness;
  float aspect_ratio[2];

  float fill_opacity_fac;

  float uv_rotation;
  float uv_translation[2];
  float uv_scale;

  int select_index;
  char _pad4[4];

  struct MDeformVert *dvert;
  void *_pad3;

  float vert_color_fill[4];

  struct bGPDcurve *editcurve;
 
  bGPDstroke_Runtime runtime;
  void *_pad5;
} bGPDstroke;

typedef enum eGPDstroke_Flag {
  /* stroke is in 3d-space */
  GP_STROKE_3DSPACE = (1 << 0),
  /* stroke is in 2d-space */
  GP_STROKE_2DSPACE = (1 << 1),
  /* stroke is in 2d-space (but with special 'image' scaling) */
  GP_STROKE_2DIMAGE = (1 << 2),
  /* stroke is selected */
  GP_STROKE_SELECT = (1 << 3),
  /* Flag used to indicate that stroke is closed and draw edge between last and first point */
  GP_STROKE_CYCLIC = (1 << 7),
  /* Flag used to indicate that stroke is used for fill close and must use
   * fill color for stroke and no fill area */
  GP_STROKE_NOFILL = (1 << 8),
  /* Flag to indicated that the editcurve has been changed and the stroke needs to be updated with
   * the curve data */
  GP_STROKE_NEEDS_CURVE_UPDATE = (1 << 9),
  /* Flag to indicate that a stroke is used only for help, and will not affect rendering or fill */
  GP_STROKE_HELP = (1 << 10),
  /* Flag to indicate that a extend stroke collide (fill tool). */
  GP_STROKE_COLLIDE = (1 << 11),
  /* only for use with stroke-buffer (while drawing arrows) */
  GP_STROKE_USE_ARROW_START = (1 << 12),
  /* only for use with stroke-buffer (while drawing arrows) */
  GP_STROKE_USE_ARROW_END = (1 << 13),
  /* Tag for update geometry */
  GP_STROKE_TAG = (1 << 14),
  /* only for use with stroke-buffer (while drawing eraser) */
  GP_STROKE_ERASER = (1 << 15),
} eGPDstroke_Flag;

typedef enum eGPDstroke_Caps {
  /* type of extreme */
  GP_STROKE_CAP_ROUND = 0,
  GP_STROKE_CAP_FLAT = 1,
 
  /* Keep last. */
  GP_STROKE_CAP_MAX,
} GPDstroke_Caps;
 
/* Arrows ----------------------- */

typedef enum eGPDstroke_Arrowstyle {
  GP_STROKE_ARROWSTYLE_NONE = 0,
  GP_STROKE_ARROWSTYLE_SEGMENT = 2,
  GP_STROKE_ARROWSTYLE_OPEN = 3,
  GP_STROKE_ARROWSTYLE_CLOSED = 4,
  GP_STROKE_ARROWSTYLE_SQUARE = 6,
} eGPDstroke_Arrowstyle;
 
/* ***************************************** */
/* GP Frame */
 
/* Runtime temp data for bGPDframe */
typedef struct bGPDframe_Runtime {
  DNA_DEFINE_CXX_METHODS(bGPDframe_Runtime)
 
  
  int frameid;
  int onion_id;
} bGPDframe_Runtime;

typedef struct bGPDframe {
  DNA_DEFINE_CXX_METHODS(bGPDframe)
 
  struct bGPDframe *next, *prev;

  ListBase strokes;

  int framenum;

  short flag;
  short key_type;
 
  bGPDframe_Runtime runtime;
} bGPDframe;
 
/* bGPDframe->flag */
typedef enum eGPDframe_Flag {
  /* frame is being painted on */
  GP_FRAME_PAINT = (1 << 0),
  /* for editing in Action Editor */
  GP_FRAME_SELECT = (1 << 1),
  /* Line Art generation */
  GP_FRAME_LRT_CLEARED = (1 << 2),
} eGPDframe_Flag;
 
/* ***************************************** */
/* GP Layer */
 
/* List of masking layers. */
typedef struct bGPDlayer_Mask {
  DNA_DEFINE_CXX_METHODS(bGPDlayer_Mask)
 
  struct bGPDlayer_Mask *next, *prev;
  char name[128];
  short flag;
  short sort_index;
  char _pad[4];
} bGPDlayer_Mask;
 
/* bGPDlayer_Mask->flag */
typedef enum ebGPDlayer_Mask_Flag {
  /* Mask is hidden. */
  GP_MASK_HIDE = (1 << 0),
  /* Mask is inverted. */
  GP_MASK_INVERT = (1 << 1),
} ebGPDlayer_Mask_Flag;

typedef struct bGPDlayer_Runtime {
  DNA_DEFINE_CXX_METHODS(bGPDlayer_Runtime)
 
  
  int icon_id;
  char _pad[4];
} bGPDlayer_Runtime;

typedef struct bGPDlayer {
  DNA_DEFINE_CXX_METHODS(bGPDlayer)
 
  struct bGPDlayer *next, *prev;

  ListBase frames;
  bGPDframe *actframe;

  short flag;
  short onion_flag;

  float color[4];
  float fill[4];

  char info[128];

  short thickness;
  short pass_index;

  struct Object *parent;
  float inverse[4][4];
  char parsubstr[/*MAX_NAME*/ 64];
  short partype;

  short line_change;
  float tintcolor[4];
  float opacity;
  char viewlayername[64];

  int blend_mode;
  float vertex_paint_opacity;
 
  /* annotation onion skin */
  short gstep;
  short gstep_next;

  float gcolor_prev[3];
  float gcolor_next[3];
  char _pad1[4];

  ListBase mask_layers;
  int act_mask;
  char _pad2[4];

  float location[3], rotation[3], scale[3];
  float layer_mat[4][4], layer_invmat[4][4];
  char _pad3[4];
 
  bGPDlayer_Runtime runtime;
} bGPDlayer;
 
/* bGPDlayer->flag */
typedef enum eGPDlayer_Flag {
  /* don't display layer */
  GP_LAYER_HIDE = (1 << 0),
  /* protected from further editing */
  GP_LAYER_LOCKED = (1 << 1),
  /* layer is 'active' layer being edited */
  GP_LAYER_ACTIVE = (1 << 2),
  /* draw points of stroke for debugging purposes */
  GP_LAYER_DRAWDEBUG = (1 << 3),
  /* Flag used to display in Paint mode only layers with keyframe */
  GP_LAYER_SOLO_MODE = (1 << 4),
  /* for editing in Action Editor */
  GP_LAYER_SELECT = (1 << 5),
  /* current frame for layer can't be changed */
  GP_LAYER_FRAMELOCK = (1 << 6),
  /* Don't render X-ray (which is default). */
  GP_LAYER_NO_XRAY = (1 << 7),
  /* "volumetric" strokes */
  GP_LAYER_VOLUMETRIC = (1 << 10),
  /* Use Scene lights */
  GP_LAYER_USE_LIGHTS = (1 << 11),
  /* Unlock color */
  GP_LAYER_UNLOCK_COLOR = (1 << 12),
  /* Mask Layer */
  GP_LAYER_USE_MASK = (1 << 13), /* TODO: DEPRECATED */
  /* Ruler Layer */
  GP_LAYER_IS_RULER = (1 << 14),
  /* Disable masks in view-layer render */
  GP_LAYER_DISABLE_MASKS_IN_VIEWLAYER = (1 << 15),
} eGPDlayer_Flag;

typedef enum eGPDlayer_OnionFlag {
  /* do onion skinning */
  GP_LAYER_ONIONSKIN = (1 << 0),
  GP_LAYER_ONIONSKIN_CUSTOM_COLOR = (1 << 1),
} eGPDlayer_OnionFlag;

typedef enum eGPLayerBlendModes {
  eGplBlendMode_Regular = 0,
  eGplBlendMode_HardLight = 1,
  eGplBlendMode_Add = 2,
  eGplBlendMode_Subtract = 3,
  eGplBlendMode_Multiply = 4,
  eGplBlendMode_Divide = 5,
} eGPLayerBlendModes;
 
/* ***************************************** */
/* GP Datablock */
 
/* Runtime temp data for bGPdata */
typedef struct bGPdata_Runtime {
  DNA_DEFINE_CXX_METHODS(bGPdata_Runtime)
 
  
  void *sbuffer;

  short playing;

  short matid;
 
  /* Stroke Buffer data (only used during paint-session)
   * - buffer must be initialized before use, but freed after
   *   whole paint operation is over
   */
  short sbuffer_sflag;
  char _pad1[2];
  int sbuffer_used;
  int sbuffer_size;

  float vert_color_fill[4];

  float fill_opacity_fac;

  float arrow_start[8];
  float arrow_end[8];
  /* Arrow style for each corner */
  int arrow_start_style;
  int arrow_end_style;
 
  char _pad[4];
} bGPdata_Runtime;
 
/* grid configuration */
typedef struct bGPgrid {
  float color[3];
  float scale[2];
  float offset[2];
  char _pad1[4];
 
  int lines;
  char _pad[4];
} bGPgrid;

typedef struct bGPdata {
#ifdef __cplusplus
  DNA_DEFINE_CXX_METHODS(bGPdata)
  static constexpr ID_Type id_type = ID_GD_LEGACY;
#endif

  ID id;
  struct AnimData *adt;
 
  /* Grease-Pencil data */
  ListBase layers;
  int flag;
  int curve_edit_resolution;
  float curve_edit_threshold;
  float curve_edit_corner_angle;
 
  /* Palettes */
  ListBase palettes DNA_DEPRECATED;

  ListBase vertex_group_names;
 
  /* 3D Viewport/Appearance Settings */
  float pixfactor;
  float line_color[4];
 
  /* Onion skinning */
  float onion_factor;
  int onion_mode;
  int onion_flag;
  short gstep;
  short gstep_next;

  float gcolor_prev[3];
  float gcolor_next[3];

  float zdepth_offset;
  struct Material **mat;
  short totcol;
 
  /* stats */
  short totlayer;
  short totframe;
  char _pad2[6];
  int totstroke;
  int totpoint;

  short draw_mode;
  short onion_keytype;

  int select_last_index;
 
  int vertex_group_active_index;
 
  bGPgrid grid;
 
  bGPdata_Runtime runtime;
} bGPdata;

typedef enum eGPdata_Flag {
  /* data-block is used for "annotations"
   * NOTE: This flag used to be used in 2.4x, but should hardly ever have been set.
   *       We can use this freely now, as all GP data-blocks from pre-2.8 will get
   *       set on file load (as many old use cases are for "annotations" only)
   */
  GP_DATA_ANNOTATIONS = (1 << 0),
 
  /* show debugging info in viewport (i.e. status print) */
  GP_DATA_DISPINFO = (1 << 1),
  /* in Action Editor, show as expanded channel */
  GP_DATA_EXPAND = (1 << 2),
 
  /* is the block overriding all clicks? */
  /* GP_DATA_EDITPAINT = (1 << 3), */
 
  /* ------------------------------------------------ DEPRECATED */
  /* new strokes are added in viewport space */
  GP_DATA_VIEWALIGN = (1 << 4),
 
  /* Project into the screen's Z values */
  GP_DATA_DEPTH_VIEW = (1 << 5),
  GP_DATA_DEPTH_STROKE = (1 << 6),
 
  GP_DATA_DEPTH_STROKE_ENDPOINTS = (1 << 7),
  /* ------------------------------------------------ DEPRECATED */
 
  /* Stroke Editing Mode - Toggle to enable alternative keymap
   * for easier editing of stroke points */
  GP_DATA_STROKE_EDITMODE = (1 << 8),
 
  /* Main flag to switch onion skinning on/off */
  GP_DATA_SHOW_ONIONSKINS = (1 << 9),
 
  /* Batch drawing cache need to be recalculated */
  GP_DATA_CACHE_IS_DIRTY = (1 << 11),
 
  /* Stroke Paint Mode - Toggle paint mode */
  GP_DATA_STROKE_PAINTMODE = (1 << 12),
  /* Stroke Editing Mode - Toggle sculpt mode */
  GP_DATA_STROKE_SCULPTMODE = (1 << 13),
  /* Stroke Editing Mode - Toggle weight paint mode */
  GP_DATA_STROKE_WEIGHTMODE = (1 << 14),
 
  /* keep stroke thickness unchanged when zoom change */
  GP_DATA_STROKE_KEEPTHICKNESS = (1 << 15),
 
  /* Allow edit several frames at the same time */
  GP_DATA_STROKE_MULTIEDIT = (1 << 16),
 
  /* Vertex Paint Mode - Toggle paint mode */
  GP_DATA_STROKE_VERTEXMODE = (1 << 18),
 
  /* Auto-lock not active layers. */
  GP_DATA_AUTOLOCK_LAYERS = (1 << 20),
 
  /* Enable Bezier Editing Curve (a sub-mode of Edit mode). */
  GP_DATA_CURVE_EDIT_MODE = (1 << 21),
  /* Use adaptive curve resolution */
  GP_DATA_CURVE_ADAPTIVE_RESOLUTION = (1 << 22),
} eGPdata_Flag;
 
/* gpd->onion_flag */
typedef enum eGPD_OnionFlag {
  /* use custom color for ghosts before current frame */
  GP_ONION_GHOST_PREVCOL = (1 << 0),
  /* use custom color for ghosts after current frame */
  GP_ONION_GHOST_NEXTCOL = (1 << 1),
  /* always show onion skins (i.e. even during renders/animation playback) */
  GP_ONION_GHOST_ALWAYS = (1 << 2),
  /* use fade color in onion skin */
  GP_ONION_FADE = (1 << 3),
  /* Loop showing first frame after last frame */
  GP_ONION_LOOP = (1 << 4),
} eGPD_OnionFlag;
 
/* gpd->onion_mode */
typedef enum eGP_OnionModes {
  GP_ONION_MODE_ABSOLUTE = 0,
  GP_ONION_MODE_RELATIVE = 1,
  GP_ONION_MODE_SELECTED = 2,
} eGP_OnionModes;
 
/* X-ray modes (Depth Ordering). */
typedef enum eGP_DepthOrdering {
  GP_XRAY_FRONT = 0,
  GP_XRAY_3DSPACE = 1,
} eGP_DepthOrdering;
 
/* draw modes (Use 2D or 3D position) */
typedef enum eGP_DrawMode {
  GP_DRAWMODE_2D = 0,
  GP_DRAWMODE_3D = 1,
} eGP_DrawMode;