swrenderer: signed distance field: properly round the x and y glyph coordinate (#6687)

Author: ogoffart

internal/compiler/passes/embed_glyphs.rs

@@ -557,8 +557,8 @@ fn generate_sdf_for_glyph(
     glyph_data.push(0);
 
     let metrics = fontdue::Metrics {
-        xmin: -(1. - bbox.x_min as f64 * scale).floor() as i32,
-        ymin: -(1. - bbox.y_min as f64 * scale).floor() as i32,
+        xmin: -(1. - bbox.x_min as f64 * scale).round() as i32,
+        ymin: -(1. - bbox.y_min as f64 * scale).round() as i32,
         width: width as usize,
         height: height as usize,
         advance_width: (face.glyph_hor_advance(glyph_id).unwrap() as f64 * scale) as f32,

internal/core/software_renderer.rs

@@ -1498,7 +1498,11 @@ impl<'a, T: ProcessScene> SceneBuilder<'a, T> {
                     }
                     let scale_delta = paragraph.layout.font.scale_delta();
                     for positioned_glyph in glyphs {
-                        let glyph = paragraph.layout.font.render_glyph(positioned_glyph.glyph_id);
+                        let Some(glyph) =
+                            paragraph.layout.font.render_glyph(positioned_glyph.glyph_id)
+                        else {
+                            continue;
+                        };
 
                         let target_rect = PhysicalRect::new(
                             PhysicalPoint::from_lengths(
@@ -1538,9 +1542,6 @@ impl<'a, T: ProcessScene> SceneBuilder<'a, T> {
 
                         match &glyph.alpha_map {
                             fonts::GlyphAlphaMap::Static(data) => {
-                                if data.is_empty() {
-                                    continue;
-                                }
                                 let texture = if !glyph.sdf {
                                     SceneTexture {
                                         data,

internal/core/software_renderer/fonts.rs

@@ -44,7 +44,7 @@ impl RenderableGlyph {
 }
 
 pub trait GlyphRenderer {
-    fn render_glyph(&self, glyph_id: core::num::NonZeroU16) -> RenderableGlyph;
+    fn render_glyph(&self, glyph_id: core::num::NonZeroU16) -> Option<RenderableGlyph>;
     /// The amount of pixel in the original image that correspond to one pixel in the rendered image
     fn scale_delta(&self) -> Fixed<u16, 8>;
 }

internal/core/software_renderer/fonts/pixelfont.rs

@@ -38,18 +38,24 @@ impl PixelFont {
 }
 
 impl GlyphRenderer for PixelFont {
-    fn render_glyph(&self, glyph_id: core::num::NonZeroU16) -> RenderableGlyph {
+    fn render_glyph(&self, glyph_id: core::num::NonZeroU16) -> Option<RenderableGlyph> {
         let glyph_index = Self::glyph_id_to_glyph_index(glyph_id);
         let bitmap_glyph = &self.glyphs.glyph_data[glyph_index];
-        RenderableGlyph {
+        if bitmap_glyph.data.len() == 0 {
+            // For example, ' ' has no glyph data
+            return None;
+        }
+        let width = self.scale_glyph_length(bitmap_glyph.width - 1) + PhysicalLength::new(1);
+        let height = self.scale_glyph_length(bitmap_glyph.height - 1) + PhysicalLength::new(1);
+        Some(RenderableGlyph {
             x: self.scale_glyph_length(bitmap_glyph.x),
-            y: self.scale_glyph_length(bitmap_glyph.y),
-            width: self.scale_glyph_length(bitmap_glyph.width - 1) + PhysicalLength::new(1),
-            height: self.scale_glyph_length(bitmap_glyph.height - 1) + PhysicalLength::new(1),
+            y: self.scale_glyph_length(bitmap_glyph.y + bitmap_glyph.height) - height,
+            width,
+            height,
             alpha_map: bitmap_glyph.data.as_slice().into(),
             pixel_stride: bitmap_glyph.width as u16,
             sdf: self.bitmap_font.sdf,
-        }
+        })
     }
     fn scale_delta(&self) -> super::Fixed<u16, 8> {
         super::Fixed::from_integer(self.glyphs.pixel_size as u16) / self.pixel_size.get() as u16

internal/core/software_renderer/fonts/vectorfont.rs

@@ -191,14 +191,14 @@ impl crate::textlayout::FontMetrics<PhysicalLength> for VectorFont {
 }
 
 impl super::GlyphRenderer for VectorFont {
-    fn render_glyph(&self, glyph_id: core::num::NonZeroU16) -> super::RenderableGlyph {
+    fn render_glyph(&self, glyph_id: core::num::NonZeroU16) -> Option<super::RenderableGlyph> {
         GLYPH_CACHE.with(|cache| {
             let mut cache = cache.borrow_mut();
 
             let cache_key = (self.id, self.pixel_size, glyph_id);
 
             if let Some(entry) = cache.get(&cache_key) {
-                entry.clone()
+                Some(entry.clone())
             } else {
                 let (metrics, alpha_map) =
                     self.fontdue_font.rasterize_indexed(glyph_id.get(), self.pixel_size.get() as _);
@@ -216,7 +216,7 @@ impl super::GlyphRenderer for VectorFont {
                 };
 
                 cache.put_with_weight(cache_key, glyph.clone()).ok();
-                glyph
+                Some(glyph)
             }
         })
     }