nothing works

src/gui/font.rs

@@ -0,0 +1,211 @@
+use std::{rc::Rc, str::FromStr, sync::Arc};
+
+use fontconfig::{FontConfig, OwnedPattern};
+use freetype::{bitmap::PixelMode, face::LoadFlag, Face, Library};
+use idmap::IdMap;
+use log::debug;
+use vulkano::{format::Format, command_buffer::CommandBufferUsage, image::ImmutableImage};
+
+use crate::graphics::WlxGraphics;
+
+const PRIMARY_FONT: &str = "LiberationSans";
+
+pub struct FontCache {
+    fc: FontConfig,
+    ft: Library,
+    collections: IdMap<isize, FontCollection>,
+}
+
+struct FontCollection {
+    fonts: Vec<Font>,
+    cp_map: IdMap<usize, usize>,
+}
+
+struct Font {
+    face: Face,
+    path: String,
+    index: isize,
+    size: isize,
+    glyphs: IdMap<usize, Rc<Glyph>>,
+}
+
+pub struct Glyph {
+    pub tex: Option<Arc<ImmutableImage>>,
+    pub top: f32,
+    pub left: f32,
+    pub width: f32,
+    pub height: f32,
+    pub advance: f32,
+}
+
+impl FontCache {
+    pub fn new() -> Self {
+        let ft = Library::init().expect("Failed to initialize freetype");
+        let fc = FontConfig::default();
+
+        FontCache {
+            fc,
+            ft,
+            collections: IdMap::new(),
+        }
+    }
+
+    pub fn get_text_size(&mut self, text: &str, size: isize, graphics: Arc<WlxGraphics>) -> (f32, f32) {
+        let sizef = size as f32;
+
+        let height = sizef + ((text.lines().count() as f32) - 1f32) * (sizef * 1.5);
+
+        let mut max_w = sizef * 0.33;
+        for line in text.lines() {
+            let w: f32 = line
+                .chars()
+                .map(|c| self.get_glyph_for_cp(c as usize, size, graphics.clone()).advance)
+                .sum();
+
+            if w > max_w {
+                max_w = w;
+            }
+        }
+        (max_w, height)
+    }
+
+    pub fn get_glyphs(&mut self, text: &str, size: isize, graphics: Arc<WlxGraphics>) -> Vec<Rc<Glyph>> {
+        let mut glyphs = Vec::new();
+        for line in text.lines() {
+            for c in line.chars() {
+                glyphs.push(self.get_glyph_for_cp(c as usize, size, graphics.clone()));
+            }
+        }
+        glyphs
+    }
+
+    fn get_font_for_cp(&mut self, cp: usize, size: isize) -> usize {
+        if !self.collections.contains_key(size) {
+            self.collections.insert(
+                size,
+                FontCollection {
+                    fonts: Vec::new(),
+                    cp_map: IdMap::new(),
+                },
+            );
+        }
+        let coll = self.collections.get_mut(size).unwrap();
+
+        if let Some(font) = coll.cp_map.get(cp) {
+            return *font;
+        }
+
+        let pattern_str = format!("{PRIMARY_FONT}-{size}:style=bold:charset={cp:04x}");
+
+        let mut pattern =
+            OwnedPattern::from_str(&pattern_str).expect("Failed to create fontconfig pattern");
+        self.fc
+            .substitute(&mut pattern, fontconfig::MatchKind::Pattern);
+        pattern.default_substitute();
+
+        let pattern = pattern.font_match(&mut self.fc);
+
+        if let Some(path) = pattern.filename() {
+            debug!(
+                "Loading font: {} {}pt",
+                pattern.name().unwrap_or(path),
+                size
+            );
+
+            let font_idx = pattern.face_index().unwrap_or(0);
+
+            let face = self
+                .ft
+                .new_face(path, font_idx as _)
+                .expect("Failed to load font face");
+            face.set_char_size(size << 6, size << 6, 96, 96)
+                .expect("Failed to set font size");
+
+            let idx = coll.fonts.len();
+            for cp in 0..0xFFFF {
+                if coll.cp_map.contains_key(cp) {
+                    continue;
+                }
+                let g = face.get_char_index(cp);
+                if g > 0 {
+                    coll.cp_map.insert(cp, idx);
+                }
+            }
+
+            let zero_glyph = Rc::new(Glyph {
+                tex: None,
+                top: 0.,
+                left: 0.,
+                width: 0.,
+                height: 0.,
+                advance: size as f32 / 3.,
+            });
+            let mut glyphs = IdMap::new();
+            glyphs.insert(0, zero_glyph);
+
+            let font = Font {
+                face,
+                path: path.to_string(),
+                size,
+                index: font_idx as _,
+                glyphs,
+            };
+            coll.fonts.push(font);
+
+            idx
+        } else {
+            coll.cp_map.insert(cp, 0);
+            0
+        }
+    }
+
+    fn get_glyph_for_cp(&mut self, cp: usize, size: isize, graphics: Arc<WlxGraphics>) -> Rc<Glyph> {
+        let key = self.get_font_for_cp(cp, size);
+
+        let font = &mut self.collections[size].fonts[key];
+
+        if let Some(glyph) = font.glyphs.get(cp) {
+            return glyph.clone();
+        }
+
+        if font.face.load_char(cp, LoadFlag::DEFAULT).is_err() {
+            return font.glyphs[0].clone();
+        }
+
+        let glyph = font.face.glyph();
+        if glyph.render_glyph(freetype::RenderMode::Normal).is_err() {
+            return font.glyphs[0].clone();
+        }
+
+        let bmp = glyph.bitmap();
+        let buf = bmp.buffer().to_vec();
+        if buf.len() == 0 {
+            return font.glyphs[0].clone();
+        }
+
+        let metrics = glyph.metrics();
+
+        let format = match bmp.pixel_mode() {
+            Ok(PixelMode::Gray) => Format::R8_UNORM,
+            Ok(PixelMode::Gray2) => Format::R16_SFLOAT,
+            Ok(PixelMode::Gray4) => Format::R32_SFLOAT,
+            _ => return font.glyphs[0].clone(),
+        };
+
+        let mut cmd_buffer = graphics.create_command_buffer(CommandBufferUsage::OneTimeSubmit);
+        let texture = cmd_buffer.texture2d(bmp.width() as _, bmp.rows() as _, format, buf);
+        let _ = cmd_buffer.end_and_execute();
+
+        let g = Glyph {
+            tex: Some(texture),
+            top: (metrics.horiBearingY >> 6i64) as _,
+            left: (metrics.horiBearingX >> 6i64) as _,
+            advance: (metrics.horiAdvance >> 6i64) as _,
+            width: bmp.width() as _,
+            height: bmp.rows() as _,
+        };
+
+        font.glyphs.insert(cp, Rc::new(g));
+        font.glyphs[cp].clone()
+    }
+}