Remove FontAtlasSets (#21345)

# Objective

The `FontAtlasSets` resource contains a map from `AssetId<Font>`s to
`FontAtlasSet`s.
`FontAtlasSet` has another map from a `FontAtlasKey` (tuple of the font
size bit cast into a `u32` and `FontSmoothing`) to a vec that contains
the actual font atlases for the font. The redirection through the
additional map doesn't serve much purpose, only individual fonts are
looked up (except when freeing unused fonts), not the set of all atlases
for a particular font face.

## Solution
* Remove `FontAtlasSet`. 
* Rename `FontAtlasSets` to `FontAtlasSet`.
* Add `AssetId<Font>` to `FontAtlasKey`.
* Change the font atlas map to a `HashMap<FontAtlasKey, Vec<FontAtlas>>`
* Move the `FontAtlasSet` methods `add_glyph_to_atlas`,
`get_glyph_atlas_info`, and `get_outlined_glyph_texture` into the
`font_atlas` module and rework them into free functions.
* Change `FontAtlasSet` into a newtype around the map and remove the
manual method implementations in favour of deriving `Deref` and
`DerefMut`.

We could consider renaming `FontAlasSet` to `FontAtlasMap`, but it
doesn't seem necessary, and mathematically a map is a set so it's not
incorrect.

## Testing

The output from all of the text examples should be unchanged.

Naive benchmarks suggest this is a modest improvement in performance at
a very high load (5% ish), but this is more about reducing complexity to
make more significant optimisations possible. Freeing the unused atlases
when a font asset is removed will be slower, it has to filter all the
font atlas vecs now instead of just removing the entry for the font
asset, but this isn't done very often and the number of entries should
be relatively low.

---------

Co-authored-by: Dimitrios Loukadakis <[email protected]>

Author: ickshonpe

crates/bevy_sprite/src/lib.rs

@@ -87,7 +87,7 @@ impl Plugin for SpritePlugin {
                 bevy_text::detect_text_needs_rerender::<Text2d>,
                 update_text2d_layout
                     .after(bevy_camera::CameraUpdateSystems)
-                    .after(bevy_text::remove_dropped_font_atlas_sets),
+                    .after(bevy_text::free_unused_font_atlases_system),
                 calculate_bounds_text2d.in_set(VisibilitySystems::CalculateBounds),
             )
                 .chain()

crates/bevy_sprite/src/text2d.rs

@@ -20,7 +20,7 @@ use bevy_image::prelude::*;
 use bevy_math::{FloatOrd, Vec2, Vec3};
 use bevy_reflect::{prelude::ReflectDefault, Reflect};
 use bevy_text::{
-    ComputedTextBlock, CosmicFontSystem, Font, FontAtlasSets, LineBreak, SwashCache, TextBounds,
+    ComputedTextBlock, CosmicFontSystem, Font, FontAtlasSet, LineBreak, SwashCache, TextBounds,
     TextColor, TextError, TextFont, TextLayout, TextLayoutInfo, TextPipeline, TextReader, TextRoot,
     TextSpanAccess, TextWriter,
 };
@@ -165,7 +165,7 @@ pub fn update_text2d_layout(
     fonts: Res<Assets<Font>>,
     camera_query: Query<(&Camera, &VisibleEntities, Option<&RenderLayers>)>,
     mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
-    mut font_atlas_sets: ResMut<FontAtlasSets>,
+    mut font_atlas_set: ResMut<FontAtlasSet>,
     mut text_pipeline: ResMut<TextPipeline>,
     mut text_query: Query<(
         Entity,
@@ -240,7 +240,7 @@ pub fn update_text2d_layout(
                 scale_factor as f64,
                 &block,
                 text_bounds,
-                &mut font_atlas_sets,
+                &mut font_atlas_set,
                 &mut texture_atlases,
                 &mut textures,
                 computed.as_mut(),
@@ -321,7 +321,7 @@ mod tests {
         app.init_resource::<Assets<Font>>()
             .init_resource::<Assets<Image>>()
             .init_resource::<Assets<TextureAtlasLayout>>()
-            .init_resource::<FontAtlasSets>()
+            .init_resource::<FontAtlasSet>()
             .init_resource::<TextPipeline>()
             .init_resource::<CosmicFontSystem>()
             .init_resource::<SwashCache>()

crates/bevy_text/src/font_atlas.rs

@@ -2,9 +2,9 @@ use bevy_asset::{Assets, Handle, RenderAssetUsages};
 use bevy_image::{prelude::*, ImageSampler, ToExtents};
 use bevy_math::{IVec2, UVec2};
 use bevy_platform::collections::HashMap;
-use wgpu_types::{TextureDimension, TextureFormat};
+use wgpu_types::{Extent3d, TextureDimension, TextureFormat};
 
-use crate::{FontSmoothing, GlyphAtlasLocation, TextError};
+use crate::{FontSmoothing, GlyphAtlasInfo, GlyphAtlasLocation, TextError};
 
 /// Rasterized glyphs are cached, stored in, and retrieved from, a `FontAtlas`.
 ///
@@ -118,3 +118,139 @@ impl core::fmt::Debug for FontAtlas {
             .finish()
     }
 }
+
+/// Adds the given subpixel-offset glyph to the given font atlases
+pub fn add_glyph_to_atlas(
+    font_atlases: &mut Vec<FontAtlas>,
+    texture_atlases: &mut Assets<TextureAtlasLayout>,
+    textures: &mut Assets<Image>,
+    font_system: &mut cosmic_text::FontSystem,
+    swash_cache: &mut cosmic_text::SwashCache,
+    layout_glyph: &cosmic_text::LayoutGlyph,
+    font_smoothing: FontSmoothing,
+) -> Result<GlyphAtlasInfo, TextError> {
+    let physical_glyph = layout_glyph.physical((0., 0.), 1.0);
+
+    let (glyph_texture, offset) =
+        get_outlined_glyph_texture(font_system, swash_cache, &physical_glyph, font_smoothing)?;
+    let mut add_char_to_font_atlas = |atlas: &mut FontAtlas| -> Result<(), TextError> {
+        atlas.add_glyph(
+            textures,
+            texture_atlases,
+            physical_glyph.cache_key,
+            &glyph_texture,
+            offset,
+        )
+    };
+    if !font_atlases
+        .iter_mut()
+        .any(|atlas| add_char_to_font_atlas(atlas).is_ok())
+    {
+        // Find the largest dimension of the glyph, either its width or its height
+        let glyph_max_size: u32 = glyph_texture
+            .texture_descriptor
+            .size
+            .height
+            .max(glyph_texture.width());
+        // Pick the higher of 512 or the smallest power of 2 greater than glyph_max_size
+        let containing = (1u32 << (32 - glyph_max_size.leading_zeros())).max(512);
+        font_atlases.push(FontAtlas::new(
+            textures,
+            texture_atlases,
+            UVec2::splat(containing),
+            font_smoothing,
+        ));
+
+        font_atlases.last_mut().unwrap().add_glyph(
+            textures,
+            texture_atlases,
+            physical_glyph.cache_key,
+            &glyph_texture,
+            offset,
+        )?;
+    }
+
+    Ok(get_glyph_atlas_info(font_atlases, physical_glyph.cache_key).unwrap())
+}
+
+/// Get the texture of the glyph as a rendered image, and its offset
+pub fn get_outlined_glyph_texture(
+    font_system: &mut cosmic_text::FontSystem,
+    swash_cache: &mut cosmic_text::SwashCache,
+    physical_glyph: &cosmic_text::PhysicalGlyph,
+    font_smoothing: FontSmoothing,
+) -> Result<(Image, IVec2), TextError> {
+    // NOTE: Ideally, we'd ask COSMIC Text to honor the font smoothing setting directly.
+    // However, since it currently doesn't support that, we render the glyph with antialiasing
+    // and apply a threshold to the alpha channel to simulate the effect.
+    //
+    // This has the side effect of making regular vector fonts look quite ugly when font smoothing
+    // is turned off, but for fonts that are specifically designed for pixel art, it works well.
+    //
+    // See: https://github.com/pop-os/cosmic-text/issues/279
+    let image = swash_cache
+        .get_image_uncached(font_system, physical_glyph.cache_key)
+        .ok_or(TextError::FailedToGetGlyphImage(physical_glyph.cache_key))?;
+
+    let cosmic_text::Placement {
+        left,
+        top,
+        width,
+        height,
+    } = image.placement;
+
+    let data = match image.content {
+        cosmic_text::SwashContent::Mask => {
+            if font_smoothing == FontSmoothing::None {
+                image
+                    .data
+                    .iter()
+                    // Apply a 50% threshold to the alpha channel
+                    .flat_map(|a| [255, 255, 255, if *a > 127 { 255 } else { 0 }])
+                    .collect()
+            } else {
+                image
+                    .data
+                    .iter()
+                    .flat_map(|a| [255, 255, 255, *a])
+                    .collect()
+            }
+        }
+        cosmic_text::SwashContent::Color => image.data,
+        cosmic_text::SwashContent::SubpixelMask => {
+            // TODO: implement
+            todo!()
+        }
+    };
+
+    Ok((
+        Image::new(
+            Extent3d {
+                width,
+                height,
+                depth_or_array_layers: 1,
+            },
+            TextureDimension::D2,
+            data,
+            TextureFormat::Rgba8UnormSrgb,
+            RenderAssetUsages::MAIN_WORLD,
+        ),
+        IVec2::new(left, top),
+    ))
+}
+
+/// Generates the [`GlyphAtlasInfo`] for the given subpixel-offset glyph.
+pub fn get_glyph_atlas_info(
+    font_atlases: &mut [FontAtlas],
+    cache_key: cosmic_text::CacheKey,
+) -> Option<GlyphAtlasInfo> {
+    font_atlases.iter().find_map(|atlas| {
+        atlas
+            .get_glyph_index(cache_key)
+            .map(|location| GlyphAtlasInfo {
+                location,
+                texture_atlas: atlas.texture_atlas.id(),
+                texture: atlas.texture.id(),
+            })
+    })
+}