Use two layers for image::atlas only on Gl backend

examples/integration/src/main.rs

@@ -87,7 +87,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     });
     let surface = instance.create_surface(window.clone())?;
 
-    let (format, (device, queue)) =
+    let (format, adapter, device, queue) =
         futures::futures::executor::block_on(async {
             let adapter = wgpu::util::initialize_adapter_from_env_or_default(
                 &instance,
@@ -107,6 +107,19 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             let capabilities = surface.get_capabilities(&adapter);
 
+            let (device, queue) = adapter
+                .request_device(
+                    &wgpu::DeviceDescriptor {
+                        label: None,
+                        required_features: adapter_features
+                            & wgpu::Features::default(),
+                        required_limits: needed_limits,
+                    },
+                    None,
+                )
+                .await
+                .expect("Request device");
+
             (
                 capabilities
                     .formats
@@ -115,18 +128,9 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
                     .find(wgpu::TextureFormat::is_srgb)
                     .or_else(|| capabilities.formats.first().copied())
                     .expect("Get preferred format"),
-                adapter
-                    .request_device(
-                        &wgpu::DeviceDescriptor {
-                            label: None,
-                            required_features: adapter_features
-                                & wgpu::Features::default(),
-                            required_limits: needed_limits,
-                        },
-                        None,
-                    )
-                    .await
-                    .expect("Request device"),
+                adapter,
+                device,
+                queue,
             )
         });
 
@@ -153,7 +157,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize iced
     let mut debug = Debug::new();
     let mut renderer = Renderer::new(
-        Backend::new(&device, &queue, Settings::default(), format),
+        Backend::new(&adapter, &device, &queue, Settings::default(), format),
         Font::default(),
         Pixels(16.0),
     );

wgpu/src/backend.rs

@@ -27,7 +27,6 @@ pub struct Backend {
     text_pipeline: text::Pipeline,
     triangle_pipeline: triangle::Pipeline,
     pipeline_storage: pipeline::Storage,
-
     #[cfg(any(feature = "image", feature = "svg"))]
     image_pipeline: image::Pipeline,
 }
@@ -35,6 +34,7 @@ pub struct Backend {
 impl Backend {
     /// Creates a new [`Backend`].
     pub fn new(
+        _adapter: &wgpu::Adapter,
         device: &wgpu::Device,
         queue: &wgpu::Queue,
         settings: Settings,
@@ -46,7 +46,11 @@ impl Backend {
             triangle::Pipeline::new(device, format, settings.antialiasing);
 
         #[cfg(any(feature = "image", feature = "svg"))]
-        let image_pipeline = image::Pipeline::new(device, format);
+        let image_pipeline = {
+            let backend = _adapter.get_info().backend;
+
+            image::Pipeline::new(device, format, backend)
+        };
 
         Self {
             quad_pipeline,

wgpu/src/image.rs

@@ -176,7 +176,11 @@ impl Data {
 }
 
 impl Pipeline {
-    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+    pub fn new(
+        device: &wgpu::Device,
+        format: wgpu::TextureFormat,
+        backend: wgpu::Backend,
+    ) -> Self {
         let nearest_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
             address_mode_u: wgpu::AddressMode::ClampToEdge,
             address_mode_v: wgpu::AddressMode::ClampToEdge,
@@ -318,7 +322,7 @@ impl Pipeline {
                 multiview: None,
             });
 
-        let texture_atlas = Atlas::new(device);
+        let texture_atlas = Atlas::new(device, backend);
 
         let texture = device.create_bind_group(&wgpu::BindGroupDescriptor {
             label: Some("iced_wgpu::image texture atlas bind group"),

wgpu/src/image/atlas.rs

@@ -23,11 +23,15 @@ pub struct Atlas {
 }
 
 impl Atlas {
-    pub fn new(device: &wgpu::Device) -> Self {
-        // We start with 2 layers, to help wgpu figure out that this texture is `GL_TEXTURE_2D_ARRAY` rather
-        // than `GL_TEXTURE_2D`
-        // https://github.com/gfx-rs/wgpu/blob/004e3efe84a320d9331371ed31fa50baa2414911/wgpu-hal/src/gles/mod.rs#L371
-        let layers = vec![Layer::Empty, Layer::Empty];
+    pub fn new(device: &wgpu::Device, backend: wgpu::Backend) -> Self {
+        let layers = match backend {
+            // On the GL backend we start with 2 layers, to help wgpu figure
+            // out that this texture is `GL_TEXTURE_2D_ARRAY` rather than `GL_TEXTURE_2D`
+            // https://github.com/gfx-rs/wgpu/blob/004e3efe84a320d9331371ed31fa50baa2414911/wgpu-hal/src/gles/mod.rs#L371
+            wgpu::Backend::Gl => vec![Layer::Empty, Layer::Empty],
+            _ => vec![Layer::Empty],
+        };
+
         let extent = wgpu::Extent3d {
             width: SIZE,
             height: SIZE,

wgpu/src/window/compositor.rs

@@ -146,7 +146,13 @@ impl Compositor {
 
     /// Creates a new rendering [`Backend`] for this [`Compositor`].
     pub fn create_backend(&self) -> Backend {
-        Backend::new(&self.device, &self.queue, self.settings, self.format)
+        Backend::new(
+            &self.adapter,
+            &self.device,
+            &self.queue,
+            self.settings,
+            self.format,
+        )
     }
 }