Add swash fontdb glyph fallback

Author: ku1ik

src/renderer.rs

@@ -459,6 +459,63 @@ mod tests {
         assert_left_cell_edge_has_ink(&image, 1, 0, PALETTE[GREEN], PALETTE[YELLOW]);
     }
 
+    #[test]
+    fn swash_falls_back_to_unlisted_font_faces() {
+        let mut font_db = fontdb::Database::new();
+        font_db.load_font_data(include_bytes!("../fonts/JetBrainsMono-Regular.ttf").to_vec());
+        font_db.load_font_data(include_bytes!("../fonts/NotoSansCJKjp-Regular.otf").to_vec());
+
+        let settings = Settings {
+            terminal_size: (COLS, ROWS),
+            font_db,
+            font_families: vec![FONT_FAMILY.to_owned()],
+            text_family: FONT_FAMILY.to_owned(),
+            font_size: FONT_SIZE,
+            line_height: LINE_HEIGHT,
+            theme: theme(),
+            bold_is_bright: false,
+        };
+
+        let mut renderer = swash(settings);
+        let image = renderer.render(&lines_for("\x1b[48;5;3m日\x1b[49m"), None);
+
+        assert_closer_to(cell_pixel(&image, 1, 0, 0.3, 0.5), FG, PALETTE[YELLOW]);
+    }
+
+    #[test]
+    fn swash_fontdb_fallback_prefers_matching_style() {
+        let make_db = || {
+            let mut font_db = fontdb::Database::new();
+            font_db.load_font_data(include_bytes!("../fonts/JetBrainsMono-Italic.ttf").to_vec());
+            font_db.load_font_data(include_bytes!("../fonts/JetBrainsMono-Regular.ttf").to_vec());
+
+            font_db
+        };
+
+        let settings = |font_db, font_families| Settings {
+            terminal_size: (COLS, ROWS),
+            font_db,
+            font_families,
+            text_family: FONT_FAMILY.to_owned(),
+            font_size: FONT_SIZE,
+            line_height: LINE_HEIGHT,
+            theme: theme(),
+            bold_is_bright: false,
+        };
+
+        let mut fallback_renderer = swash(settings(make_db(), vec![]));
+        let fallback_image = fallback_renderer.render(&lines_for("M"), None);
+
+        let mut regular_renderer = swash(settings(make_db(), vec![FONT_FAMILY.to_owned()]));
+        let regular_image = regular_renderer.render(&lines_for("M"), None);
+
+        let mut italic_renderer = swash(settings(make_db(), vec![FONT_FAMILY.to_owned()]));
+        let italic_image = italic_renderer.render(&lines_for("\x1b[3mM"), None);
+
+        assert_images_equal(&fallback_image, &regular_image);
+        assert_images_differ(&fallback_image, &italic_image);
+    }
+
     // The col-2 (ANSI white, n=7) assertions probe the n < 8 boundary —
     // they catch off-by-one regressions like `n < 7` that the col-0 (red,
     // n=1) assertion alone would miss.
@@ -626,6 +683,37 @@ mod tests {
         );
     }
 
