feat: working system fonts

Author: dsgallups

crates/bevy_text/src/font.rs

@@ -16,9 +16,76 @@ use bevy_reflect::TypePath;
 ///
 /// Bevy currently loads a single font face as a single `Font` asset.
 #[derive(Debug, TypePath, Clone, Asset)]
-pub struct Font {
+pub enum Font {
     /// Content of a font file as bytes
-    pub data: Arc<Vec<u8>>,
+    Data(Arc<Vec<u8>>),
+    /// References a font installed on the system by family, weight, stretch, and style.
+    System {
+        /// A list of font families that satisfy this font requirement
+        families: Vec<Family>,
+        /// Specifies the weight of glyphs in the font, their degree of blackness or stroke thickness.
+        ///
+        /// See [`cosmic_text::Weight`] for details.
+        weight: cosmic_text::Weight,
+        /// A face [width](https://docs.microsoft.com/en-us/typography/opentype/spec/os2#uswidthclass).
+        ///
+        /// See [`cosmic_text::Stretch`] for details.
+        stretch: cosmic_text::Stretch,
+        /// Allows italic or oblique faces to be selected.
+        ///
+        /// See [`cosmic_text::Style`] for details.
+        style: cosmic_text::Style,
+    },
+}
+
+/// A font family specifier, either by name or generic category.
+///
+/// See [`cosmic_text::Family`] for details.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Family {
+    /// The name of a font family of choice.
+    ///
+    /// This must be a *Typographic Family* (ID 16) or a *Family Name* (ID 1) in terms of TrueType.
+    /// Meaning you have to pass a family without any additional suffixes like _Bold_, _Italic_,
+    /// _Regular_, etc.
+    ///
+    /// Localized names are allowed.
+    Name(String),
+
+    /// Serif fonts represent the formal text style for a script.
+    Serif,
+
+    /// Glyphs in sans-serif fonts, as the term is used in CSS, are generally low contrast
+    /// and have stroke endings that are plain — without any flaring, cross stroke,
+    /// or other ornamentation.
+    SansSerif,
+
+    /// Glyphs in cursive fonts generally use a more informal script style,
+    /// and the result looks more like handwritten pen or brush writing than printed letterwork.
+    Cursive,
+
+    /// Fantasy fonts are primarily decorative or expressive fonts that
+    /// contain decorative or expressive representations of characters.
+    Fantasy,
+
+    /// The sole criterion of a monospace font is that all glyphs have the same fixed width.
+    MonoSpace,
+}
+
+impl Family {
+    /// References variants to create a [`cosmic_text::Family`].
+    ///
+    /// This is required for querying the underlying [`cosmic_text::fontdb::Database`]
+    pub fn as_fontdb_family(&self) -> cosmic_text::Family<'_> {
+        match self {
+            Family::Name(name) => cosmic_text::Family::Name(name),
+            Family::Serif => cosmic_text::Family::Serif,
+            Family::SansSerif => cosmic_text::Family::SansSerif,
+            Family::Cursive => cosmic_text::Family::Cursive,
+            Family::Fantasy => cosmic_text::Family::Fantasy,
+            Family::MonoSpace => cosmic_text::Family::Monospace,
+        }
+    }
 }
 
 impl Font {
@@ -28,8 +95,6 @@ impl Font {
     ) -> Result<Self, cosmic_text::ttf_parser::FaceParsingError> {
         use cosmic_text::ttf_parser;
         ttf_parser::Face::parse(&font_data, 0)?;
-        Ok(Self {
-            data: Arc::new(font_data),
-        })
+        Ok(Self::Data(Arc::new(font_data)))
     }
 }

crates/bevy_text/src/lib.rs

@@ -53,13 +53,16 @@ pub use pipeline::*;
 pub use text::*;
 pub use text_access::*;
 
+pub use cosmic_text::{Stretch, Style, Weight};
+
 /// The text prelude.
 ///
 /// This includes the most common types in this crate, re-exported for your convenience.
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        Font, Justify, LineBreak, TextColor, TextError, TextFont, TextLayout, TextSpan,
+        Family, Font, Justify, LineBreak, Stretch, Style, TextColor, TextError, TextFont,
+        TextLayout, TextSpan, Weight,
     };
 }
 

