be smarter about NO_HINTING

Only use it when we think the dpi is high, otherwise use the
default freetype parameters.

refs: https://github.com/wez/wezterm/issues/4908
refs: https://github.com/wez/wezterm/issues/4902

config/src/config.rs

@@ -266,7 +266,7 @@ pub struct Config {
     #[dynamic(default)]
     pub freetype_render_target: Option<FreeTypeLoadTarget>,
     #[dynamic(default)]
-    pub freetype_load_flags: FreeTypeLoadFlags,
+    pub freetype_load_flags: Option<FreeTypeLoadFlags>,
 
     /// Selects the freetype interpret version to use.
     /// Likely values are 35, 38 and 40 which have different

config/src/font.rs

@@ -271,9 +271,15 @@ bitflags! {
     }
 }
 
+impl FreeTypeLoadFlags {
+    pub fn default_hidpi() -> Self {
+        Self::NO_HINTING
+    }
+}
+
 impl Default for FreeTypeLoadFlags {
     fn default() -> Self {
-        Self::NO_HINTING
+        Self::DEFAULT
     }
 }
 

docs/changelog.md

@@ -22,7 +22,9 @@ usually the best available version.
 As features stabilize some brief notes about them will accumulate here.
 
 #### Changed
-* Not yet!
+* The default for
+  [freetype_load_flags](config/lua/config/freetype_load_flags.md) is now
+  `NO_HINTING` when the dpi is >= 100, otherwise `DEFAULT`. #4902
 #### New
 #### Fixed
 * It was not possible to specify `freetype_load_flags = 'DEFAULT'`. #4902

wezterm-font/src/ftwrap.rs

@@ -58,11 +58,16 @@ pub fn compute_load_flags_from_config(
     freetype_load_flags: Option<FreeTypeLoadFlags>,
     freetype_load_target: Option<FreeTypeLoadTarget>,
     freetype_render_target: Option<FreeTypeLoadTarget>,
+    dpi: Option<u32>,
 ) -> (i32, FT_Render_Mode) {
     let config = configuration();
 
     let load_flags = freetype_load_flags
-        .unwrap_or(config.freetype_load_flags)
+        .or(config.freetype_load_flags)
+        .unwrap_or_else(|| match dpi {
+            Some(dpi) if dpi >= 100 => FreeTypeLoadFlags::default_hidpi(),
+            _ => FreeTypeLoadFlags::default(),
+        })
         .bits()
         | FT_LOAD_COLOR;
 
@@ -989,7 +994,7 @@ impl Face {
         if glyph_pos == 0 {
             anyhow::bail!("no I from which to compute cap height");
         }
-        let (load_flags, render_mode) = compute_load_flags_from_config(None, None, None);
+        let (load_flags, render_mode) = compute_load_flags_from_config(None, None, None, None);
         let ft_glyph = self.load_and_render_glyph(glyph_pos, load_flags, render_mode, false)?;
 
         let mode: FT_Pixel_Mode =

wezterm-font/src/rasterizer/freetype.rs

@@ -53,6 +53,7 @@ impl FontRasterizer for FreeTypeRasterizer {
             self.freetype_load_flags,
             self.freetype_load_target,
             self.freetype_render_target,
+            Some(dpi),
         );
 
         let mut face = self.face.borrow_mut();

wezterm-font/src/shaper/harfbuzz.rs

@@ -142,7 +142,11 @@ impl HarfbuzzShaper {
         })
     }
 
-    fn load_fallback(&self, font_idx: FallbackIdx) -> anyhow::Result<Option<RefMut<FontPair>>> {
+    fn load_fallback(
+        &self,
+        font_idx: FallbackIdx,
+        dpi: u32,
+    ) -> anyhow::Result<Option<RefMut<FontPair>>> {
         if font_idx >= self.handles.len() {
             return Ok(None);
         }
@@ -162,6 +166,7 @@ impl HarfbuzzShaper {
                             handle.freetype_load_flags,
                             handle.freetype_load_target,
                             handle.freetype_render_target,
+                            Some(dpi),
                         );
                         let mut font = harfbuzz::Font::new(face.face);
                         font.set_load_flags(load_flags);
@@ -236,7 +241,7 @@ impl HarfbuzzShaper {
         let mut no_more_fallbacks = false;
 
         loop {
-            match self.load_fallback(font_idx).context("load_fallback")? {
+            match self.load_fallback(font_idx, dpi).context("load_fallback")? {
                 Some(mut pair) => {
                     if let Some(p) = presentation {
                         if pair.presentation != p {
@@ -604,7 +609,7 @@ impl FontShaper for HarfbuzzShaper {
 
     fn metrics_for_idx(&self, font_idx: usize, size: f64, dpi: u32) -> anyhow::Result<FontMetrics> {
         let mut pair = self
-            .load_fallback(font_idx)?
+            .load_fallback(font_idx, dpi)?
             .ok_or_else(|| anyhow!("metrics_for_idx: there is no font with idx={font_idx}!?"))?;
 
         let key = MetricsKey {
@@ -683,7 +688,7 @@ impl FontShaper for HarfbuzzShaper {
             theoretical_height,
             self.handles
         );
-        while let Ok(Some(mut pair)) = self.load_fallback(metrics_idx) {
+        while let Ok(Some(mut pair)) = self.load_fallback(metrics_idx, dpi) {
             let selected_size = pair
                 .face
                 .set_font_size(size * self.handles[metrics_idx].scale.unwrap_or(1.), dpi)?;