diff --git a/examples/text/src/main.rs b/examples/text/src/main.rs index 59c0e6a0..acf258c5 100644 --- a/examples/text/src/main.rs +++ b/examples/text/src/main.rs @@ -4,17 +4,6 @@ use std::{ time::Instant, }; -struct FontShape { - info: rustybuzz::GlyphInfo, - pos: rustybuzz::GlyphPosition, -} - -struct FontGlyph<'a> { - x_advance: i32, - y_advance: i32, - inner: rusttype::PositionedGlyph<'a>, -} - struct Font<'a> { data: &'a [u8], pub rustybuzz: rustybuzz::Face<'a>, @@ -29,51 +18,150 @@ impl<'a> Font<'a> { rusttype: rusttype::Font::try_from_bytes_and_index(data, index)?, }) } +} - pub fn shape(&self, line: &str) -> Vec { - let mut buffer = rustybuzz::UnicodeBuffer::new(); - buffer.push_str(line); - buffer.guess_segment_properties(); - println!("{:?}: {}", buffer.script(), line); +struct FontGlyph<'a> { + x_advance: i32, + y_advance: i32, + inner: rusttype::PositionedGlyph<'a>, +} - let glyph_buffer = rustybuzz::shape(&self.rustybuzz, &[], buffer); - let glyph_infos = glyph_buffer.glyph_infos(); - let glyph_positions = glyph_buffer.glyph_positions(); +struct FontShape<'a> { + info: rustybuzz::GlyphInfo, + pos: rustybuzz::GlyphPosition, + font: &'a Font<'a> +} - let mut shaped = Vec::with_capacity(glyph_infos.len()); - for (info, pos) in glyph_infos.iter().zip(glyph_positions.iter()) { - println!(" {:?} {:?}", info, pos); - shaped.push(FontShape { - info: *info, - pos: *pos - }); +impl<'a> FontShape<'a> { + pub fn glyph(&self, font_size: i32) -> FontGlyph<'a> { + let font_scale = self.font.rustybuzz.units_per_em(); + + let glyph = self.font.rusttype.glyph(rusttype::GlyphId(self.info.glyph_id as u16)) + .scaled(rusttype::Scale::uniform(font_size as f32)) + .positioned(rusttype::point( + (font_size * self.pos.x_offset) as f32 / font_scale as f32, + (font_size * self.pos.y_offset) as f32 / font_scale as f32 + )); + + FontGlyph { + x_advance: (font_size * self.pos.x_advance) / font_scale, + y_advance: (font_size * self.pos.y_advance) / font_scale, + inner: glyph + } + } +} + +struct FontMatches<'a> { + fonts: Vec<&'a Font<'a>>, +} + +impl<'a> FontMatches<'a> { + pub fn shape(&self, line: &str) -> Vec { + let mut font_shaped = Vec::with_capacity(self.fonts.len()); + for font in self.fonts.iter() { + let mut buffer = rustybuzz::UnicodeBuffer::new(); + buffer.push_str(line); + buffer.guess_segment_properties(); + println!("{:?}: {}", buffer.script(), line); + + let glyph_buffer = rustybuzz::shape(&font.rustybuzz, &[], buffer); + let glyph_infos = glyph_buffer.glyph_infos(); + let glyph_positions = glyph_buffer.glyph_positions(); + + let mut misses = 0; + let mut shaped = Vec::with_capacity(glyph_infos.len()); + for (info, pos) in glyph_infos.iter().zip(glyph_positions.iter()) { + //println!(" {:?} {:?}", info, pos); + if info.glyph_id == 0 { + misses += 1; + } + shaped.push(FontShape { + info: *info, + pos: *pos, + font, + }); + } + if misses == 0 { + return shaped; + } else { + font_shaped.push((misses, shaped)); + } + } + + let mut least_i = 0; + let mut least_misses = usize::MAX; + for (i, (misses, _)) in font_shaped.iter().enumerate() { + if *misses < least_misses { + least_i = i; + least_misses = *misses; + } + } + + if least_i > 0 { + println!("MISSES {}, {}", least_i, least_misses); + } + + font_shaped.remove(least_i).1 + } +} + +struct FontSystem<'a> { + fonts: Vec>, +} + +impl<'a> FontSystem<'a> { + pub fn new() -> Self { + Self { + fonts: Vec::new(), } - shaped } - pub fn glyph(&self, shaped: &[FontShape], font_size: i32) -> Vec> { - let font_scale = self.rustybuzz.units_per_em(); + pub fn add(&mut self, font: Font<'a>) { + self.fonts.push(font); + } - let mut glyphs = Vec::with_capacity(shaped.len()); - for FontShape { info, pos } in shaped.iter() { - if info.glyph_id == 0 { - println!("Missing glyph for cluster {}", info.cluster); + pub fn matches(&'a self, patterns: &[&str]) -> Option> { + let mut fonts = Vec::new(); + for font in self.fonts.iter() { + for rec in font.rustybuzz.names() { + if rec.name_id == 4 && rec.is_unicode() { + let mut words: Vec = Vec::new(); + + let mut i = 0; + while i + 1 < rec.name.len() { + words.push( + (rec.name[i + 1] as u16) | + ((rec.name[i] as u16) << 8) + ); + i += 2; + } + + match String::from_utf16(&words) { + Ok(name) => { + let mut matched = false; + for pattern in patterns.iter() { + println!("Matching font name '{}' with pattern '{}'", name, pattern); + if name.contains(pattern) { + matched = true; + } + } + if matched { + println!("Matched font name '{}'", name); + fonts.push(font); + } else { + println!("Did not match font name '{}'", name); + } + }, + Err(_) => () + } + } } - - let glyph = self.rusttype.glyph(rusttype::GlyphId(info.glyph_id as u16)) - .scaled(rusttype::Scale::uniform(font_size as f32)) - .positioned(rusttype::point( - (font_size * pos.x_offset) as f32 / font_scale as f32, - (font_size * pos.y_offset) as f32 / font_scale as f32 - )); - - glyphs.push(FontGlyph { - x_advance: (font_size * pos.x_advance) / font_scale, - y_advance: (font_size * pos.y_advance) / font_scale, - inner: glyph - }); } - glyphs + if ! fonts.is_empty() { + Some(FontMatches { fonts }) + } else { + None + } } } @@ -104,14 +192,33 @@ fn main() { let font_size_default = 2; // Title 4 let mut font_size_i = font_size_default; + let mut font_system = FontSystem::new(); + font_system.add( + Font::new(include_bytes!("../../../res/Fira/FiraSans-Regular.otf"), 0).unwrap() + ); + font_system.add( + Font::new(include_bytes!("../../../res/Fira/FiraMono-Regular.otf"), 0).unwrap() + ); + font_system.add( + Font::new(include_bytes!("../../../res/FreeFont/FreeSans.ttf"), 0).unwrap() + ); + font_system.add( + Font::new(include_bytes!("../../../res/FreeFont/FreeSerif.ttf"), 0).unwrap() + ); + font_system.add( + Font::new(include_bytes!("../../../res/FreeFont/FreeMono.ttf"), 0).unwrap() + ); + #[cfg(feature = "mono")] - let font = Font::new(include_bytes!("../../../res/FreeFont/FreeMono.ttf"), 0).unwrap(); + let font_pattern = &["Mono"]; #[cfg(not(feature = "mono"))] - let font = Font::new(include_bytes!("../../../res/FreeFont/FreeSerif.ttf"), 0).unwrap(); + let font_pattern = &["Sans", "Serif"]; + + let font_matches = font_system.matches(font_pattern).unwrap(); let mut shaped_lines = Vec::new(); for line in text.lines() { - shaped_lines.push(font.shape(line)); + shaped_lines.push(font_matches.shape(line)); } let mut glyph_lines = Vec::new(); @@ -128,7 +235,11 @@ fn main() { glyph_lines.clear(); for shaped in shaped_lines.iter() { - glyph_lines.push(font.glyph(&shaped, font_size)) + let mut glyphs = Vec::with_capacity(shaped.len()); + for shape in shaped.iter() { + glyphs.push(shape.glyph(font_size)); + } + glyph_lines.push(glyphs); } redraw = true; diff --git a/res/Fira/FiraMono-Regular.otf b/res/Fira/FiraMono-Regular.otf new file mode 100644 index 00000000..c30b25b9 Binary files /dev/null and b/res/Fira/FiraMono-Regular.otf differ diff --git a/res/FiraSans/Light.otf b/res/Fira/FiraSans-Light.otf similarity index 100% rename from res/FiraSans/Light.otf rename to res/Fira/FiraSans-Light.otf diff --git a/res/FiraSans/Regular.otf b/res/Fira/FiraSans-Regular.otf similarity index 100% rename from res/FiraSans/Regular.otf rename to res/Fira/FiraSans-Regular.otf diff --git a/res/FiraSans/SemiBold.otf b/res/Fira/FiraSans-SemiBold.otf similarity index 100% rename from res/FiraSans/SemiBold.otf rename to res/Fira/FiraSans-SemiBold.otf diff --git a/res/FiraSans/SIL Open Font License.txt b/res/Fira/SIL Open Font License.txt similarity index 100% rename from res/FiraSans/SIL Open Font License.txt rename to res/Fira/SIL Open Font License.txt diff --git a/res/FreeFont/FreeSans.ttf b/res/FreeFont/FreeSans.ttf new file mode 100644 index 00000000..2072cdaf Binary files /dev/null and b/res/FreeFont/FreeSans.ttf differ diff --git a/src/font.rs b/src/font.rs index 1cb10c1f..c9148dfc 100644 --- a/src/font.rs +++ b/src/font.rs @@ -2,15 +2,15 @@ pub use iced::Font; pub const FONT: Font = Font::External { name: "Fira Sans Regular", - bytes: include_bytes!("../res/FiraSans/Regular.otf"), + bytes: include_bytes!("../res/Fira/FiraSans-Regular.otf"), }; pub const FONT_LIGHT: Font = Font::External { name: "Fira Sans Light", - bytes: include_bytes!("../res/FiraSans/Light.otf"), + bytes: include_bytes!("../res/Fira/FiraSans-Light.otf"), }; pub const FONT_SEMIBOLD: Font = Font::External { name: "Fira Sans SemiBold", - bytes: include_bytes!("../res/FiraSans/SemiBold.otf"), + bytes: include_bytes!("../res/Fira/FiraSans-SemiBold.otf"), };