crates/bevy_text/src/pipeline.rs

@@ -13,7 +13,7 @@ use bevy_math::{Rect, UVec2, Vec2};
 use bevy_platform::collections::HashMap;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 
-use cosmic_text::{Attrs, Buffer, Family, Metrics, Shaping, Wrap};
+use cosmic_text::{Attrs, Buffer, Metrics, Shaping, Wrap};
 
 use crate::{
     error::TextError, ComputedTextBlock, Font, FontAtlasSets, FontSmoothing, Justify, LineBreak,
@@ -44,6 +44,7 @@ impl CosmicFontSystem {
         if load_system_fonts {
             db.load_system_fonts();
         }
+
         Self(cosmic_text::FontSystem::new_with_locale_and_db(locale, db))
     }
 }
@@ -151,7 +152,8 @@ impl TextPipeline {
                 font_system,
                 &mut self.map_handle_to_font_id,
                 fonts,
-            );
+            )
+            .ok_or(TextError::NoSuchFont)?;
 
             // Save spans that aren't zero-sized.
             if scale_factor <= 0.0 || text_font.font_size <= 0.0 {
@@ -507,34 +509,65 @@ pub fn load_font_to_fontdb(
     font_system: &mut cosmic_text::FontSystem,
     map_handle_to_font_id: &mut HashMap<AssetId<Font>, (cosmic_text::fontdb::ID, Arc<str>)>,
     fonts: &Assets<Font>,
-) -> FontFaceInfo {
+) -> Option<FontFaceInfo> {
     let font_handle = text_font.font.clone();
-    let (face_id, family_name) = map_handle_to_font_id
-        .entry(font_handle.id())
-        .or_insert_with(|| {
+
+    let (face_id, family_name) = match map_handle_to_font_id.get_mut(&font_handle.id()) {
+        Some((face_id, family_name)) => (face_id, family_name),
+        None => {
             let font = fonts.get(font_handle.id()).expect(
                 "Tried getting a font that was not available, probably due to not being loaded yet",
             );
-            let data = Arc::clone(&font.data);
-            let ids = font_system
-                .db_mut()
-                .load_font_source(cosmic_text::fontdb::Source::Binary(data));
 
-            // TODO: it is assumed this is the right font face
-            let face_id = *ids.last().unwrap();
+            let face_id = match font {
+                Font::Data(data) => {
+                    let data = Arc::clone(data);
+
+                    let ids = font_system
+                        .db_mut()
+                        .load_font_source(cosmic_text::fontdb::Source::Binary(data));
+
+                    // TODO: it is assumed this is the right font face
+                    *ids.last().unwrap()
+                }
+                Font::System {
+                    families,
+                    weight,
+                    stretch,
+                    style,
+                } => {
+                    let families = families
+                        .iter()
+                        .map(|family| family.as_fontdb_family())
+                        .collect::<Vec<_>>();
+                    let query = cosmic_text::fontdb::Query {
+                        families: &families,
+                        weight: *weight,
+                        stretch: *stretch,
+                        style: *style,
+                    };
+
+                    font_system.db().query(&query)?
+                }
+            };
+
             let face = font_system.db().face(face_id).unwrap();
             let family_name = Arc::from(face.families[0].0.as_str());
 
+            map_handle_to_font_id.insert(font_handle.id(), (face_id, family_name));
+            let (face_id, family_name) = map_handle_to_font_id.get_mut(&font_handle.id()).unwrap();
             (face_id, family_name)
-        });
+        }
+    };
+
     let face = font_system.db().face(*face_id).unwrap();
 
-    FontFaceInfo {
+    Some(FontFaceInfo {
         stretch: face.stretch,
         style: face.style,
         weight: face.weight,
         family_name: family_name.clone(),
-    }
+    })
 }
 
 /// Translates [`TextFont`] to [`Attrs`].
@@ -547,7 +580,7 @@ fn get_attrs<'a>(
 ) -> Attrs<'a> {
     Attrs::new()
         .metadata(span_index)
-        .family(Family::Name(&face_info.family_name))
+        .family(cosmic_text::Family::Name(&face_info.family_name))
         .stretch(face_info.stretch)
         .style(face_info.style)
         .weight(face_info.weight)