Replace unwrap() calls with proper error handling in font_altas (bevyengine#21790)

# Objective

- Replace unwrap() calls with proper error handling in `font_atlas.rs`'s
`add_glyph()` and `add_glyph_to_atlas()` to prevent panics and provide
clear information.

## Solution

- Add new variants to the TextError enum to provide more specific error
messages.

Author: Breakdown-Dog

crates/bevy_sprite/src/text2d.rs

@@ -253,7 +253,13 @@ pub fn update_text2d_layout(
                     // queue for further processing
                     queue.insert(entity);
                 }
-                Err(e @ (TextError::FailedToAddGlyph(_) | TextError::FailedToGetGlyphImage(_))) => {
+                Err(
+                    e @ (TextError::FailedToAddGlyph(_)
+                    | TextError::FailedToGetGlyphImage(_)
+                    | TextError::MissingAtlasLayout
+                    | TextError::MissingAtlasTexture
+                    | TextError::InconsistentAtlasState),
+                ) => {
                     panic!("Fatal error when processing text: {e}.");
                 }
                 Ok(()) => {

crates/bevy_text/src/error.rs

@@ -14,4 +14,13 @@ pub enum TextError {
     /// Failed to get scaled glyph image for cache key
     #[error("failed to get scaled glyph image for cache key: {0:?}")]
     FailedToGetGlyphImage(CacheKey),
+    /// Missing texture atlas layout for the font
+    #[error("missing texture atlas layout for the font")]
+    MissingAtlasLayout,
+    /// Missing texture for the font atlas
+    #[error("missing texture for the font atlas")]
+    MissingAtlasTexture,
+    /// Failed to find glyph in atlas after it was added
+    #[error("failed to find glyph in atlas after it was added")]
+    InconsistentAtlasState,
 }

crates/bevy_text/src/font_atlas.rs

@@ -87,8 +87,12 @@ impl FontAtlas {
         texture: &Image,
         offset: IVec2,
     ) -> Result<(), TextError> {
-        let atlas_layout = atlas_layouts.get_mut(&self.texture_atlas).unwrap();
-        let atlas_texture = textures.get_mut(&self.texture).unwrap();
+        let atlas_layout = atlas_layouts
+            .get_mut(&self.texture_atlas)
+            .ok_or(TextError::MissingAtlasLayout)?;
+        let atlas_texture = textures
+            .get_mut(&self.texture)
+            .ok_or(TextError::MissingAtlasTexture)?;
 
         if let Ok(glyph_index) =
             self.dynamic_texture_atlas_builder
@@ -154,23 +158,27 @@ pub fn add_glyph_to_atlas(
             .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(
+
+        let mut new_atlas = FontAtlas::new(
             textures,
             texture_atlases,
             UVec2::splat(containing),
             font_smoothing,
-        ));
+        );
 
-        font_atlases.last_mut().unwrap().add_glyph(
+        new_atlas.add_glyph(
             textures,
             texture_atlases,
             physical_glyph.cache_key,
             &glyph_texture,
             offset,
         )?;
+
+        font_atlases.push(new_atlas);
     }
 
-    Ok(get_glyph_atlas_info(font_atlases, physical_glyph.cache_key).unwrap())
+    get_glyph_atlas_info(font_atlases, physical_glyph.cache_key)
+        .ok_or(TextError::InconsistentAtlasState)
 }
 
 /// Get the texture of the glyph as a rendered image, and its offset

crates/bevy_ui/src/widget/text.rs

@@ -260,7 +260,13 @@ fn create_text_measure<'a>(
             // Try again next frame
             text_flags.needs_measure_fn = true;
         }
-        Err(e @ (TextError::FailedToAddGlyph(_) | TextError::FailedToGetGlyphImage(_))) => {
+        Err(
+            e @ (TextError::FailedToAddGlyph(_)
+            | TextError::FailedToGetGlyphImage(_)
+            | TextError::MissingAtlasLayout
+            | TextError::MissingAtlasTexture
+            | TextError::InconsistentAtlasState),
+        ) => {
             panic!("Fatal error when processing text: {e}.");
         }
     };
@@ -372,7 +378,13 @@ fn queue_text(
             // There was an error processing the text layout, try again next frame
             text_flags.needs_recompute = true;
         }
-        Err(e @ (TextError::FailedToAddGlyph(_) | TextError::FailedToGetGlyphImage(_))) => {
+        Err(
+            e @ (TextError::FailedToAddGlyph(_)
+            | TextError::FailedToGetGlyphImage(_)
+            | TextError::MissingAtlasLayout
+            | TextError::MissingAtlasTexture
+            | TextError::InconsistentAtlasState),
+        ) => {
             panic!("Fatal error when processing text: {e}.");
         }
         Ok(()) => {