Store wgpu::Backend in image::Atlas

wgpu/src/image/atlas.rs

@@ -19,6 +19,7 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct Atlas {
+    backend: wgpu::Backend,
     texture: wgpu::Texture,
     texture_view: wgpu::TextureView,
     texture_bind_group: wgpu::BindGroup,
@@ -79,6 +80,7 @@ impl Atlas {
             });
 
         Atlas {
+            backend,
             texture,
             texture_view,
             texture_bind_group,
@@ -98,7 +100,6 @@ impl Atlas {
     pub fn upload(
         &mut self,
         device: &wgpu::Device,
-        backend: wgpu::Backend,
         encoder: &mut wgpu::CommandEncoder,
         width: u32,
         height: u32,
@@ -110,7 +111,7 @@ impl Atlas {
 
             // We grow the internal texture after allocating if necessary
             let new_layers = self.layers.len() - current_size;
-            self.grow(new_layers, device, backend, encoder);
+            self.grow(new_layers, device, encoder);
 
             entry
         };
@@ -371,7 +372,6 @@ impl Atlas {
         &mut self,
         amount: usize,
         device: &wgpu::Device,
-        backend: wgpu::Backend,
         encoder: &mut wgpu::CommandEncoder,
     ) {
         if amount == 0 {
@@ -383,7 +383,7 @@ impl Atlas {
         // some unused memory on GL, but it's better than not being able to grow the atlas past a depth
         // of 6!
         // https://github.com/gfx-rs/wgpu/blob/004e3efe84a320d9331371ed31fa50baa2414911/wgpu-hal/src/gles/mod.rs#L371
-        let depth_or_array_layers = match backend {
+        let depth_or_array_layers = match self.backend {
             wgpu::Backend::Gl if self.layers.len() == 6 => 7,
             _ => self.layers.len() as u32,
         };

wgpu/src/image/cache.rs

@@ -49,19 +49,16 @@ impl Cache {
     pub fn upload_raster(
         &mut self,
         device: &wgpu::Device,
-        backend: wgpu::Backend,
         encoder: &mut wgpu::CommandEncoder,
         handle: &core::image::Handle,
     ) -> Option<&atlas::Entry> {
-        self.raster
-            .upload(device, backend, encoder, handle, &mut self.atlas)
+        self.raster.upload(device, encoder, handle, &mut self.atlas)
     }
 
     #[cfg(feature = "svg")]
     pub fn upload_vector(
         &mut self,
         device: &wgpu::Device,
-        backend: wgpu::Backend,
         encoder: &mut wgpu::CommandEncoder,
         handle: &core::svg::Handle,
         color: Option<core::Color>,
@@ -70,7 +67,6 @@ impl Cache {
     ) -> Option<&atlas::Entry> {
         self.vector.upload(
             device,
-            backend,
             encoder,
             handle,
             color,

wgpu/src/image/mod.rs

@@ -235,12 +235,9 @@ impl State {
             match &image {
                 #[cfg(feature = "image")]
                 Image::Raster(image, bounds) => {
-                    if let Some(atlas_entry) = cache.upload_raster(
-                        device,
-                        pipeline.backend,
-                        encoder,
-                        &image.handle,
-                    ) {
+                    if let Some(atlas_entry) =
+                        cache.upload_raster(device, encoder, &image.handle)
+                    {
                         add_instances(
                             [bounds.x, bounds.y],
                             [bounds.width, bounds.height],
@@ -268,7 +265,6 @@ impl State {
 
                     if let Some(atlas_entry) = cache.upload_vector(
                         device,
-                        pipeline.backend,
                         encoder,
                         &svg.handle,
                         svg.color,

wgpu/src/image/raster.rs

@@ -66,7 +66,6 @@ impl Cache {
     pub fn upload(
         &mut self,
         device: &wgpu::Device,
-        backend: wgpu::Backend,
         encoder: &mut wgpu::CommandEncoder,
         handle: &image::Handle,
         atlas: &mut Atlas,
@@ -76,8 +75,7 @@ impl Cache {
         if let Memory::Host(image) = memory {
             let (width, height) = image.dimensions();
 
-            let entry =
-                atlas.upload(device, backend, encoder, width, height, image)?;
+            let entry = atlas.upload(device, encoder, width, height, image)?;
 
             *memory = Memory::Device(entry);
         }

wgpu/src/image/vector.rs

@@ -93,7 +93,6 @@ impl Cache {
     pub fn upload(
         &mut self,
         device: &wgpu::Device,
-        backend: wgpu::Backend,
         encoder: &mut wgpu::CommandEncoder,
         handle: &svg::Handle,
         color: Option<Color>,
@@ -168,8 +167,8 @@ impl Cache {
                     });
                 }
 
-                let allocation = atlas
-                    .upload(device, backend, encoder, width, height, &rgba)?;
+                let allocation =
+                    atlas.upload(device, encoder, width, height, &rgba)?;
 
                 log::debug!("allocating {id} {width}x{height}");