From 080cb4543078d80de0d6a5ed6c464ff66b2d72a0 Mon Sep 17 00:00:00 2001
From: verzuz <verzuz@gmx.de>
Date: Mon, 14 Sep 2020 21:23:25 +0200
Subject: [PATCH 1/4] manage font_atlas overflow

---
 crates/bevy_text/src/font_atlas.rs     |  5 +++--
 crates/bevy_text/src/font_atlas_set.rs | 30 +++++++++++++++++---------
 examples/ui/font_atlas_debug.rs        | 27 +++++++++++++----------
 3 files changed, 39 insertions(+), 23 deletions(-)

diff --git a/crates/bevy_text/src/font_atlas.rs b/crates/bevy_text/src/font_atlas.rs
index 24c67d53cbdca..9c39fcf89eede 100644
--- a/crates/bevy_text/src/font_atlas.rs
+++ b/crates/bevy_text/src/font_atlas.rs
@@ -39,15 +39,16 @@ impl FontAtlas {
         texture_atlases: &mut Assets<TextureAtlas>,
         character: char,
         texture: &Texture,
-    ) {
+    ) -> bool {
         let texture_atlas = texture_atlases.get_mut(&self.texture_atlas).unwrap();
         if let Some(index) =
             self.dynamic_texture_atlas_builder
                 .add_texture(texture_atlas, textures, texture)
         {
             self.glyph_to_index.insert(character, index);
+            true
         } else {
-            panic!("ran out of space in font atlas");
+            false
         }
     }
 }
diff --git a/crates/bevy_text/src/font_atlas_set.rs b/crates/bevy_text/src/font_atlas_set.rs
index 581877d110774..e45b16ab84295 100644
--- a/crates/bevy_text/src/font_atlas_set.rs
+++ b/crates/bevy_text/src/font_atlas_set.rs
@@ -13,7 +13,7 @@ type FontSizeKey = FloatOrd;
 #[derive(Default)]
 pub struct FontAtlasSet {
     font: Handle<Font>,
-    font_atlases: HashMap<FontSizeKey, FontAtlas>,
+    font_atlases: HashMap<FontSizeKey, Vec<FontAtlas>>,
 }
 
 #[derive(Debug)]
