1 files changed, 330 insertions, 163 deletions

diff --git a/source/blender/blenfont/intern/blf_glyph.c b/source/blender/blenfont/intern/blf_glyph.c
index 6cdf5fc5996..5f14ef433e9 100644
--- a/source/blender/blenfont/intern/blf_glyph.c
+++ b/source/blender/blenfont/intern/blf_glyph.c
@@ -55,27 +55,47 @@
 #include "BLI_math_vector.h"
 #include "BLI_strict_flags.h"
 
-GlyphCacheBLF *blf_glyph_cache_find(FontBLF *font, unsigned int size, unsigned int dpi)
+/* -------------------------------------------------------------------- */
+/** \name Internal Utilities
+ * \{ */
+
+/**
+ * Convert a floating point value to a FreeType 16.16 fixed point value.
+ */
+static FT_Fixed to_16dot16(double val)
 {
-  GlyphCacheBLF *p;
+  return (FT_Fixed)(lround(val * 65536.0));
+}
 
-  p = (GlyphCacheBLF *)font->cache.first;
-  while (p) {
-    if (p->size == size && p->dpi == dpi && (p->bold == ((font->flags & BLF_BOLD) != 0)) &&
-        (p->italic == ((font->flags & BLF_ITALIC) != 0))) {
-      return p;
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Glyph Cache
+ * \{ */
+
+/**
+ * Find a glyph cache that matches a size, DPI & styles.
+ */
+GlyphCacheBLF *blf_glyph_cache_find(FontBLF *font, float size, unsigned int dpi)
+{
+  GlyphCacheBLF *gc = (GlyphCacheBLF *)font->cache.first;
+  while (gc) {
+    if (gc->size == size && gc->dpi == dpi && (gc->bold == ((font->flags & BLF_BOLD) != 0)) &&
+        (gc->italic == ((font->flags & BLF_ITALIC) != 0))) {
+      return gc;
     }
-    p = p->next;
+    gc = gc->next;
   }
   return NULL;
 }
 
-/* Create a new glyph cache for the current size, dpi, bold, italic. */
+/**
+ * Create a new glyph cache for the current size, DPI & styles.
+ */
 GlyphCacheBLF *blf_glyph_cache_new(FontBLF *font)
 {
-  GlyphCacheBLF *gc;
+  GlyphCacheBLF *gc = (GlyphCacheBLF *)MEM_callocN(sizeof(GlyphCacheBLF), "blf_glyph_cache_new");
 
-  gc = (GlyphCacheBLF *)MEM_callocN(sizeof(GlyphCacheBLF), "blf_glyph_cache_new");
   gc->next = NULL;
   gc->prev = NULL;
   gc->size = font->size;
@@ -86,27 +106,6 @@ GlyphCacheBLF *blf_glyph_cache_new(FontBLF *font)
   memset(gc->glyph_ascii_table, 0, sizeof(gc->glyph_ascii_table));
   memset(gc->bucket, 0, sizeof(gc->bucket));
 
-  gc->ascender = ((float)font->face->size->metrics.ascender) / 64.0f;
-  gc->descender = ((float)font->face->size->metrics.descender) / 64.0f;
-
-  if (FT_IS_SCALABLE(font->face)) {
-    gc->glyph_width_max = (int)((float)(font->face->bbox.xMax - font->face->bbox.xMin) *
-                                (((float)font->face->size->metrics.x_ppem) /
-                                 ((float)font->face->units_per_EM)));
-
-    gc->glyph_height_max = (int)((float)(font->face->bbox.yMax - font->face->bbox.yMin) *
-                                 (((float)font->face->size->metrics.y_ppem) /
-                                  ((float)font->face->units_per_EM)));
-  }
-  else {
-    gc->glyph_width_max = (int)(((float)font->face->size->metrics.max_advance) / 64.0f);
-    gc->glyph_height_max = (int)(((float)font->face->size->metrics.height) / 64.0f);
-  }
-
-  /* can happen with size 1 fonts */
-  CLAMP_MIN(gc->glyph_width_max, 1);
-  CLAMP_MIN(gc->glyph_height_max, 1);
-
   BLI_addhead(&font->cache, gc);
   return gc;
 }
@@ -159,59 +158,95 @@ void blf_glyph_cache_free(GlyphCacheBLF *gc)
   MEM_freeN(gc);
 }
 
-GlyphBLF *blf_glyph_search(GlyphCacheBLF *gc, unsigned int c)
+/**
+ * Try to find a glyph in cache.
+ *
+ * \return NULL if not found.
+ */
+static GlyphBLF *blf_glyph_cache_find_glyph(GlyphCacheBLF *gc, uint charcode)
 {
-  GlyphBLF *p;
-  unsigned int key;
-
-  key = blf_hash(c);
-  p = gc->bucket[key].first;
-  while (p) {
-    if (p->c == c) {
-      return p;
+  if (charcode < GLYPH_ASCII_TABLE_SIZE) {
+    return gc->glyph_ascii_table[charcode];
+  }
+
+  GlyphBLF *g = gc->bucket[blf_hash(charcode)].first;
+  while (g) {
+    if (g->c == charcode) {
+      return g;
     }
-    p = p->next;
+    g = g->next;
   }
   return NULL;
 }
 
-GlyphBLF *blf_glyph_add(FontBLF *font, GlyphCacheBLF *gc, unsigned int index, unsigned int c)
+/**
+ * Add a rendered glyph to a cache.
+ */
+static GlyphBLF *blf_glyph_cache_add_glyph(
+    FontBLF *font, GlyphCacheBLF *gc, FT_GlyphSlot glyph, uint charcode, FT_UInt glyph_index)
 {
-  FT_GlyphSlot slot;
-  GlyphBLF *g;
-  FT_Error err;
-  FT_Bitmap bitmap, tempbitmap;
+  GlyphBLF *g = (GlyphBLF *)MEM_callocN(sizeof(GlyphBLF), "blf_glyph_get");
+  g->c = charcode;
+  g->idx = glyph_index;
+  g->advance = ((float)glyph->advance.x) / 64.0f;
+  g->advance_i = (int)g->advance;
+  g->pos[0] = glyph->bitmap_left;
+  g->pos[1] = glyph->bitmap_top;
+  g->dims[0] = (int)glyph->bitmap.width;
+  g->dims[1] = (int)glyph->bitmap.rows;
+  g->pitch = glyph->bitmap.pitch;
+
   FT_BBox bbox;
-  unsigned int key;
+  FT_Outline_Get_CBox(&(glyph->outline), &bbox);
+  g->box.xmin = ((float)bbox.xMin) / 64.0f;
+  g->box.xmax = ((float)bbox.xMax) / 64.0f;
+  g->box.ymin = ((float)bbox.yMin) / 64.0f;
+  g->box.ymax = ((float)bbox.yMax) / 64.0f;
 
-  g = blf_glyph_search(gc, c);
-  if (g) {
-    return g;
+  const int buffer_size = (int)(glyph->bitmap.width * glyph->bitmap.rows);
+  if (buffer_size != 0) {
+    if (font->flags & BLF_MONOCHROME) {
+      /* Font buffer uses only 0 or 1 values, Blender expects full 0..255 range. */
+      for (int i = 0; i < buffer_size; i++) {
+        glyph->bitmap.buffer[i] = glyph->bitmap.buffer[i] ? 255 : 0;
+      }
+    }
+    g->bitmap = MEM_mallocN((size_t)buffer_size, "glyph bitmap");
+    memcpy(g->bitmap, glyph->bitmap.buffer, (size_t)buffer_size);
   }
 
-  /* glyphs are dynamically created as needed by font rendering. this means that
-   * to make font rendering thread safe we have to do locking here. note that this
-   * must be a lock for the whole library and not just per font, because the font
-   * renderer uses a shared buffer internally */
-  BLI_spin_lock(font->ft_lib_mutex);
-
-  /* search again after locking */
-  g = blf_glyph_search(gc, c);
-  if (g) {
-    BLI_spin_unlock(font->ft_lib_mutex);
-    return g;
+  unsigned int key = blf_hash(g->c);
+  BLI_addhead(&(gc->bucket[key]), g);
+  if (charcode < GLYPH_ASCII_TABLE_SIZE) {
+    gc->glyph_ascii_table[charcode] = g;
   }
 
+  return g;
+}
+
+/**
+ * Return a glyph index from `charcode`. Not found returns zero, which is a valid
+ * printable character (`.notdef` or `tofu`). Font is allowed to change here.
+ */
+static FT_UInt blf_glyph_index_from_charcode(FontBLF **font, const uint charcode)
+{
+  FT_UInt glyph_index = FT_Get_Char_Index((*font)->face, charcode);
+  /* TODO: If not found in this font, check others, update font pointer. */
+  return glyph_index;
+}
+
+/**
+ * Load a glyph into the glyph slot of a font's face object.
+ */
+static FT_GlyphSlot blf_glyph_load(FontBLF *font, FT_UInt glyph_index)
+{
   int load_flags;
-  int render_mode;
 
   if (font->flags & BLF_MONOCHROME) {
     load_flags = FT_LOAD_TARGET_MONO;
-    render_mode = FT_RENDER_MODE_MONO;
   }
   else {
     load_flags = FT_LOAD_NO_BITMAP;
-    render_mode = FT_RENDER_MODE_NORMAL;
     if (font->flags & BLF_HINTING_NONE) {
       load_flags |= FT_LOAD_TARGET_NORMAL | FT_LOAD_NO_HINTING;
     }
@@ -228,104 +263,222 @@ GlyphBLF *blf_glyph_add(FontBLF *font, GlyphCacheBLF *gc, unsigned int index, un
     }
   }
 
-  err = FT_Load_Glyph(font->face, (FT_UInt)index, load_flags);
-
-  /* Do not oblique a font that is designed to be italic! */
-  if (((font->flags & BLF_ITALIC) != 0) && !(font->face->style_flags & FT_STYLE_FLAG_ITALIC) &&
-      (font->face->glyph->format == FT_GLYPH_FORMAT_OUTLINE)) {
-    /* For (fake) italic: a shear transform with a 6 degree angle. */
-    FT_Matrix transform;
-    transform.xx = 0x10000L;
-    transform.yx = 0x00000L;
-    transform.xy = 0x03000L;
-    transform.yy = 0x10000L;
-    FT_Outline_Transform(&font->face->glyph->outline, &transform);
-  }
-
-  /* Do not embolden an already bold font! */
-  if (((font->flags & BLF_BOLD) != 0) &&
-      !(font->face->style_flags & FT_STYLE_FLAG_BOLD) &
-          (font->face->glyph->format == FT_GLYPH_FORMAT_OUTLINE)) {
-    /* Strengthen the width more than the height. */
-    const FT_Pos extra_x = FT_MulFix(font->face->units_per_EM, font->face->size->metrics.x_scale) /
-                           14;
-    const FT_Pos extra_y = FT_MulFix(font->face->units_per_EM, font->face->size->metrics.y_scale) /
-                           28;
-    FT_Outline_EmboldenXY(&font->face->glyph->outline, extra_x, extra_y);
-    if ((font->face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) == 0) {
-      /* Need to increase advance, but not for fixed-width fonts. */
-      font->face->glyph->advance.x += (FT_Pos)(((float)extra_x) * 1.05f);
-      font->face->glyph->advance.y += extra_y;
-    }
-    else {
-      /* Widened fixed-pitch font gets a nudge left. */
-      FT_Outline_Translate(&font->face->glyph->outline, (extra_x / -2), 0);
-    }
+  if (FT_Load_Glyph(font->face, glyph_index, load_flags) == 0) {
+    return font->face->glyph;
+  }
+  return NULL;
+}
+
+/**
+ * Convert a glyph from outlines to a bitmap that we can display.
+ */
+static bool blf_glyph_render_bitmap(FontBLF *font, FT_GlyphSlot glyph)
+{
+  int render_mode;
+
+  if (font->flags & BLF_MONOCHROME) {
+    render_mode = FT_RENDER_MODE_MONO;
+  }
+  else {
+    render_mode = FT_RENDER_MODE_NORMAL;
   }
 
-  if (err) {
-    BLI_spin_unlock(font->ft_lib_mutex);
-    return NULL;
+  /* Render the glyph curves to a bitmap. */
+  FT_Error err = FT_Render_Glyph(glyph, render_mode);
+  if (err != 0) {
+    return false;
   }
 
-  /* get the glyph. */
-  slot = font->face->glyph;
-  err = FT_Render_Glyph(slot, render_mode);
+  FT_Bitmap tempbitmap;
 
   if (font->flags & BLF_MONOCHROME) {
     /* Convert result from 1 bit per pixel to 8 bit per pixel */
-    /* Accum errors for later, fine if not interested beyond "ok vs any error" */
+    /* Accumulate errors for later, fine if not interested beyond "ok vs any error" */
     FT_Bitmap_New(&tempbitmap);
 
     /* Does Blender use Pitch 1 always? It works so far */
-    err += FT_Bitmap_Convert(font->ft_lib, &slot->bitmap, &tempbitmap, 1);
-    err += FT_Bitmap_Copy(font->ft_lib, &tempbitmap, &slot->bitmap);
+    err += FT_Bitmap_Convert(font->ft_lib, &glyph->bitmap, &tempbitmap, 1);
+    err += FT_Bitmap_Copy(font->ft_lib, &tempbitmap, &glyph->bitmap);
     err += FT_Bitmap_Done(font->ft_lib, &tempbitmap);
   }
 
-  if (err || slot->format != FT_GLYPH_FORMAT_BITMAP) {
-    BLI_spin_unlock(font->ft_lib_mutex);
-    return NULL;
+  if (err || glyph->format != FT_GLYPH_FORMAT_BITMAP) {
+    return false;
   }
 
-  g = (GlyphBLF *)MEM_callocN(sizeof(GlyphBLF), "blf_glyph_add");
-  g->c = c;
-  g->idx = (FT_UInt)index;
-  bitmap = slot->bitmap;
-  g->dims[0] = (int)bitmap.width;
-  g->dims[1] = (int)bitmap.rows;
+  return true;
+}
 
-  const int buffer_size = g->dims[0] * g->dims[1];
+/** \} */
 
-  if (buffer_size != 0) {
-    if (font->flags & BLF_MONOCHROME) {
-      /* Font buffer uses only 0 or 1 values, Blender expects full 0..255 range */
-      for (int i = 0; i < buffer_size; i++) {
-        bitmap.buffer[i] = bitmap.buffer[i] ? 255 : 0;
-      }
+/* -------------------------------------------------------------------- */
+/** \name Glyph Transformations
+ * \{ */
+
+/**
+ * Adjust the glyphs weight by a factor.
+ *
+ * \param factor: -1 (min stroke width) <= 0 (normal) => 1 (max boldness).
+ */
+static bool blf_glyph_transform_weight(FT_GlyphSlot glyph, float factor, bool monospaced)
+{
+  if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
+    /* Fake bold if the font does not have this variable axis. */
+    const FT_Pos average_width = FT_MulFix(glyph->face->units_per_EM,
+                                           glyph->face->size->metrics.x_scale);
+    FT_Pos change = (FT_Pos)((float)average_width * factor * 0.1f);
+    FT_Outline_EmboldenXY(&glyph->outline, change, change / 2);
+    if (monospaced) {
+      /* Widened fixed-pitch font needs a nudge left. */
+      FT_Outline_Translate(&glyph->outline, change / -2, 0);
+    }
+    else {
+      /* Need to increase advance. */
+      glyph->advance.x += change;
+      glyph->advance.y += change / 2;
     }
+    return true;
+  }
+  return false;
+}
 
-    g->bitmap = MEM_mallocN((size_t)buffer_size, "glyph bitmap");
-    memcpy(g->bitmap, bitmap.buffer, (size_t)buffer_size);
+/**
+ * Adjust the glyphs slant by a factor (making it oblique).
+ *
+ * \param factor: -1 (max negative) <= 0 (no slant) => 1 (max positive).
+ *
+ * \note that left-leaning italics are possible in some RTL writing systems.
+ */
+static bool blf_glyph_transform_slant(FT_GlyphSlot glyph, float factor)
+{
+  if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
+    FT_Matrix transform = {to_16dot16(1), to_16dot16(factor / 2.0f), 0, to_16dot16(1)};
+    FT_Outline_Transform(&glyph->outline, &transform);
+    return true;
   }
+  return false;
+}
 
-  g->advance = ((float)slot->advance.x) / 64.0f;
-  g->advance_i = (int)g->advance;
-  g->pos[0] = slot->bitmap_left;
-  g->pos[1] = slot->bitmap_top;
-  g->pitch = slot->bitmap.pitch;
+/**
+ * Adjust the glyph width by factor.
+ *
+ * \param factor: -1 (min width) <= 0 (normal) => 1 (max width).
+ */
+static bool UNUSED_FUNCTION(blf_glyph_transform_width)(FT_GlyphSlot glyph, float factor)
+{
+  if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
+    float scale = (factor * 0.4f) + 1.0f; /* 0.6f - 1.4f */
+    FT_Matrix matrix = {to_16dot16(scale), 0, 0, to_16dot16(1)};
+    FT_Outline_Transform(&glyph->outline, &matrix);
+    glyph->advance.x = (FT_Pos)((double)glyph->advance.x * scale);
+    return true;
+  }
+  return false;
+}
 
-  FT_Outline_Get_CBox(&(slot->outline), &bbox);
-  g->box.xmin = ((float)bbox.xMin) / 64.0f;
-  g->box.xmax = ((float)bbox.xMax) / 64.0f;
-  g->box.ymin = ((float)bbox.yMin) / 64.0f;
-  g->box.ymax = ((float)bbox.yMax) / 64.0f;
+/**
+ * Transform glyph to fit nicely within a fixed column width.
+ */
+static bool UNUSED_FUNCTION(blf_glyph_transform_monospace)(FT_GlyphSlot glyph, int width)
+{
+  if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
+    int gwidth = (int)(glyph->linearHoriAdvance >> 16);
+    if (gwidth > width) {
+      float scale = (float)width / (float)gwidth;
+      FT_Matrix matrix = {to_16dot16(scale), 0, 0, to_16dot16(1)};
+      /* Narrowing all points also thins vertical strokes. */
+      FT_Outline_Transform(&glyph->outline, &matrix);
+      const FT_Pos extra_x = (int)((float)(gwidth - width) * 5.65f);
+      /* Horizontally widen strokes to counteract narrowing. */
+      FT_Outline_EmboldenXY(&glyph->outline, extra_x, 0);
+    }
+    else if (gwidth < width) {
+      /* Narrow glyphs only need to be centered. */
+      int nudge = (width - gwidth) / 2;
+      FT_Outline_Translate(&glyph->outline, (FT_Pos)nudge * 64, 0);
+    }
+    return true;
+  }
+  return false;
+}
 
-  key = blf_hash(g->c);
-  BLI_addhead(&(gc->bucket[key]), g);
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Glyph Access (Ensure/Free)
+ * \{ */
+
+/**
+ * Create and return a fully-rendered bitmap glyph.
+ */
+static FT_GlyphSlot blf_glyph_render(FontBLF *settings_font,
+                                     FontBLF *glyph_font,
+                                     FT_UInt glyph_index)
+{
+  if (glyph_font != settings_font) {
+    FT_Set_Char_Size(glyph_font->face,
+                     0,
+                     ((FT_F26Dot6)(settings_font->size)) * 64,
+                     settings_font->dpi,
+                     settings_font->dpi);
+    glyph_font->size = settings_font->size;
+    glyph_font->dpi = settings_font->dpi;
+  }
+
+  FT_GlyphSlot glyph = blf_glyph_load(glyph_font, glyph_index);
+  if (!glyph) {
+    return NULL;
+  }
 
-  BLI_spin_unlock(font->ft_lib_mutex);
+  if ((settings_font->flags & BLF_ITALIC) != 0) {
+    /* 37.5% of maximum rightward slant results in 6 degree slope, matching italic
+     * version (`DejaVuSans-Oblique.ttf`) of our current font. But a nice median when
+     * checking others. Worth reevaluating if we change default font. We could also
+     * narrow the glyph slightly as most italics do, but this one does not. */
+    blf_glyph_transform_slant(glyph, 0.375f);
+  }
 
+  if ((settings_font->flags & BLF_BOLD) != 0) {
+    /* 70% of maximum weight results in the same amount of boldness and horizontal
+     * expansion as the bold version (`DejaVuSans-Bold.ttf`) of our default font.
+     * Worth reevaluating if we change default font. */
+    blf_glyph_transform_weight(glyph, 0.7f, glyph->face->face_flags & FT_FACE_FLAG_FIXED_WIDTH);
+  }
+
+  if (blf_glyph_render_bitmap(glyph_font, glyph)) {
+    return glyph;
+  }
+  return NULL;
+}
+
+/**
+ * Create (or load from cache) a fully-rendered bitmap glyph.
+ */
+GlyphBLF *blf_glyph_ensure(FontBLF *font, GlyphCacheBLF *gc, uint charcode)
+{
+  GlyphBLF *g = blf_glyph_cache_find_glyph(gc, charcode);
+  if (g) {
+    return g;
+  }
+
+  /* Glyph might not come from the initial font. */
+  FontBLF *font_with_glyph = font;
+  FT_UInt glyph_index = blf_glyph_index_from_charcode(&font_with_glyph, charcode);
+
+  /* Glyphs are dynamically created as needed by font rendering. this means that
+   * to make font rendering thread safe we have to do locking here. note that this
+   * must be a lock for the whole library and not just per font, because the font
+   * renderer uses a shared buffer internally. */
+  BLI_spin_lock(font_with_glyph->ft_lib_mutex);
+
+  FT_GlyphSlot glyph = blf_glyph_render(font, font_with_glyph, glyph_index);
+
+  if (glyph) {
+    /* Save this glyph in the initial font's cache. */
+    g = blf_glyph_cache_add_glyph(font, gc, glyph, charcode, glyph_index);
+  }
+
+  BLI_spin_unlock(font_with_glyph->ft_lib_mutex);
   return g;
 }
 
@@ -337,6 +490,42 @@ void blf_glyph_free(GlyphBLF *g)
   MEM_freeN(g);
 }
 
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Glyph Bounds Calculation
+ * \{ */
+
+static void blf_glyph_calc_rect(rctf *rect, GlyphBLF *g, float x, float y)
+{
+  rect->xmin = floorf(x + (float)g->pos[0]);
+  rect->xmax = rect->xmin + (float)g->dims[0];
+  rect->ymin = floorf(y + (float)g->pos[1]);
+  rect->ymax = rect->ymin - (float)g->dims[1];
+}
+
+static void blf_glyph_calc_rect_test(rctf *rect, GlyphBLF *g, float x, float y)
+{
+  /* Intentionally check with `g->advance`, because this is the
+   * width used by BLF_width. This allows that the text slightly
+   * overlaps the clipping border to achieve better alignment. */
+  rect->xmin = floorf(x);
+  rect->xmax = rect->xmin + MIN2(g->advance, (float)g->dims[0]);
+  rect->ymin = floorf(y);
+  rect->ymax = rect->ymin - (float)g->dims[1];
+}
+
+static void blf_glyph_calc_rect_shadow(rctf *rect, GlyphBLF *g, float x, float y, FontBLF *font)
+{
+  blf_glyph_calc_rect(rect, g, x + (float)font->shadow_x, y + (float)font->shadow_y);
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Glyph Drawing
+ * \{ */
+
 static void blf_texture_draw(const unsigned char color[4],
                              const int glyph_size[2],
                              const int offset,
@@ -395,31 +584,7 @@ static void blf_texture3_draw(const unsigned char color_in[4],
   blf_texture_draw(color_in, glyph_size_flag, offset, x1, y1, x2, y2);
 }
 
-static void blf_glyph_calc_rect(rctf *rect, GlyphBLF *g, float x, float y)
-{
-  rect->xmin = floorf(x + (float)g->pos[0]);
-  rect->xmax = rect->xmin + (float)g->dims[0];
-  rect->ymin = floorf(y + (float)g->pos[1]);
-  rect->ymax = rect->ymin - (float)g->dims[1];
-}
-
-static void blf_glyph_calc_rect_test(rctf *rect, GlyphBLF *g, float x, float y)
-{
-  /* Intentionally check with g->advance, because this is the
-   * width used by BLF_width. This allows that the text slightly
-   * overlaps the clipping border to achieve better alignment. */
-  rect->xmin = floorf(x);
-  rect->xmax = rect->xmin + MIN2(g->advance, (float)g->dims[0]);
-  rect->ymin = floorf(y);
-  rect->ymax = rect->ymin - (float)g->dims[1];
-}
-
-static void blf_glyph_calc_rect_shadow(rctf *rect, GlyphBLF *g, float x, float y, FontBLF *font)
-{
-  blf_glyph_calc_rect(rect, g, x + (float)font->shadow_x, y + (float)font->shadow_y);
-}
-
-void blf_glyph_render(FontBLF *font, GlyphCacheBLF *gc, GlyphBLF *g, float x, float y)
+void blf_glyph_draw(FontBLF *font, GlyphCacheBLF *gc, GlyphBLF *g, float x, float y)
 {
   if ((!g->dims[0]) || (!g->dims[1])) {
     return;
@@ -526,3 +691,5 @@ void blf_glyph_render(FontBLF *font, GlyphCacheBLF *gc, GlyphBLF *g, float x, fl
   blf_texture_draw(font->color, g->dims, g->offset, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
 #endif
 }
+
+/** \} */