Migrate to cosmic-text

Cargo.toml

@@ -205,9 +205,6 @@ wayland = ["bevy_internal/wayland"]
 # X11 display server support
 x11 = ["bevy_internal/x11"]
 
-# Enable rendering of font glyphs using subpixel accuracy
-subpixel_glyph_atlas = ["bevy_internal/subpixel_glyph_atlas"]
-
 # Enable systems that allow for automated testing on CI
 bevy_ci_testing = ["bevy_internal/bevy_ci_testing"]
 
@@ -1832,6 +1829,16 @@ description = "Demonstrates how the to use the size constraints to control the s
 category = "UI (User Interface)"
 wasm = true
 
+[[example]]
+name = "system_fonts"
+path = "examples/ui/system_fonts.rs"
+
+[package.metadata.example.system_fonts]
+name = "System Fonts"
+description = "Demonstrates using system fonts."
+category = "UI (User Interface)"
+wasm = false
+
 [[example]]
 name = "text"
 path = "examples/ui/text.rs"

crates/bevy_internal/Cargo.toml

@@ -71,9 +71,6 @@ serialize = ["bevy_core/serialize", "bevy_input/serialize", "bevy_time/serialize
 wayland = ["bevy_winit/wayland"]
 x11 = ["bevy_winit/x11"]
 
-# enable rendering of font glyphs using subpixel accuracy
-subpixel_glyph_atlas = ["bevy_text/subpixel_glyph_atlas"]
-
 # Optimise for WebGL2
 webgl = ["bevy_core_pipeline?/webgl", "bevy_pbr?/webgl", "bevy_render?/webgl"]
 

crates/bevy_text/Cargo.toml

@@ -9,7 +9,6 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [features]
-subpixel_glyph_atlas = []
 default_font = []
 
 [dependencies]
@@ -27,7 +26,8 @@ bevy_utils = { path = "../bevy_utils", version = "0.11.0-dev" }
 
 # other
 anyhow = "1.0.4"
-ab_glyph = "0.2.6"
-glyph_brush_layout = "0.2.1"
+cosmic-text = "0.8.0"
 thiserror = "1.0"
 serde = {version = "1", features = ["derive"]}
+sys-locale = "0.3.0"
+unicode-bidi = "0.3.13"

crates/bevy_text/src/error.rs

@@ -1,10 +1,11 @@
-use ab_glyph::GlyphId;
 use thiserror::Error;
 
 #[derive(Debug, PartialEq, Eq, Error)]
 pub enum TextError {
     #[error("font not found")]
     NoSuchFont,
     #[error("failed to add glyph to newly-created atlas {0:?}")]
-    FailedToAddGlyph(GlyphId),
+    FailedToAddGlyph(u16),
+    #[error("font system mutex could not be acquired or is poisoned")]
+    FailedToAcquireMutex,
 }

crates/bevy_text/src/font.rs

@@ -1,45 +1,20 @@
-use ab_glyph::{FontArc, FontVec, InvalidFont, OutlinedGlyph};
 use bevy_reflect::{TypePath, TypeUuid};
-use bevy_render::{
-    render_resource::{Extent3d, TextureDimension, TextureFormat},
-    texture::Image,
-};
 
 #[derive(Debug, TypeUuid, TypePath, Clone)]
 #[uuid = "97059ac6-c9ba-4da9-95b6-bed82c3ce198"]
+
+/// An [`Asset`](bevy_asset::Asset) that contains the data for a loaded font, if loaded as an asset.
+///
+/// Loaded by [`FontLoader`](crate::FontLoader).
 pub struct Font {
-    pub font: FontArc,
+    pub data: std::sync::Arc<Vec<u8>>,
 }
 
 impl Font {
-    pub fn try_from_bytes(font_data: Vec<u8>) -> Result<Self, InvalidFont> {
-        let font = FontVec::try_from_vec(font_data)?;
-        let font = FontArc::new(font);
-        Ok(Font { font })
-    }
-
-    pub fn get_outlined_glyph_texture(outlined_glyph: OutlinedGlyph) -> Image {
-        let bounds = outlined_glyph.px_bounds();
-        let width = bounds.width() as usize;
-        let height = bounds.height() as usize;
-        let mut alpha = vec![0.0; width * height];
-        outlined_glyph.draw(|x, y, v| {
-            alpha[y as usize * width + x as usize] = v;
-        });
-
-        // TODO: make this texture grayscale
-        Image::new(
-            Extent3d {
-                width: width as u32,
-                height: height as u32,
-                depth_or_array_layers: 1,
-            },
-            TextureDimension::D2,
-            alpha
-                .iter()
-                .flat_map(|a| vec![255, 255, 255, (*a * 255.0) as u8])
-                .collect::<Vec<u8>>(),
-            TextureFormat::Rgba8UnormSrgb,
-        )
+    pub fn from_bytes(font_data: Vec<u8>) -> Self {
+        // TODO: validate font, restore `try_from_bytes`
+        Self {
+            data: std::sync::Arc::new(font_data),
+        }
     }
 }

crates/bevy_text/src/font_atlas.rs

@@ -1,47 +1,23 @@
-use ab_glyph::{GlyphId, Point};
 use bevy_asset::{Assets, Handle};
-use bevy_math::Vec2;
+use bevy_math::{IVec2, Vec2};
 use bevy_render::{
     render_resource::{Extent3d, TextureDimension, TextureFormat},
     texture::Image,
 };
 use bevy_sprite::{DynamicTextureAtlasBuilder, TextureAtlas};
 use bevy_utils::HashMap;
 
-#[cfg(feature = "subpixel_glyph_atlas")]
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub struct SubpixelOffset {
-    x: u16,
-    y: u16,
-}
-
-#[cfg(feature = "subpixel_glyph_atlas")]
-impl From<Point> for SubpixelOffset {
-    fn from(p: Point) -> Self {
-        fn f(v: f32) -> u16 {
-            ((v % 1.) * (u16::MAX as f32)) as u16
-        }
-        Self {
-            x: f(p.x),
-            y: f(p.y),
-        }
-    }
-}
-
-#[cfg(not(feature = "subpixel_glyph_atlas"))]
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub struct SubpixelOffset;
-
-#[cfg(not(feature = "subpixel_glyph_atlas"))]
-impl From<Point> for SubpixelOffset {
-    fn from(_: Point) -> Self {
-        Self
-    }
-}
+use crate::GlyphAtlasLocation;
 
+/// Rasterized glyphs are cached, stored in, and retrieved from, a `FontAtlas`.
+///
+/// A [`FontAtlasSet`](crate::FontAtlasSet) contains one or more `FontAtlas`es.
 pub struct FontAtlas {
+    /// Used to update the [`TextureAtlas`].
     pub dynamic_texture_atlas_builder: DynamicTextureAtlasBuilder,
-    pub glyph_to_atlas_index: HashMap<(GlyphId, SubpixelOffset), usize>,
+    /// A mapping between subpixel-binned glyphs and their [`GlyphAtlasLocation`].
+    pub glyph_to_atlas_index: HashMap<cosmic_text::CacheKey, GlyphAtlasLocation>,
+    /// The handle to the [`TextureAtlas`] that holds the rasterized glyphs.
     pub texture_atlas: Handle<TextureAtlas>,
 }
 
@@ -69,36 +45,34 @@ impl FontAtlas {
         }
     }
 
-    pub fn get_glyph_index(
-        &self,
-        glyph_id: GlyphId,
-        subpixel_offset: SubpixelOffset,
-    ) -> Option<usize> {
-        self.glyph_to_atlas_index
-            .get(&(glyph_id, subpixel_offset))
-            .copied()
+    pub fn get_glyph_index(&self, cache_key: cosmic_text::CacheKey) -> Option<GlyphAtlasLocation> {
+        self.glyph_to_atlas_index.get(&cache_key).copied()
     }
 
-    pub fn has_glyph(&self, glyph_id: GlyphId, subpixel_offset: SubpixelOffset) -> bool {
-        self.glyph_to_atlas_index
-            .contains_key(&(glyph_id, subpixel_offset))
+    pub fn has_glyph(&self, cache_key: cosmic_text::CacheKey) -> bool {
+        self.glyph_to_atlas_index.contains_key(&cache_key)
     }
 
     pub fn add_glyph(
         &mut self,
         textures: &mut Assets<Image>,
         texture_atlases: &mut Assets<TextureAtlas>,
-        glyph_id: GlyphId,
-        subpixel_offset: SubpixelOffset,
+        cache_key: cosmic_text::CacheKey,
         texture: &Image,
+        offset: IVec2,
     ) -> bool {
         let texture_atlas = texture_atlases.get_mut(&self.texture_atlas).unwrap();
-        if let Some(index) =
+        if let Some(glyph_index) =
             self.dynamic_texture_atlas_builder
                 .add_texture(texture_atlas, textures, texture)
         {
-            self.glyph_to_atlas_index
-                .insert((glyph_id, subpixel_offset), index);
+            self.glyph_to_atlas_index.insert(
+                cache_key,
+                GlyphAtlasLocation {
+                    glyph_index,
+                    offset,
+                },
+            );
             true
         } else {
             false