2 files changed, 77 insertions, 32 deletions

diff --git a/wgpu/src/backend.rs b/wgpu/src/backend.rs
index d07898f7..7f44fafa 100644
--- a/wgpu/src/backend.rs
+++ b/wgpu/src/backend.rs
@@ -93,10 +93,17 @@ impl Backend {
             encoder,
             scale_factor,
             transformation,
-            target_size,
             &layers,
         );
 
+        while !self.prepare_text(
+            device,
+            queue,
+            scale_factor,
+            target_size,
+            &layers,
+        ) {}
+
         self.render(
             device,
             encoder,
@@ -115,6 +122,38 @@ impl Backend {
         self.image_pipeline.end_frame(device, queue, encoder);
     }
 
+    fn prepare_text(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        scale_factor: f32,
+        target_size: Size<u32>,
+        layers: &[Layer<'_>],
+    ) -> bool {
+        for layer in layers {
+            let bounds = (layer.bounds * scale_factor).snap();
+
+            if bounds.width < 1 || bounds.height < 1 {
+                continue;
+            }
+
+            if !layer.text.is_empty() {
+                if !self.text_pipeline.prepare(
+                    device,
+                    queue,
+                    &layer.text,
+                    layer.bounds,
+                    scale_factor,
+                    target_size,
+                ) {
+                    return false;
+                }
+            }
+        }
+
+        true
+    }
+
     fn prepare(
         &mut self,
         device: &wgpu::Device,
@@ -122,14 +161,13 @@ impl Backend {
         _encoder: &mut wgpu::CommandEncoder,
         scale_factor: f32,
         transformation: Transformation,
-        target_size: Size<u32>,
         layers: &[Layer<'_>],
     ) {
         for layer in layers {
             let bounds = (layer.bounds * scale_factor).snap();
 
             if bounds.width < 1 || bounds.height < 1 {
-                return;
+                continue;
             }
 
             if !layer.quads.is_empty() {
@@ -170,17 +208,6 @@ impl Backend {
                     );
                 }
             }
-
-            if !layer.text.is_empty() {
-                self.text_pipeline.prepare(
-                    device,
-                    queue,
-                    &layer.text,
-                    layer.bounds,
-                    scale_factor,
-                    target_size,
-                );
-            }
         }
     }
 
diff --git a/wgpu/src/text.rs b/wgpu/src/text.rs
index 655ad987..4406177a 100644
--- a/wgpu/src/text.rs
+++ b/wgpu/src/text.rs
@@ -86,7 +86,7 @@ impl Pipeline {
         bounds: Rectangle,
         scale_factor: f32,
         target_size: Size<u32>,
-    ) {
+    ) -> bool {
         self.system.as_mut().unwrap().with_mut(|fields| {
             if self.renderers.len() <= self.prepare_layer {
                 self.renderers
@@ -165,23 +165,39 @@ impl Pipeline {
                     }
                 });
 
-            renderer
-                .prepare(
-                    device,
-                    queue,
-                    &mut self.atlas,
-                    glyphon::Resolution {
-                        width: target_size.width,
-                        height: target_size.height,
-                    },
-                    text_areas,
-                    glyphon::Color::rgb(0, 0, 0),
-                    &mut glyphon::SwashCache::new(fields.fonts),
-                )
-                .expect("Prepare text sections");
-
-            self.prepare_layer += 1;
-        });
+            let result = renderer.prepare(
+                device,
+                queue,
+                &mut self.atlas,
+                glyphon::Resolution {
+                    width: target_size.width,
+                    height: target_size.height,
+                },
+                text_areas,
+                glyphon::Color::rgb(0, 0, 0),
+                &mut glyphon::SwashCache::new(fields.fonts),
+            );
+
+            match result {
+                Ok(()) => {
+                    self.prepare_layer += 1;
+
+                    true
+                }
+                Err(glyphon::PrepareError::AtlasFull(content_type)) => {
+                    self.prepare_layer = 0;
+
+                    if self.atlas.grow(device, content_type) {
+                        false
+                    } else {
+                        // If the atlas cannot grow, then all bets are off.
+                        // Instead of panicking, we will just pray that the result
+                        // will be somewhat readable...
+                        true
+                    }
+                }
+            }
+        })
     }
 
     pub fn render<'a>(
@@ -205,6 +221,8 @@ impl Pipeline {
     }
 
     pub fn end_frame(&mut self) {
+        self.atlas.trim();
+
         self.system
             .as_mut()
             .unwrap()