Small polish of the appearence of small glyph with sdf

The trick is that we should have a constant delta, regardless of the
size of the individual glyphs.

Author: ogoffart

internal/core/software_renderer.rs

@@ -1496,6 +1496,7 @@ impl<'a, T: ProcessScene> SceneBuilder<'a, T> {
                                 .process_rectangle(geometry, selection.selection_background.into());
                         }
                     }
+                    let scale_delta = paragraph.layout.font.scale_delta();
                     for positioned_glyph in glyphs {
                         let glyph = paragraph.layout.font.render_glyph(positioned_glyph.glyph_id);
 
@@ -1537,6 +1538,9 @@ 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,
@@ -1554,21 +1558,10 @@ impl<'a, T: ProcessScene> SceneBuilder<'a, T> {
                                         },
                                     }
                                 } else {
-                                    let dx = if glyph.width.get() <= 1 {
-                                        Fixed::from_integer(0)
-                                    } else {
-                                        Fixed::from_integer(pixel_stride - 1)
-                                            / (glyph.width.get() as u16 - 1)
-                                    };
-                                    let dy = if glyph.height.get() <= 1 {
-                                        Fixed::from_integer(0)
-                                    } else {
-                                        Fixed::from_integer(
-                                            (data.len() as u16 - 1) / pixel_stride - 1,
-                                        ) / (glyph.height.get() as u16 - 1)
-                                    };
-                                    let off_x = Fixed::<i32, 8>::from_fixed(dx) * off_x as i32;
-                                    let off_y = Fixed::<i32, 8>::from_fixed(dy) * off_y as i32;
+                                    let off_x =
+                                        Fixed::<i32, 8>::from_fixed(scale_delta) * off_x as i32;
+                                    let off_y =
+                                        Fixed::<i32, 8>::from_fixed(scale_delta) * off_y as i32;
                                     SceneTexture {
                                         data,
                                         pixel_stride,
@@ -1578,8 +1571,8 @@ impl<'a, T: ProcessScene> SceneBuilder<'a, T> {
                                             // color already is mixed with global alpha
                                             alpha: color.alpha(),
                                             rotation: self.rotation.orientation,
-                                            dx,
-                                            dy,
+                                            dx: scale_delta,
+                                            dy: scale_delta,
                                             off_x: Fixed::try_from_fixed(off_x).unwrap(),
                                             off_y: Fixed::try_from_fixed(off_y).unwrap(),
                                         },

internal/core/software_renderer/fonts.rs

@@ -9,7 +9,7 @@ use core::cell::RefCell;
 #[cfg(all(not(feature = "std"), feature = "unsafe-single-threaded"))]
 use crate::thread_local_ as thread_local;
 
-use super::{PhysicalLength, PhysicalSize};
+use super::{Fixed, PhysicalLength, PhysicalSize};
 use crate::graphics::{BitmapFont, FontRequest};
 use crate::items::TextWrap;
 use crate::lengths::{LogicalLength, LogicalSize, ScaleFactor};
@@ -45,6 +45,8 @@ impl RenderableGlyph {
 
 pub trait GlyphRenderer {
     fn render_glyph(&self, glyph_id: core::num::NonZeroU16) -> 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>;
 }
 
 pub(super) const DEFAULT_FONT_SIZE: LogicalLength = LogicalLength::new(12 as Coord);

internal/core/software_renderer/fonts/pixelfont.rs

@@ -44,13 +44,16 @@ impl GlyphRenderer for PixelFont {
         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),
-            height: self.scale_glyph_length(bitmap_glyph.height),
+            width: self.scale_glyph_length(bitmap_glyph.width - 1) + PhysicalLength::new(1),
+            height: self.scale_glyph_length(bitmap_glyph.height - 1) + PhysicalLength::new(1),
             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
+    }
 }
 
 impl TextShaper for PixelFont {

internal/core/software_renderer/fonts/vectorfont.rs

@@ -220,4 +220,8 @@ impl super::GlyphRenderer for VectorFont {
             }
         })
     }
+
+    fn scale_delta(&self) -> super::Fixed<u16, 8> {
+        super::Fixed::from_integer(1)
+    }
 }