Engine: fixed auto-outline for fonts with glyphs with negative offsets

Some rare fonts may have glyphs that have negative offsets, that is - their leftmost pixels lie to the left from the "pen" position (requested top-left text render coords).
We may learn this by reading font's BBox.
This commit fixes this problem for the auto-outlining. But the general issue still remains: if such text is positioned too close to the leftmost border of a parent surface (gui control, overlay, etc), then there's a chance that parts of the letter will be cut off.
This issue cannot be resolved without displacing text further from its starting draw position. But that may go against text rendering logic, and produce effects unexpected to the user. So I'll leave that for the future consideration.

Author: ivan-mogilko

Common/font/fonts.cpp

@@ -410,7 +410,14 @@ int get_font_surface_height_outlined(int font_number)
     return get_font_height_with_outline(font_number, true /* use surface height */);
 }
 
-std::pair<int, int> get_font_surface_extent(int font_number)
+std::pair<int, int> get_font_surface_hextent(int font_number)
+{
+    if (!assert_font_number(font_number))
+        return std::make_pair(0, 0);
+    return std::make_pair(fonts[font_number].Metrics.BBox.Left, fonts[font_number].Metrics.BBox.Right);
+}
+
+std::pair<int, int> get_font_surface_vextent(int font_number)
 {
     if (!assert_font_number(font_number))
         return std::make_pair(0, 0);

Common/font/fonts.h

@@ -71,10 +71,14 @@ int get_font_height_outlined(int font_number);
 int get_font_surface_height(int font_number);
 // Gets the surface height of the given font with corresponding outlining
 int get_font_surface_height_outlined(int font_number);
-// Get font's maximal graphical extent: this means the farthest vertical positions of glyphs,
-// relative to the "pen" position. Besides letting to calculate the surface height,
-// this information also lets to detect if some of the glyphs may appear above y0.
-std::pair<int, int> get_font_surface_extent(int font_number);
+// Get font's maximal horizontal extent: this means the farthest horizontal positions
+// of any glyph, relative to the "pen" position.
+std::pair<int, int> get_font_surface_hextent(int font_number);
+// Get font's maximal vertical extent: this means the farthest vertical positions
+// of any glyph, relative to the "pen" position. Besides letting to calculate the
+// surface height, this information also lets to detect if some of the glyphs may
+// appear above y0.
+std::pair<int, int> get_font_surface_vextent(int font_number);
 // Get font's glyphs max bounding box, in pixels relative to the "pen" position.
 Rect get_font_glyph_bbox(int font_number);
 // Get font's line spacing

Common/gui/guimain.cpp

@@ -864,7 +864,7 @@ Line CalcFontGraphicalVExtent(int font)
     // * font's real graphical extent (top and bottom offsets relative to the "pen")
     // * custom vertical offset set by user (if non-zero),
     const auto finfo = get_fontinfo(font);
-    const auto fextent = get_font_surface_extent(font);
+    const auto fextent = get_font_surface_vextent(font);
     int top = fextent.first +
         std::min(0, finfo.YOffset); // apply YOffset only if negative
     int bottom = fextent.second +

Common/libsrc/alfont-2.0.9/alfont.c

@@ -533,10 +533,14 @@ int alfont_get_font_real_height(ALFONT_FONT *f) {
 }
 
 ALFONT_DLL_DECLSPEC void alfont_get_font_bbox(ALFONT_FONT *f, int *left, int *top, int *right, int *bottom) {
-  *left = f->face_bbox.xmin;
-  *right = f->face_bbox.xmax;
-  *top = f->face_bbox.ymax;
-  *bottom = f->face_bbox.ymin;
+  if (left)
+    *left = f->face_bbox.xmin;
+  if (right)
+    *right = f->face_bbox.xmax;
+  if (top)
+    *top = f->face_bbox.ymax;
+  if (bottom)
+    *bottom = f->face_bbox.ymin;
 }
 
 ALFONT_DLL_DECLSPEC void alfont_get_charcode_range(ALFONT_FONT *f, int *first_charcode, int *last_charcode, int *num_charcodes) {

Engine/ac/display.cpp

@@ -654,20 +654,27 @@ void wouttextxy_AutoOutline(Bitmap *ds, size_t font, int32_t color, const char *
         color |= makeacol32(0, 0, 0, 0xff);
 
     const int t_width = get_text_width(texx, font);
-    const auto t_extent = get_font_surface_extent(font);
-    const int t_height = t_extent.second - t_extent.first + 1;
+    // Horizontal extent lets us know if any glyphs have negative horizontal offset
+    const auto t_extent_hor = get_font_surface_hextent(font);
+    const auto t_extent_ver = get_font_surface_vextent(font);
+    const int t_height = t_extent_ver.second - t_extent_ver.first + 1;
     if (t_width == 0 || t_height == 0)
         return;
     // Prepare stencils
-    const int t_yoff = t_extent.first;
+    const int t_xoff = (t_extent_hor.first < 0 ? t_extent_hor.first : 0);
+    const int t_yoff = t_extent_ver.first;
     Bitmap *texx_stencil, *outline_stencil;
     alloc_font_outline_buffers(font, &texx_stencil, &outline_stencil,
-        t_width, t_height, stencil_cd);
+        t_width + (-t_xoff) * 2, t_height, stencil_cd);
     texx_stencil->ClearTransparent();
     outline_stencil->ClearTransparent();
     // Ready text stencil
-    // Note we are drawing with y off, in case some font's glyphs exceed font's ascender
-    wouttextxy(texx_stencil, 0, -t_yoff, font, color, texx);
+    // Note we are drawing with x off, in case some glyphs have negative offsets
+    // and appear further to the left (we create stencil with extra space in that case);
+    // and y off, in case some font's glyphs exceed font's ascender
+    // NOTE: t_xoff here will only fix the outline, but this won't resolve e.g. parts
+    // of leftmost glyph positioned outside of a gui control or an overlay.
+    wouttextxy(texx_stencil, -t_xoff, -t_yoff, font, color, texx);
     // Anti-aliased TTFs require to be alpha-blended, not blit,
     // or the alpha values will be plain copied and final image will be broken.
     void(Bitmap::*pfn_drawstencil)(const Bitmap *src, int dst_x, int dst_y);
@@ -681,11 +688,12 @@ void wouttextxy_AutoOutline(Bitmap *ds, size_t font, int32_t color, const char *
         pfn_drawstencil = &Bitmap::MaskedBlit;
     }
 
-    // move start of text so that the outline doesn't drop off the bitmap
-    xxp += thickness;
+    // move start of text so that the outline doesn't drop off the bitmap;
+    // move by glyph offset in case the stencil was drawn with offset
+    xxp += thickness + t_xoff;
     int const outline_y = yyp + t_yoff;
     yyp += thickness;
-    
+
     // What we do here: first we paint text onto outline_stencil offsetting vertically;
     // then we paint resulting outline_stencil onto final dest offsetting horizontally.
     int largest_y_diff_reached_so_far = -1; 
@@ -713,6 +721,8 @@ void wouttextxy_AutoOutline(Bitmap *ds, size_t font, int32_t color, const char *
         if (x_diff > 0)
             (ds->*pfn_drawstencil)(outline_stencil, xxp + x_diff, outline_y);
     }
+
+    xxp -= t_xoff; // remove glyph offset from the final text position (keep std text pos)
 }
 
 void wouttext_outline(Bitmap *ds, int xxp, int yyp, int font, color_t text_color, color_t outline_color, const char *texx)

Engine/ac/draw.cpp

@@ -2414,7 +2414,7 @@ void draw_fps(const Rect &viewport)
     char loop_buffer[128];
     snprintf(loop_buffer, sizeof(loop_buffer), "Loop %u Time %.2f", loopcounter, time_ms * 0.001f);
 
-    int text_off = get_font_surface_extent(font).first; // TODO: a generic function that accounts for this?
+    int text_off = get_font_surface_vextent(font).first; // TODO: a generic function that accounts for this?
     wouttext_outline(fpsDisplay.get(), 1, 1 - text_off, font, text_color, fps_buffer);
     wouttext_outline(fpsDisplay.get(), viewport.GetWidth() / 2, 1 - text_off, font, text_color, loop_buffer);