blf_internal_types.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2008 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <mutex>
 
#include "BLF_api.hh"
 
#include "BLI_map.hh"
#include "BLI_vector.hh"
 
#include "GPU_texture.hh"
#include "GPU_vertex_buffer.hh"
 
struct ColorManagedDisplay;
struct FontBLF;
namespace blender::gpu {
class Batch;
class VertBuf;
}  // namespace blender::gpu
struct GPUVertBufRaw;
 
#include FT_MULTIPLE_MASTERS_H /* Variable font support. */
 
#define BLF_VARIATIONS_MAX 16
 
#define MAKE_DVAR_TAG(a, b, c, d) \
  ((uint32_t(a) << 24u) | (uint32_t(b) << 16u) | (uint32_t(c) << 8u) | (uint32_t(d)))
 
#define BLF_VARIATION_AXIS_WEIGHT MAKE_DVAR_TAG('w', 'g', 'h', 't')  /* 'wght' weight axis. */
#define BLF_VARIATION_AXIS_SLANT MAKE_DVAR_TAG('s', 'l', 'n', 't')   /* 'slnt' slant axis. */
#define BLF_VARIATION_AXIS_WIDTH MAKE_DVAR_TAG('w', 'd', 't', 'h')   /* 'wdth' width axis. */
#define BLF_VARIATION_AXIS_SPACING MAKE_DVAR_TAG('s', 'p', 'a', 'c') /* 'spac' spacing axis. */
#define BLF_VARIATION_AXIS_OPTSIZE MAKE_DVAR_TAG('o', 'p', 's', 'z') /* 'opsz' optical size. */
 
/* -------------------------------------------------------------------- */
typedef int32_t ft_pix;
 
/* Macros copied from `include/freetype/internal/ftobjs.h`. */
 
#define FT_PIX_FLOOR(x) ((x) & ~63)
#define FT_PIX_ROUND(x) FT_PIX_FLOOR((x) + 32)
#define FT_PIX_CEIL(x) ((x) + 63)
 
inline int ft_pix_to_int(ft_pix v)
{
  return int(v >> 6);
}
 
inline int ft_pix_to_int_floor(ft_pix v)
{
  return int(v >> 6); /* No need for explicit floor as the bits are removed when shifting. */
}
 
inline int ft_pix_to_int_ceil(ft_pix v)
{
  return int(FT_PIX_CEIL(v) >> 6);
}
 
inline ft_pix ft_pix_from_int(int v)
{
  return v * 64;
}
 
inline ft_pix ft_pix_from_float(float v)
{
  return lroundf(v * 64.0f);
}
 
#define BLF_BATCH_DRAW_LEN_MAX 2048 /* in glyph */
 
#define KERNING_CACHE_TABLE_SIZE 128
 
#define KERNING_ENTRY_UNSET INT_MAX
 
struct BatchBLF {
  FontBLF *font;
  blender::gpu::Batch *batch;
  blender::gpu::VertBuf *verts;
  GPUVertBufRaw pos_step, col_step, offset_step, glyph_size_step, glyph_flags_step;
  unsigned int pos_loc, col_loc, offset_loc, glyph_size_loc, glyph_flags_loc;
  unsigned int glyph_len;
  int ofs[2];
  /* Previous call `modelmatrix`. */
  float mat[4][4];
  bool enabled, active, simple_shader;
  GlyphCacheBLF *glyph_cache;
};
 
extern BatchBLF g_batch;
 
struct KerningCacheBLF {
  int ascii_table[KERNING_CACHE_TABLE_SIZE][KERNING_CACHE_TABLE_SIZE];
};
 
struct GlyphCacheKey {
  uint charcode;
  uint8_t subpixel;
  friend bool operator==(const GlyphCacheKey &a, const GlyphCacheKey &b)
  {
    return a.charcode == b.charcode && a.subpixel == b.subpixel;
  }
  uint64_t hash() const
  {
    return blender::get_default_hash(charcode, subpixel);
  }
};
 
struct GlyphCacheBLF {
  float size;
 
  int char_weight;
  float char_slant;
  float char_width;
  float char_spacing;
 
  bool bold;
  bool italic;
 
  int fixed_width;
 
  blender::Map<GlyphCacheKey, std::unique_ptr<GlyphBLF>> glyphs;
 
  GPUTexture *texture;
  char *bitmap_result;
  int bitmap_len;
  int bitmap_len_landed;
  int bitmap_len_alloc;
 
  ~GlyphCacheBLF();
};
 
struct GlyphBLF {
  unsigned int c;
 
  FT_UInt idx;
 
  ft_pix box_xmin;
  ft_pix box_xmax;
  ft_pix box_ymin;
  ft_pix box_ymax;
 
  ft_pix advance_x;
  uint8_t subpixel;
 
  ft_pix lsb_delta;
  ft_pix rsb_delta;
 
  int offset;
 
  unsigned char *bitmap;
 
  int dims[2];
  int pitch;
  int num_channels;
 
  int pos[2];
 
  GlyphCacheBLF *glyph_cache;
 
  ~GlyphBLF();
};
 
struct FontBufInfoBLF {
  float *fbuf;
 
  unsigned char *cbuf;
 
  int dims[2];
 
  ColorManagedDisplay *display;
 
  float col_init[4];
  unsigned char col_char[4];
  float col_float[4];
};
 
struct FontMetrics {
  bool valid;
  short weight;
  float width;
  float slant;
  float spacing;
 
  short units_per_EM; /* */
  short family_class;
  short selection_flags;
  int num_glyphs;
  short first_charindex;
  short last_charindex;
 
  short ascender;
  short descender;
  short line_height;
  short x_height;
  short cap_height;
  float o_proportion;
  short max_advance_width;
  short max_advance_height;
 
  short underline_position;
  short underline_thickness;
  short strikeout_position;
  short strikeout_thickness;
  short subscript_size;
  short subscript_xoffset;
  short subscript_yoffset;
  short superscript_size;
  short superscript_xoffset;
  short superscript_yoffset;
};
 
struct FontBLF {
  char *filepath;
 
  void *mem;
  size_t mem_size;
  char *mem_name;
 
  uint unicode_ranges[4];
 
  unsigned int reference_count;
 
  float aspect[3];
 
  int pos[3];
 
  float angle;
 
  FontShadowType shadow;
 
  int shadow_x;
  int shadow_y;
 
  unsigned char shadow_color[4];
 
  unsigned char color[4];
 
  rcti clip_rec;
 
  int wrap_width;
 
  float size;
 
  FT_MM_Var *variations;
 
  int char_weight;    /* 100 - 900, 400 = normal. */
  float char_slant;   /* Slant in clockwise degrees. 0.0 = upright. */
  float char_width;   /* Factor of normal character width. 1.0 = normal. */
  float char_spacing; /* Factor of normal character spacing. 0.0 = normal. */
 
  int tex_size_max;
 
  int flags;
 
  blender::Vector<std::unique_ptr<GlyphCacheBLF>> cache;
 
  KerningCacheBLF *kerning_cache;
 
  FT_Library ft_lib;
 
  FT_Face face;
 
  FT_Size ft_size;
 
  FT_Long face_flags;
 
  FontMetrics metrics;
 
  FontBufInfoBLF buf_info;
 
  std::mutex glyph_cache_mutex;
};