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 <atomic>
#include <cmath>
 
#include "DNA_vec_types.h"
 
#include "BLF_api.hh"
 
#include "BLI_map.hh"
#include "BLI_mutex.hh"
#include "BLI_vector.hh"
 
#include "GPU_texture.hh"
#include "GPU_vertex_buffer.hh"
 
#include <ft2build.h>
 
struct FontBLF;
struct GlyphCacheBLF;
struct GlyphBLF;
 
namespace blender::gpu {
class Batch;
class VertBuf;
}  // namespace blender::gpu
struct GPUVertBufRaw;
 
namespace blender::ocio {
class Display;
}  // namespace blender::ocio
using ColorManagedDisplay = blender::ocio::Display;
 
#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. */
 
/* -------------------------------------------------------------------- */

using ft_pix = int32_t;
 
/* 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 (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];

  const 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];

  std::atomic<uint32_t> 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;
  BLFWrapMode wrap_mode;

  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;

  blender::Mutex glyph_cache_mutex;
};