@@ -30,7 +30,7 @@ impl FontAtlasSet {
         }
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = (&FontSizeKey, &FontAtlas)> {
+    pub fn iter(&self) -> impl Iterator<Item = (&FontSizeKey, &Vec<FontAtlas>)> {
         self.font_atlases.iter()
     }
 
@@ -38,7 +38,7 @@ impl FontAtlasSet {
         self.font_atlases
             .get(&FloatOrd(font_size))
             .map_or(false, |font_atlas| {
-                font_atlas.get_char_index(character).is_some()
+                font_atlas.iter().any( |atlas| atlas.get_char_index(character).is_some() )
             })
     }
 
@@ -55,7 +55,7 @@ impl FontAtlasSet {
         let font_atlas = self
             .font_atlases
             .entry(FloatOrd(font_size))
-            .or_insert_with(|| FontAtlas::new(textures, texture_atlases, Vec2::new(512.0, 512.0)));
+            .or_insert_with(|| vec![FontAtlas::new(textures, texture_atlases, Vec2::new(512.0, 512.0))]);
 
         let mut last_glyph: Option<Glyph> = None;
         let mut width = 0.0;
@@ -67,10 +67,16 @@ impl FontAtlasSet {
             if let Some(last_glyph) = last_glyph.take() {
                 width += scaled_font.kern(last_glyph.id, glyph.id);
             }
-            if font_atlas.get_char_index(character).is_none() {
+            if !font_atlas.iter().any( |atlas| atlas.get_char_index(character).is_some() ) {
                 if let Some(outlined_glyph) = scaled_font.outline_glyph(glyph.clone()) {
                     let glyph_texture = Font::get_outlined_glyph_texture(outlined_glyph);
-                    font_atlas.add_char(textures, texture_atlases, character, &glyph_texture);
+
+                    if !font_atlas.iter_mut().any( | atlas | atlas.add_char(textures, texture_atlases, character, &glyph_texture) ) {
+                        font_atlas.push(FontAtlas::new(textures, texture_atlases, Vec2::new(512.0, 512.0)));
+                        if !font_atlas.last_mut().unwrap().add_char(textures, texture_atlases, character, &glyph_texture) {
+                            panic!("could not add character to newly created fontatlas");
+                        }
+                    }
                 }
             }
             width += scaled_font.h_advance(glyph.id);
@@ -84,12 +90,16 @@ impl FontAtlasSet {
         self.font_atlases
             .get(&FloatOrd(font_size))
             .and_then(|font_atlas| {
-                font_atlas
-                    .get_char_index(character)
-                    .map(|char_index| GlyphAtlasInfo {
-                        texture_atlas: font_atlas.texture_atlas,
+                if let Some(atlas) = font_atlas.iter().find(|atlas| atlas.get_char_index(character).is_some()) {
+                    let char_index = atlas.get_char_index(character).unwrap();
+                    Some(GlyphAtlasInfo {
+                        texture_atlas: atlas.texture_atlas,
                         char_index,
                     })
+                }
+                else {
+                    None
+                }
             })
     }
 }
diff --git a/examples/ui/font_atlas_debug.rs b/examples/ui/font_atlas_debug.rs
index cb30d82e3a2ab..a0e3061b1f787 100644
--- a/examples/ui/font_atlas_debug.rs
+++ b/examples/ui/font_atlas_debug.rs
@@ -12,7 +12,7 @@ fn main() {
 }
 
 struct State {
-    added: bool,
+    atlas_count: u32,
     handle: Handle<Font>,
     timer: Timer,
 }
@@ -20,7 +20,7 @@ struct State {
 impl Default for State {
     fn default() -> Self {
         Self {
-            added: false,
+            atlas_count: 0,
             handle: Handle::default(),
             timer: Timer::from_seconds(0.05, true),
         }
@@ -34,20 +34,21 @@ fn atlas_render_system(
     font_atlas_sets: Res<Assets<FontAtlasSet>>,
     texture_atlases: Res<Assets<TextureAtlas>>,
 ) {
-    if state.added {
-        return;
-    }
     if let Some(set) = font_atlas_sets.get(&state.handle.as_handle::<FontAtlasSet>()) {
         if let Some((_size, font_atlas)) = set.iter().next() {
-            state.added = true;
-            let texture_atlas = texture_atlases.get(&font_atlas.texture_atlas).unwrap();
+            let x_offset = state.atlas_count as f32;
+            if state.atlas_count == font_atlas.len() as u32 {
+                return;
+            }
+            let texture_atlas = texture_atlases.get(&font_atlas[state.atlas_count as usize].texture_atlas).unwrap();
+            state.atlas_count += 1;
             commands.spawn(ImageComponents {
                 material: materials.add(texture_atlas.texture.into()),
                 style: Style {
                     position_type: PositionType::Absolute,
                     position: Rect {
                         top: Val::Px(0.0),
-                        left: Val::Px(0.0),
+                        left: Val::Px(512.0 * x_offset),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -61,9 +62,13 @@ fn atlas_render_system(
 fn text_update_system(mut state: ResMut<State>, time: Res<Time>, mut query: Query<&mut Text>) {
     for mut text in &mut query.iter() {
         state.timer.tick(time.delta_seconds);
-        if state.timer.finished {
-            text.value = format!("{}", rand::random::<u8>() as char);
-            state.timer.reset();
+        let c = rand::random::<u8>() as char;
+        if !text.value.contains(c)
+        {
+            if state.timer.finished {
+                text.value = format!("{}{}", text.value, c);
+                state.timer.reset();
+            }
         }
     }
 }

From 138e17f39b4c003f1f6f987a79fc1bf863f34c76 Mon Sep 17 00:00:00 2001
From: verzuz <verzuz@gmx.de>
Date: Tue, 15 Sep 2020 17:17:49 +0200
Subject: [PATCH 2/4] cargo fmt

---
 crates/bevy_text/src/font_atlas_set.rs | 42 ++++++++++++++++++++------
 examples/ui/font_atlas_debug.rs        |  7 +++--
 2 files changed, 37 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_text/src/font_atlas_set.rs b/crates/bevy_text/src/font_atlas_set.rs
index e45b16ab84295..1d671ccfedd1c 100644
--- a/crates/bevy_text/src/font_atlas_set.rs
+++ b/crates/bevy_text/src/font_atlas_set.rs
@@ -38,7 +38,9 @@ impl FontAtlasSet {
         self.font_atlases
             .get(&FloatOrd(font_size))
             .map_or(false, |font_atlas| {
-                font_atlas.iter().any( |atlas| atlas.get_char_index(character).is_some() )
+                font_atlas
+                    .iter()
+                    .any(|atlas| atlas.get_char_index(character).is_some())
             })
     }
 
@@ -55,7 +57,13 @@ impl FontAtlasSet {
         let font_atlas = self
             .font_atlases
             .entry(FloatOrd(font_size))
-            .or_insert_with(|| vec![FontAtlas::new(textures, texture_atlases, Vec2::new(512.0, 512.0))]);
+            .or_insert_with(|| {
+                vec![FontAtlas::new(
+                    textures,
+                    texture_atlases,
+                    Vec2::new(512.0, 512.0),
+                )]
+            });
 
         let mut last_glyph: Option<Glyph> = None;
         let mut width = 0.0;
@@ -67,13 +75,27 @@ impl FontAtlasSet {
             if let Some(last_glyph) = last_glyph.take() {
                 width += scaled_font.kern(last_glyph.id, glyph.id);
             }
-            if !font_atlas.iter().any( |atlas| atlas.get_char_index(character).is_some() ) {
+            if !font_atlas
+                .iter()
+                .any(|atlas| atlas.get_char_index(character).is_some())
+            {
                 if let Some(outlined_glyph) = scaled_font.outline_glyph(glyph.clone()) {
                     let glyph_texture = Font::get_outlined_glyph_texture(outlined_glyph);
 
-                    if !font_atlas.iter_mut().any( | atlas | atlas.add_char(textures, texture_atlases, character, &glyph_texture) ) {
-                        font_atlas.push(FontAtlas::new(textures, texture_atlases, Vec2::new(512.0, 512.0)));
-                        if !font_atlas.last_mut().unwrap().add_char(textures, texture_atlases, character, &glyph_texture) {
+                    if !font_atlas.iter_mut().any(|atlas| {
+                        atlas.add_char(textures, texture_atlases, character, &glyph_texture)
+                    }) {
+                        font_atlas.push(FontAtlas::new(
+                            textures,
+                            texture_atlases,
+                            Vec2::new(512.0, 512.0),
+                        ));
+                        if !font_atlas.last_mut().unwrap().add_char(
+                            textures,
+                            texture_atlases,
+                            character,
+                            &glyph_texture,
+                        ) {
                             panic!("could not add character to newly created fontatlas");
                         }
                     }
@@ -90,14 +112,16 @@ impl FontAtlasSet {
         self.font_atlases
             .get(&FloatOrd(font_size))
             .and_then(|font_atlas| {
-                if let Some(atlas) = font_atlas.iter().find(|atlas| atlas.get_char_index(character).is_some()) {
+                if let Some(atlas) = font_atlas
+                    .iter()
+                    .find(|atlas| atlas.get_char_index(character).is_some())
+                {
                     let char_index = atlas.get_char_index(character).unwrap();
                     Some(GlyphAtlasInfo {
                         texture_atlas: atlas.texture_atlas,
                         char_index,
                     })
-                }
-                else {
+                } else {
                     None
                 }
             })
diff --git a/examples/ui/font_atlas_debug.rs b/examples/ui/font_atlas_debug.rs
index a0e3061b1f787..18ab85e03b2fd 100644
--- a/examples/ui/font_atlas_debug.rs
+++ b/examples/ui/font_atlas_debug.rs
@@ -40,7 +40,9 @@ fn atlas_render_system(
             if state.atlas_count == font_atlas.len() as u32 {
                 return;
             }
-            let texture_atlas = texture_atlases.get(&font_atlas[state.atlas_count as usize].texture_atlas).unwrap();
+            let texture_atlas = texture_atlases
+                .get(&font_atlas[state.atlas_count as usize].texture_atlas)
+                .unwrap();
             state.atlas_count += 1;
             commands.spawn(ImageComponents {
                 material: materials.add(texture_atlas.texture.into()),
@@ -63,8 +65,7 @@ fn text_update_system(mut state: ResMut<State>, time: Res<Time>, mut query: Quer
     for mut text in &mut query.iter() {
         state.timer.tick(time.delta_seconds);
         let c = rand::random::<u8>() as char;
-        if !text.value.contains(c)
-        {
+        if !text.value.contains(c) {
             if state.timer.finished {
                 text.value = format!("{}{}", text.value, c);
                 state.timer.reset();

From 7605114b96796ad4c5acc022abbf3879a13f12be Mon Sep 17 00:00:00 2001
From: verzuz <verzuz@gmx.de>
Date: Tue, 15 Sep 2020 20:40:53 +0200
Subject: [PATCH 3/4] fix clippy

---
 crates/bevy_text/src/font_atlas_set.rs | 6 +++---
 examples/ui/font_atlas_debug.rs        | 8 +++-----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_text/src/font_atlas_set.rs b/crates/bevy_text/src/font_atlas_set.rs
index 1d671ccfedd1c..ff3c2ba2ebe92 100644
--- a/crates/bevy_text/src/font_atlas_set.rs
+++ b/crates/bevy_text/src/font_atlas_set.rs
@@ -81,10 +81,10 @@ impl FontAtlasSet {
             {
                 if let Some(outlined_glyph) = scaled_font.outline_glyph(glyph.clone()) {
                     let glyph_texture = Font::get_outlined_glyph_texture(outlined_glyph);
-
-                    if !font_atlas.iter_mut().any(|atlas| {
+                    let add_char_to_fontatlas = |atlas: &mut FontAtlas| -> bool {
                         atlas.add_char(textures, texture_atlases, character, &glyph_texture)
-                    }) {
+                    };
+                    if !font_atlas.iter_mut().any(add_char_to_fontatlas) {
                         font_atlas.push(FontAtlas::new(
                             textures,
                             texture_atlases,
diff --git a/examples/ui/font_atlas_debug.rs b/examples/ui/font_atlas_debug.rs
index 18ab85e03b2fd..d1d8022203229 100644
--- a/examples/ui/font_atlas_debug.rs
+++ b/examples/ui/font_atlas_debug.rs
@@ -65,11 +65,9 @@ fn text_update_system(mut state: ResMut<State>, time: Res<Time>, mut query: Quer
     for mut text in &mut query.iter() {
         state.timer.tick(time.delta_seconds);
         let c = rand::random::<u8>() as char;
-        if !text.value.contains(c) {
-            if state.timer.finished {
-                text.value = format!("{}{}", text.value, c);
-                state.timer.reset();
-            }
+        if !text.value.contains(c) && state.timer.finished {
+            text.value = format!("{}{}", text.value, c);
+            state.timer.reset();
         }
     }
 }

From d080462e5f97fc9e5c31fab09f96d134c5867842 Mon Sep 17 00:00:00 2001
From: verzuz <verzuz@gmx.de>
Date: Tue, 15 Sep 2020 21:31:39 +0200
Subject: [PATCH 4/4] fix comments from review

---
 crates/bevy_text/src/font_atlas_set.rs | 31 +++++++++++++-------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/crates/bevy_text/src/font_atlas_set.rs b/crates/bevy_text/src/font_atlas_set.rs
index ff3c2ba2ebe92..a38e3aaacf58f 100644
--- a/crates/bevy_text/src/font_atlas_set.rs
+++ b/crates/bevy_text/src/font_atlas_set.rs
@@ -54,7 +54,7 @@ impl FontAtlasSet {
     ) -> f32 {
         let font = fonts.get(&self.font).unwrap();
         let scaled_font = ab_glyph::Font::as_scaled(&font.font, font_size);
-        let font_atlas = self
+        let font_atlases = self
             .font_atlases
             .entry(FloatOrd(font_size))
             .or_insert_with(|| {
@@ -75,28 +75,28 @@ impl FontAtlasSet {
             if let Some(last_glyph) = last_glyph.take() {
                 width += scaled_font.kern(last_glyph.id, glyph.id);
             }
-            if !font_atlas
+            if !font_atlases
                 .iter()
                 .any(|atlas| atlas.get_char_index(character).is_some())
             {
                 if let Some(outlined_glyph) = scaled_font.outline_glyph(glyph.clone()) {
                     let glyph_texture = Font::get_outlined_glyph_texture(outlined_glyph);
-                    let add_char_to_fontatlas = |atlas: &mut FontAtlas| -> bool {
+                    let add_char_to_font_atlas = |atlas: &mut FontAtlas| -> bool {
                         atlas.add_char(textures, texture_atlases, character, &glyph_texture)
                     };
-                    if !font_atlas.iter_mut().any(add_char_to_fontatlas) {
-                        font_atlas.push(FontAtlas::new(
+                    if !font_atlases.iter_mut().any(add_char_to_font_atlas) {
+                        font_atlases.push(FontAtlas::new(
                             textures,
                             texture_atlases,
                             Vec2::new(512.0, 512.0),
                         ));
-                        if !font_atlas.last_mut().unwrap().add_char(
+                        if !font_atlases.last_mut().unwrap().add_char(
                             textures,
                             texture_atlases,
                             character,
                             &glyph_texture,
                         ) {
-                            panic!("could not add character to newly created fontatlas");
+                            panic!("could not add character to newly created FontAtlas");
                         }
                     }
                 }
@@ -112,18 +112,17 @@ impl FontAtlasSet {
         self.font_atlases
             .get(&FloatOrd(font_size))
             .and_then(|font_atlas| {
-                if let Some(atlas) = font_atlas
+                font_atlas
                     .iter()
-                    .find(|atlas| atlas.get_char_index(character).is_some())
-                {
-                    let char_index = atlas.get_char_index(character).unwrap();
-                    Some(GlyphAtlasInfo {
-                        texture_atlas: atlas.texture_atlas,
+                    .find_map(|atlas| {
+                        atlas
+                            .get_char_index(character)
+                            .map(|char_index| (char_index, atlas.texture_atlas))
+                    })
+                    .map(|(char_index, texture_atlas)| GlyphAtlasInfo {
+                        texture_atlas,
                         char_index,
                     })
-                } else {
-                    None
-                }
             })
     }
 }