Use array of atlases instead of one growing indefinitely.

1 files changed, 20 insertions, 109 deletions

diff --git a/wgpu/src/image/raster.rs b/wgpu/src/image/raster.rs
index 33750cac..32afb749 100644
--- a/wgpu/src/image/raster.rs
+++ b/wgpu/src/image/raster.rs
@@ -1,17 +1,19 @@
+use crate::image::AtlasArray;
 use iced_native::image;
 use std::{
     collections::{HashMap, HashSet},
 };
-use guillotiere::{Allocation, AtlasAllocator, Size};
+use guillotiere::{Allocation, Size};
 use debug_stub_derive::*;
 
 #[derive(DebugStub)]
 pub enum Memory {
     Host(::image::ImageBuffer<::image::Bgra<u8>, Vec<u8>>),
-    Device(
+    Device {
+        layer: u32,
         #[debug_stub="ReplacementValue"]
-        Allocation
-    ),
+        allocation: Allocation,
+    },
     NotFound,
     Invalid,
 }
@@ -20,7 +22,7 @@ impl Memory {
     pub fn dimensions(&self) -> (u32, u32) {
         match self {
             Memory::Host(image) => image.dimensions(),
-            Memory::Device(allocation) => {
+            Memory::Device { allocation, .. } => {
                 let size = &allocation.rectangle.size();
                 (size.width as u32, size.height as u32)
             },
@@ -75,8 +77,7 @@ impl Cache {
         handle: &image::Handle,
         device: &wgpu::Device,
         encoder: &mut wgpu::CommandEncoder,
-        allocator: &mut AtlasAllocator,
-        atlas: &mut wgpu::Texture,
+        atlas_array: &mut AtlasArray,
     ) -> &Memory {
         let _ = self.load(handle);
 
@@ -86,119 +87,29 @@ impl Cache {
             let (width, height) = image.dimensions();
             let size = Size::new(width as i32, height as i32);
 
-            let old_atlas_size = allocator.size();
-            let allocation;
+            let (layer, allocation) = atlas_array.allocate(size).unwrap_or_else(|| {
+                atlas_array.grow(1, device, encoder);
+                atlas_array.allocate(size).unwrap()
+            });
 
-            loop {
-                if let Some(a) = allocator.allocate(size) {
-                    allocation = a;
-                    break;
-                }
-
-                allocator.grow(allocator.size() * 2);
-            }
+            let flat_samples = image.as_flat_samples();
+            let slice = flat_samples.as_slice();
 
-            let new_atlas_size = allocator.size();
-
-            if new_atlas_size != old_atlas_size {
-                let new_atlas = device.create_texture(&wgpu::TextureDescriptor {
-                    size: wgpu::Extent3d {
-                        width: new_atlas_size.width as u32,
-                        height: new_atlas_size.height as u32,
-                        depth: 1,
-                    },
-                    array_layer_count: 1,
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: wgpu::TextureFormat::Bgra8UnormSrgb,
-                    usage: wgpu::TextureUsage::COPY_DST
-                        | wgpu::TextureUsage::COPY_SRC
-                        | wgpu::TextureUsage::SAMPLED,
-                });
-
-                encoder.copy_texture_to_texture(
-                    wgpu::TextureCopyView {
-                        texture: atlas,
-                        array_layer: 0,
-                        mip_level: 0,
-                        origin: wgpu::Origin3d {
-                            x: 0.0,
-                            y: 0.0,
-                            z: 0.0,
-                        },
-                    },
-                    wgpu::TextureCopyView {
-                        texture: &new_atlas,
-                        array_layer: 0,
-                        mip_level: 0,
-                        origin: wgpu::Origin3d {
-                            x: 0.0,
-                            y: 0.0,
-                            z: 0.0,
-                        },
-                    },
-                    wgpu::Extent3d {
-                        width: old_atlas_size.width as u32,
-                        height: old_atlas_size.height as u32,
-                        depth: 1,
-                    }
-                );
-
-                *atlas = new_atlas;
-            }
+            atlas_array.upload(slice, layer, &allocation, device, encoder);
 
-            let extent = wgpu::Extent3d {
-                width,
-                height,
-                depth: 1,
-            };
-
-            let temp_buf = {
-                let flat_samples = image.as_flat_samples();
-                let slice = flat_samples.as_slice();
-
-                device
-                    .create_buffer_mapped(
-                        slice.len(),
-                        wgpu::BufferUsage::COPY_SRC,
-                    )
-                    .fill_from_slice(slice)
-            };
-
-            encoder.copy_buffer_to_texture(
-                wgpu::BufferCopyView {
-                    buffer: &temp_buf,
-                    offset: 0,
-                    row_pitch: 4 * width,
-                    image_height: height,
-                },
-                wgpu::TextureCopyView {
-                    texture: atlas,
-                    array_layer: 0,
-                    mip_level: 0,
-                    origin: wgpu::Origin3d {
-                        x: allocation.rectangle.min.x as f32,
-                        y: allocation.rectangle.min.y as f32,
-                        z: 0.0,
-                    },
-                },
-                extent,
-            );
-
-            *memory = Memory::Device(allocation);
+            *memory = Memory::Device { layer, allocation };
         }
 
         memory
     }
 
-    pub fn trim(&mut self, allocator: &mut AtlasAllocator) {
+    pub fn trim(&mut self, atlas_array: &mut AtlasArray) {
         let hits = &self.hits;
 
-        for (id, mem) in &mut self.map {
-            if let Memory::Device(allocation) = mem {
+        for (id, mem) in &self.map {
+            if let Memory::Device { layer, allocation } = mem {
                 if !hits.contains(&id) {
-                    allocator.deallocate(allocation.id);
+                    atlas_array.deallocate(*layer, allocation);
                 }
             }
         }