+    fn assert_images_equal(actual: &ImgVec<RGBA8>, expected: &ImgVec<RGBA8>) {
+        assert_eq!(actual.width(), expected.width());
+        assert_eq!(actual.height(), expected.height());
+
+        let mismatched = actual
+            .buf()
+            .iter()
+            .zip(expected.buf())
+            .filter(|(actual, expected)| actual != expected)
+            .count();
+
+        assert_eq!(mismatched, 0, "expected images to match exactly");
+    }
+
+    fn assert_images_differ(actual: &ImgVec<RGBA8>, expected: &ImgVec<RGBA8>) {
+        assert_eq!(actual.width(), expected.width());
+        assert_eq!(actual.height(), expected.height());
+
+        let mismatched = actual
+            .buf()
+            .iter()
+            .zip(expected.buf())
+            .filter(|(actual, expected)| actual != expected)
+            .count();
+
+        assert!(
+            mismatched > 10,
+            "expected images to differ, but only {mismatched} pixels changed"
+        );
+    }
+
     fn blend_rgb(fg: RGB8, bg: RGB8, ratio: u8) -> RGB8 {
         let ratio = ratio as u16;
 

src/renderer/swash.rs

@@ -1,5 +1,5 @@
 use std::collections::hash_map::DefaultHasher;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
 
 use imgref::ImgVec;
@@ -124,6 +124,22 @@ fn glyph_image_is_visible(img: &Image) -> bool {
     img.placement.width > 0 && img.placement.height > 0 && !img.data.is_empty()
 }
 
+fn font_weight(bold: bool) -> fontdb::Weight {
+    if bold {
+        fontdb::Weight::BOLD
+    } else {
+        fontdb::Weight::NORMAL
+    }
+}
+
+fn font_style(italic: bool) -> fontdb::Style {
+    if italic {
+        fontdb::Style::Italic
+    } else {
+        fontdb::Style::Normal
+    }
+}
+
 impl SwashRenderer {
     pub fn new(settings: Settings) -> Self {
         let col_width = col_width(&settings.font_db, &settings.text_family, settings.font_size)
@@ -155,21 +171,16 @@ impl SwashRenderer {
     }
 
     fn get_font_id(&mut self, name: &str, bold: bool, italic: bool) -> &Option<fontdb::ID> {
-        let weight = if bold {
-            fontdb::Weight::BOLD
-        } else {
-            fontdb::Weight::NORMAL
-        };
-
-        let style = if italic {
-            fontdb::Style::Italic
-        } else {
-            fontdb::Style::Normal
-        };
-
         self.font_id_cache
             .entry((name.to_owned(), bold, italic))
-            .or_insert_with(|| get_font_id(&self.font_db, &[name], weight, style))
+            .or_insert_with(|| {
+                get_font_id(
+                    &self.font_db,
+                    &[name],
+                    font_weight(bold),
+                    font_style(italic),
+                )
+            })
     }
 
     fn ensure_glyph(&mut self, ch: char, bold: bool, italic: bool) {
@@ -179,13 +190,28 @@ impl SwashRenderer {
             return;
         }
 
-        if let Some(glyph) = self.rasterize_glyph(ch, bold, italic) {
+        let mut tried_font_ids = HashSet::new();
+
+        if let Some(glyph) = self.rasterize_family_glyph(ch, bold, italic, &mut tried_font_ids) {
             self.glyph_cache.insert(key, Some(glyph));
             return;
         }
 
         if bold || italic {
-            if let Some(glyph) = self.rasterize_glyph(ch, false, false) {
+            if let Some(glyph) = self.rasterize_family_glyph(ch, false, false, &mut tried_font_ids)
+            {
+                self.glyph_cache.insert(key, Some(glyph));
+                return;
+            }
+        }
+
+        if let Some(glyph) = self.rasterize_fallback_glyph(ch, bold, italic, &tried_font_ids) {
+            self.glyph_cache.insert(key, Some(glyph));
+            return;
+        }
+
+        if bold || italic {
+            if let Some(glyph) = self.rasterize_fallback_glyph(ch, false, false, &tried_font_ids) {
                 self.glyph_cache.insert(key, Some(glyph));
                 return;
             }
@@ -200,14 +226,52 @@ impl SwashRenderer {
             .expect("caller must invoke ensure_glyph first")
     }
 
-    fn rasterize_glyph(&mut self, ch: char, bold: bool, italic: bool) -> Option<Image> {
+    fn rasterize_family_glyph(
+        &mut self,
+        ch: char,
+        bold: bool,
+        italic: bool,
+        tried_font_ids: &mut HashSet<fontdb::ID>,
+    ) -> Option<Image> {
         let families = self.font_families.clone();
 
         for name in &families {
             let Some(font_id) = *self.get_font_id(name, bold, italic) else {
                 continue;
             };
 
+            tried_font_ids.insert(font_id);
+
+            if let Some(glyph) = self.rasterize_font_glyph(font_id, ch) {
+                return Some(glyph);
+            }
+        }
+
+        None
+    }
+
+    fn rasterize_fallback_glyph(
+        &mut self,
+        ch: char,
+        bold: bool,
+        italic: bool,
+        tried_font_ids: &HashSet<fontdb::ID>,
+    ) -> Option<Image> {
+        let weight = font_weight(bold);
+        let style = font_style(italic);
+
+        // Match resvg/usvg behavior: if configured families miss, try any
+        // loaded face so system fonts and --font-dir fonts can cover unlisted scripts.
+        let fallback_font_ids: Vec<_> = self
+            .font_db
+            .faces()
+            .filter(|face| {
+                !tried_font_ids.contains(&face.id) && face.weight == weight && face.style == style
+            })
+            .map(|face| face.id)
+            .collect();
+
+        for font_id in fallback_font_ids {
             if let Some(glyph) = self.rasterize_font_glyph(font_id, ch) {
                 return Some(glyph);
             }