Update `wgpu` to `0.6` in `iced_wgpu`

8 files changed, 277 insertions, 213 deletions

diff --git a/wgpu/Cargo.toml b/wgpu/Cargo.toml
index 6d9a1830..05088bbd 100644
--- a/wgpu/Cargo.toml
+++ b/wgpu/Cargo.toml
@@ -13,17 +13,15 @@ canvas = ["iced_graphics/canvas"]
 default_system_font = ["iced_graphics/font-source"]
 
 [dependencies]
-wgpu = "0.5"
-wgpu_glyph = "0.9"
+wgpu = "0.6"
+wgpu_glyph = "0.10"
 glyph_brush = "0.7"
 zerocopy = "0.3"
 bytemuck = "1.2"
 raw-window-handle = "0.3"
 log = "0.4"
 guillotiere = "0.5"
-# Pin `gfx-memory` until https://github.com/gfx-rs/wgpu-rs/issues/261 is
-# resolved
-gfx-memory = "=0.1.1"
+futures = "0.3"
 
 [dependencies.iced_native]
 version = "0.2"
diff --git a/wgpu/src/backend.rs b/wgpu/src/backend.rs
index c71a6a77..80c982d7 100644
--- a/wgpu/src/backend.rs
+++ b/wgpu/src/backend.rs
@@ -64,6 +64,7 @@ impl Backend {
     pub fn draw<T: AsRef<str>>(
         &mut self,
         device: &wgpu::Device,
+        staging_belt: &mut wgpu::util::StagingBelt,
         encoder: &mut wgpu::CommandEncoder,
         frame: &wgpu::TextureView,
         viewport: &Viewport,
@@ -85,6 +86,7 @@ impl Backend {
                 scale_factor,
                 transformation,
                 &layer,
+                staging_belt,
                 encoder,
                 &frame,
                 target_size.width,
@@ -104,6 +106,7 @@ impl Backend {
         scale_factor: f32,
         transformation: Transformation,
         layer: &Layer<'_>,
+        staging_belt: &mut wgpu::util::StagingBelt,
         encoder: &mut wgpu::CommandEncoder,
         target: &wgpu::TextureView,
         target_width: u32,
@@ -114,6 +117,7 @@ impl Backend {
         if !layer.quads.is_empty() {
             self.quad_pipeline.draw(
                 device,
+                staging_belt,
                 encoder,
                 &layer.quads,
                 transformation,
@@ -129,6 +133,7 @@ impl Backend {
 
             self.triangle_pipeline.draw(
                 device,
+                staging_belt,
                 encoder,
                 target,
                 target_width,
@@ -225,6 +230,7 @@ impl Backend {
 
             self.text_pipeline.draw_queued(
                 device,
+                staging_belt,
                 encoder,
                 target,
                 transformation,
diff --git a/wgpu/src/lib.rs b/wgpu/src/lib.rs
index e51a225c..570e8a94 100644
--- a/wgpu/src/lib.rs
+++ b/wgpu/src/lib.rs
@@ -23,7 +23,7 @@
 #![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 #![deny(unused_results)]
-#![forbid(unsafe_code)]
+#![deny(unsafe_code)]
 #![forbid(rust_2018_idioms)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
diff --git a/wgpu/src/quad.rs b/wgpu/src/quad.rs
index 0b62f44f..f8d6c509 100644
--- a/wgpu/src/quad.rs
+++ b/wgpu/src/quad.rs
@@ -3,6 +3,7 @@ use iced_graphics::layer;
 use iced_native::Rectangle;
 
 use std::mem;
+use wgpu::util::DeviceExt;
 use zerocopy::AsBytes;
 
 #[derive(Debug)]
@@ -20,50 +21,54 @@ impl Pipeline {
         let constant_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                 label: None,
-                bindings: &[wgpu::BindGroupLayoutEntry {
+                entries: &[wgpu::BindGroupLayoutEntry {
                     binding: 0,
                     visibility: wgpu::ShaderStage::VERTEX,
-                    ty: wgpu::BindingType::UniformBuffer { dynamic: false },
+                    ty: wgpu::BindingType::UniformBuffer {
+                        dynamic: false,
+                        min_binding_size: wgpu::BufferSize::new(
+                            mem::size_of::<Uniforms>() as u64,
+                        ),
+                    },
+                    count: None,
                 }],
             });
 
-        let constants_buffer = device.create_buffer_with_data(
-            Uniforms::default().as_bytes(),
-            wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
-        );
+        let constants_buffer =
+            device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: Uniforms::default().as_bytes(),
+                usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
+            });
 
         let constants = device.create_bind_group(&wgpu::BindGroupDescriptor {
             label: None,
             layout: &constant_layout,
-            bindings: &[wgpu::Binding {
+            entries: &[wgpu::BindGroupEntry {
                 binding: 0,
-                resource: wgpu::BindingResource::Buffer {
-                    buffer: &constants_buffer,
-                    range: 0..std::mem::size_of::<Uniforms>() as u64,
-                },
+                resource: wgpu::BindingResource::Buffer(
+                    constants_buffer.slice(..),
+                ),
             }],
         });
 
         let layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                push_constant_ranges: &[],
                 bind_group_layouts: &[&constant_layout],
             });
 
-        let vs = include_bytes!("shader/quad.vert.spv");
-        let vs_module = device.create_shader_module(
-            &wgpu::read_spirv(std::io::Cursor::new(&vs[..]))
-                .expect("Read quad vertex shader as SPIR-V"),
-        );
+        let vs_module = device
+            .create_shader_module(wgpu::include_spirv!("shader/quad.vert.spv"));
 
-        let fs = include_bytes!("shader/quad.frag.spv");
-        let fs_module = device.create_shader_module(
-            &wgpu::read_spirv(std::io::Cursor::new(&fs[..]))
-                .expect("Read quad fragment shader as SPIR-V"),
-        );
+        let fs_module = device
+            .create_shader_module(wgpu::include_spirv!("shader/quad.frag.spv"));
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                layout: &layout,
+                label: None,
+                layout: Some(&layout),
                 vertex_stage: wgpu::ProgrammableStageDescriptor {
                     module: &vs_module,
                     entry_point: "main",
@@ -78,6 +83,7 @@ impl Pipeline {
                     depth_bias: 0,
                     depth_bias_slope_scale: 0.0,
                     depth_bias_clamp: 0.0,
+                    ..Default::default()
                 }),
                 primitive_topology: wgpu::PrimitiveTopology::TriangleList,
                 color_states: &[wgpu::ColorStateDescriptor {
@@ -150,20 +156,25 @@ impl Pipeline {
                 alpha_to_coverage_enabled: false,
             });
 
-        let vertices = device.create_buffer_with_data(
-            QUAD_VERTS.as_bytes(),
-            wgpu::BufferUsage::VERTEX,
-        );
+        let vertices =
+            device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: QUAD_VERTS.as_bytes(),
+                usage: wgpu::BufferUsage::VERTEX,
+            });
 
-        let indices = device.create_buffer_with_data(
-            QUAD_INDICES.as_bytes(),
-            wgpu::BufferUsage::INDEX,
-        );
+        let indices =
+            device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: QUAD_INDICES.as_bytes(),
+                usage: wgpu::BufferUsage::INDEX,
+            });
 
         let instances = device.create_buffer(&wgpu::BufferDescriptor {
             label: None,
             size: mem::size_of::<layer::Quad>() as u64 * MAX_INSTANCES as u64,
             usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
+            mapped_at_creation: false,
         });
 
         Pipeline {
@@ -179,6 +190,7 @@ impl Pipeline {
     pub fn draw(
         &mut self,
         device: &wgpu::Device,
+        staging_belt: &mut wgpu::util::StagingBelt,
         encoder: &mut wgpu::CommandEncoder,
         instances: &[layer::Quad],
         transformation: Transformation,
@@ -188,18 +200,18 @@ impl Pipeline {
     ) {
         let uniforms = Uniforms::new(transformation, scale);
 
-        let constants_buffer = device.create_buffer_with_data(
-            uniforms.as_bytes(),
-            wgpu::BufferUsage::COPY_SRC,
-        );
+        {
+            let mut constants_buffer = staging_belt.write_buffer(
+                encoder,
+                &self.constants_buffer,
+                0,
+                wgpu::BufferSize::new(mem::size_of::<Uniforms>() as u64)
+                    .unwrap(),
+                device,
+            );
 
-        encoder.copy_buffer_to_buffer(
-            &constants_buffer,
-            0,
-            &self.constants_buffer,
-            0,
-            std::mem::size_of::<Uniforms>() as u64,
-        );
+            constants_buffer.copy_from_slice(uniforms.as_bytes());
+        }
 
         let mut i = 0;
         let total = instances.len();
@@ -208,19 +220,18 @@ impl Pipeline {
             let end = (i + MAX_INSTANCES).min(total);
             let amount = end - i;
 
-            let instance_buffer = device.create_buffer_with_data(
-                bytemuck::cast_slice(&instances[i..end]),
-                wgpu::BufferUsage::COPY_SRC,
-            );
+            let instance_bytes = bytemuck::cast_slice(&instances[i..end]);
 
-            encoder.copy_buffer_to_buffer(
-                &instance_buffer,
-                0,
+            let mut instance_buffer = staging_belt.write_buffer(
+                encoder,
                 &self.instances,
                 0,
-                (mem::size_of::<layer::Quad>() * amount) as u64,
+                wgpu::BufferSize::new(instance_bytes.len() as u64).unwrap(),
+                device,
             );
 
+            instance_buffer.copy_from_slice(instance_bytes);
+
             {
                 let mut render_pass =
                     encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -228,13 +239,9 @@ impl Pipeline {
                             wgpu::RenderPassColorAttachmentDescriptor {
                                 attachment: target,
                                 resolve_target: None,
-                                load_op: wgpu::LoadOp::Load,
-                                store_op: wgpu::StoreOp::Store,
-                                clear_color: wgpu::Color {
-                                    r: 0.0,
-                                    g: 0.0,
-                                    b: 0.0,
-                                    a: 0.0,
+                                ops: wgpu::Operations {
+                                    load: wgpu::LoadOp::Load,
+                                    store: true,
                                 },
                             },
                         ],
@@ -243,9 +250,9 @@ impl Pipeline {
 
                 render_pass.set_pipeline(&self.pipeline);
                 render_pass.set_bind_group(0, &self.constants, &[]);
-                render_pass.set_index_buffer(&self.indices, 0, 0);
-                render_pass.set_vertex_buffer(0, &self.vertices, 0, 0);
-                render_pass.set_vertex_buffer(1, &self.instances, 0, 0);
+                render_pass.set_index_buffer(self.indices.slice(..));
+                render_pass.set_vertex_buffer(0, self.vertices.slice(..));
+                render_pass.set_vertex_buffer(1, self.instances.slice(..));
                 render_pass.set_scissor_rect(
                     bounds.x,
                     bounds.y,
diff --git a/wgpu/src/text.rs b/wgpu/src/text.rs
index a7123d39..78999cf8 100644
--- a/wgpu/src/text.rs
+++ b/wgpu/src/text.rs
@@ -65,6 +65,7 @@ impl Pipeline {
     pub fn draw_queued(
         &mut self,
         device: &wgpu::Device,
+        staging_belt: &mut wgpu::util::StagingBelt,
         encoder: &mut wgpu::CommandEncoder,
         target: &wgpu::TextureView,
         transformation: Transformation,
@@ -74,6 +75,7 @@ impl Pipeline {
             .borrow_mut()
             .draw_queued_with_transform_and_scissoring(
                 device,
+                staging_belt,
                 encoder,
                 target,
                 transformation.into(),
diff --git a/wgpu/src/triangle.rs b/wgpu/src/triangle.rs
index 2744c67a..fcab5e3d 100644
--- a/wgpu/src/triangle.rs
+++ b/wgpu/src/triangle.rs
@@ -8,7 +8,7 @@ pub use iced_graphics::triangle::{Mesh2D, Vertex2D};
 
 mod msaa;
 
-const UNIFORM_BUFFER_SIZE: usize = 100;
+const UNIFORM_BUFFER_SIZE: usize = 50;
 const VERTEX_BUFFER_SIZE: usize = 10_000;
 const INDEX_BUFFER_SIZE: usize = 10_000;
 
@@ -41,6 +41,7 @@ impl<T> Buffer<T> {
             label: None,
             size: (std::mem::size_of::<T>() * size) as u64,
             usage,
+            mapped_at_creation: false,
         });
 
         Buffer {
@@ -59,6 +60,7 @@ impl<T> Buffer<T> {
                 label: None,
                 size: (std::mem::size_of::<T>() * size) as u64,
                 usage: self.usage,
+                mapped_at_creation: false,
             });
 
             self.size = size;
@@ -77,10 +79,16 @@ impl Pipeline {
         let constants_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                 label: None,
-                bindings: &[wgpu::BindGroupLayoutEntry {
+                entries: &[wgpu::BindGroupLayoutEntry {
                     binding: 0,
                     visibility: wgpu::ShaderStage::VERTEX,
-                    ty: wgpu::BindingType::UniformBuffer { dynamic: true },
+                    ty: wgpu::BindingType::UniformBuffer {
+                        dynamic: true,
+                        min_binding_size: wgpu::BufferSize::new(
+                            mem::size_of::<Uniforms>() as u64,
+                        ),
+                    },
+                    count: None,
                 }],
             });
 
@@ -94,35 +102,35 @@ impl Pipeline {
             device.create_bind_group(&wgpu::BindGroupDescriptor {
                 label: None,
                 layout: &constants_layout,
-                bindings: &[wgpu::Binding {
+                entries: &[wgpu::BindGroupEntry {
                     binding: 0,
-                    resource: wgpu::BindingResource::Buffer {
-                        buffer: &constants_buffer.raw,
-                        range: 0..std::mem::size_of::<Uniforms>() as u64,
-                    },
+                    resource: wgpu::BindingResource::Buffer(
+                        constants_buffer
+                            .raw
+                            .slice(0..std::mem::size_of::<Uniforms>() as u64),
+                    ),
                 }],
             });
 
         let layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                push_constant_ranges: &[],
                 bind_group_layouts: &[&constants_layout],
             });
 
-        let vs = include_bytes!("shader/triangle.vert.spv");
-        let vs_module = device.create_shader_module(
-            &wgpu::read_spirv(std::io::Cursor::new(&vs[..]))
-                .expect("Read triangle vertex shader as SPIR-V"),
-        );
+        let vs_module = device.create_shader_module(wgpu::include_spirv!(
+            "shader/triangle.vert.spv"
+        ));
 
-        let fs = include_bytes!("shader/triangle.frag.spv");
-        let fs_module = device.create_shader_module(
-            &wgpu::read_spirv(std::io::Cursor::new(&fs[..]))
-                .expect("Read triangle fragment shader as SPIR-V"),
-        );
+        let fs_module = device.create_shader_module(wgpu::include_spirv!(
+            "shader/triangle.frag.spv"
+        ));
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                layout: &layout,
+                label: None,
+                layout: Some(&layout),
                 vertex_stage: wgpu::ProgrammableStageDescriptor {
                     module: &vs_module,
                     entry_point: "main",
@@ -137,6 +145,7 @@ impl Pipeline {
                     depth_bias: 0,
                     depth_bias_slope_scale: 0.0,
                     depth_bias_clamp: 0.0,
+                    ..Default::default()
                 }),
                 primitive_topology: wgpu::PrimitiveTopology::TriangleList,
                 color_states: &[wgpu::ColorStateDescriptor {
@@ -204,6 +213,7 @@ impl Pipeline {
     pub fn draw(
         &mut self,
         device: &wgpu::Device,
+        staging_belt: &mut wgpu::util::StagingBelt,
         encoder: &mut wgpu::CommandEncoder,
         target: &wgpu::TextureView,
         target_width: u32,
@@ -236,12 +246,13 @@ impl Pipeline {
                 device.create_bind_group(&wgpu::BindGroupDescriptor {
                     label: None,
                     layout: &self.constants_layout,
-                    bindings: &[wgpu::Binding {
+                    entries: &[wgpu::BindGroupEntry {
                         binding: 0,
-                        resource: wgpu::BindingResource::Buffer {
-                            buffer: &self.uniforms_buffer.raw,
-                            range: 0..std::mem::size_of::<Uniforms>() as u64,
-                        },
+                        resource: wgpu::BindingResource::Buffer(
+                            self.uniforms_buffer.raw.slice(
+                                0..std::mem::size_of::<Uniforms>() as u64,
+                            ),
+                        ),
                     }],
                 });
         }
@@ -261,65 +272,85 @@ impl Pipeline {
                 * Transformation::translate(mesh.origin.x, mesh.origin.y))
             .into();
 
-            let vertex_buffer = device.create_buffer_with_data(
-                bytemuck::cast_slice(&mesh.buffers.vertices),
-                wgpu::BufferUsage::COPY_SRC,
-            );
+            let vertices = bytemuck::cast_slice(&mesh.buffers.vertices);
+            let indices = bytemuck::cast_slice(&mesh.buffers.indices);
 
-            let index_buffer = device.create_buffer_with_data(
-                mesh.buffers.indices.as_bytes(),
-                wgpu::BufferUsage::COPY_SRC,
-            );
+            if let Some(vertices_size) =
+                wgpu::BufferSize::new(vertices.len() as u64)
+            {
+                if let Some(indices_size) =
+                    wgpu::BufferSize::new(indices.len() as u64)
+                {
+                    {
+                        let mut vertex_buffer = staging_belt.write_buffer(
+                            encoder,
+                            &self.vertex_buffer.raw,
+                            (std::mem::size_of::<Vertex2D>() * last_vertex)
+                                as u64,
+                            vertices_size,
+                            device,
+                        );
+
+                        vertex_buffer.copy_from_slice(vertices);
+                    }
+
+                    {
+                        let mut index_buffer = staging_belt.write_buffer(
+                            encoder,
+                            &self.index_buffer.raw,
+                            (std::mem::size_of::<u32>() * last_index) as u64,
+                            indices_size,
+                            device,
+                        );
+
+                        index_buffer.copy_from_slice(indices);
+                    }
+
+                    uniforms.push(transform);
+                    offsets.push((
+                        last_vertex as u64,
+                        last_index as u64,
+                        mesh.buffers.indices.len(),
+                    ));
+
+                    last_vertex += mesh.buffers.vertices.len();
+                    last_index += mesh.buffers.indices.len();
+                }
+            }
+        }
 
-            encoder.copy_buffer_to_buffer(
-                &vertex_buffer,
-                0,
-                &self.vertex_buffer.raw,
-                (std::mem::size_of::<Vertex2D>() * last_vertex) as u64,
-                (std::mem::size_of::<Vertex2D>() * mesh.buffers.vertices.len())
-                    as u64,
-            );
+        let uniforms = uniforms.as_bytes();
 
-            encoder.copy_buffer_to_buffer(
-                &index_buffer,
+        if let Some(uniforms_size) =
+            wgpu::BufferSize::new(uniforms.len() as u64)
+        {
+            let mut uniforms_buffer = staging_belt.write_buffer(
+                encoder,
+                &self.uniforms_buffer.raw,
                 0,
-                &self.index_buffer.raw,
-                (std::mem::size_of::<u32>() * last_index) as u64,
-                (std::mem::size_of::<u32>() * mesh.buffers.indices.len())
-                    as u64,
+                uniforms_size,
+                device,
             );
 
-            uniforms.push(transform);
-            offsets.push((
-                last_vertex as u64,
-                last_index as u64,
-                mesh.buffers.indices.len(),
-            ));
-
-            last_vertex += mesh.buffers.vertices.len();
-            last_index += mesh.buffers.indices.len();
+            uniforms_buffer.copy_from_slice(uniforms);
         }
 
-        let uniforms_buffer = device.create_buffer_with_data(
-            uniforms.as_bytes(),
-            wgpu::BufferUsage::COPY_SRC,
-        );
-
-        encoder.copy_buffer_to_buffer(
-            &uniforms_buffer,
-            0,
-            &self.uniforms_buffer.raw,
-            0,
-            (std::mem::size_of::<Uniforms>() * uniforms.len()) as u64,
-        );
-
         {
-            let (attachment, resolve_target, load_op) =
+            let (attachment, resolve_target, load) =
                 if let Some(blit) = &mut self.blit {
                     let (attachment, resolve_target) =
                         blit.targets(device, target_width, target_height);
 
-                    (attachment, Some(resolve_target), wgpu::LoadOp::Clear)
+                    (
+                        attachment,
+                        Some(resolve_target),
+                        wgpu::LoadOp::Clear(wgpu::Color {
+                            r: 0.0,
+                            g: 0.0,
+                            b: 0.0,
+                            a: 0.0,
+                        }),
+                    )
                 } else {
                     (target, None, wgpu::LoadOp::Load)
                 };
@@ -330,14 +361,7 @@ impl Pipeline {
                         wgpu::RenderPassColorAttachmentDescriptor {
                             attachment,
                             resolve_target,
-                            load_op,
-                            store_op: wgpu::StoreOp::Store,
-                            clear_color: wgpu::Color {
-                                r: 0.0,
-                                g: 0.0,
-                                b: 0.0,
-                                a: 0.0,
-                            },
+                            ops: wgpu::Operations { load, store: true },
                         },
                     ],
                     depth_stencil_attachment: None,
@@ -363,20 +387,17 @@ impl Pipeline {
                     &[(std::mem::size_of::<Uniforms>() * i) as u32],
                 );
 
-                render_pass.set_index_buffer(
-                    &self.index_buffer.raw,
-                    index_offset * std::mem::size_of::<u32>() as u64,
-                    0,
-                );
+                render_pass.set_index_buffer(self.index_buffer.raw.slice(..));
 
-                render_pass.set_vertex_buffer(
-                    0,
-                    &self.vertex_buffer.raw,
-                    vertex_offset * std::mem::size_of::<Vertex2D>() as u64,
-                    0,
-                );
+                render_pass
+                    .set_vertex_buffer(0, self.vertex_buffer.raw.slice(..));
 
-                render_pass.draw_indexed(0..indices as u32, 0, 0..1);
+                render_pass.draw_indexed(
+                    index_offset as u32
+                        ..(index_offset as usize + indices) as u32,
+                    vertex_offset as i32,
+                    0..1,
+                );
             }
         }
 
diff --git a/wgpu/src/triangle/msaa.rs b/wgpu/src/triangle/msaa.rs
index f52c888b..f25667a5 100644
--- a/wgpu/src/triangle/msaa.rs
+++ b/wgpu/src/triangle/msaa.rs
@@ -23,18 +23,17 @@ impl Blit {
             mag_filter: wgpu::FilterMode::Linear,
             min_filter: wgpu::FilterMode::Linear,
             mipmap_filter: wgpu::FilterMode::Linear,
-            lod_min_clamp: -100.0,
-            lod_max_clamp: 100.0,
-            compare: wgpu::CompareFunction::Always,
+            ..Default::default()
         });
 
         let constant_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                 label: None,
-                bindings: &[wgpu::BindGroupLayoutEntry {
+                entries: &[wgpu::BindGroupLayoutEntry {
                     binding: 0,
                     visibility: wgpu::ShaderStage::FRAGMENT,
                     ty: wgpu::BindingType::Sampler { comparison: false },
+                    count: None,
                 }],
             });
 
@@ -42,7 +41,7 @@ impl Blit {
             device.create_bind_group(&wgpu::BindGroupDescriptor {
                 label: None,
                 layout: &constant_layout,
-                bindings: &[wgpu::Binding {
+                entries: &[wgpu::BindGroupEntry {
                     binding: 0,
                     resource: wgpu::BindingResource::Sampler(&sampler),
                 }],
@@ -51,7 +50,7 @@ impl Blit {
         let texture_layout =
             device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                 label: None,
-                bindings: &[wgpu::BindGroupLayoutEntry {
+                entries: &[wgpu::BindGroupLayoutEntry {
                     binding: 0,
                     visibility: wgpu::ShaderStage::FRAGMENT,
                     ty: wgpu::BindingType::SampledTexture {
@@ -59,29 +58,29 @@ impl Blit {
                         component_type: wgpu::TextureComponentType::Float,
                         multisampled: false,
                     },
+                    count: None,
                 }],
             });
 
         let layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                push_constant_ranges: &[],
                 bind_group_layouts: &[&constant_layout, &texture_layout],
             });
 
-        let vs = include_bytes!("../shader/blit.vert.spv");
-        let vs_module = device.create_shader_module(
-            &wgpu::read_spirv(std::io::Cursor::new(&vs[..]))
-                .expect("Read blit vertex shader as SPIR-V"),
-        );
+        let vs_module = device.create_shader_module(wgpu::include_spirv!(
+            "../shader/blit.vert.spv"
+        ));
 
-        let fs = include_bytes!("../shader/blit.frag.spv");
-        let fs_module = device.create_shader_module(
-            &wgpu::read_spirv(std::io::Cursor::new(&fs[..]))
-                .expect("Read blit fragment shader as SPIR-V"),
-        );
+        let fs_module = device.create_shader_module(wgpu::include_spirv!(
+            "../shader/blit.frag.spv"
+        ));
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                layout: &layout,
+                label: None,
+                layout: Some(&layout),
                 vertex_stage: wgpu::ProgrammableStageDescriptor {
                     module: &vs_module,
                     entry_point: "main",
@@ -96,6 +95,7 @@ impl Blit {
                     depth_bias: 0,
                     depth_bias_slope_scale: 0.0,
                     depth_bias_clamp: 0.0,
+                    ..Default::default()
                 }),
                 primitive_topology: wgpu::PrimitiveTopology::TriangleList,
                 color_states: &[wgpu::ColorStateDescriptor {
@@ -179,13 +179,9 @@ impl Blit {
                     wgpu::RenderPassColorAttachmentDescriptor {
                         attachment: target,
                         resolve_target: None,
-                        load_op: wgpu::LoadOp::Load,
-                        store_op: wgpu::StoreOp::Store,
-                        clear_color: wgpu::Color {
-                            r: 0.0,
-                            g: 0.0,
-                            b: 0.0,
-                            a: 0.0,
+                        ops: wgpu::Operations {
+                            load: wgpu::LoadOp::Load,
+                            store: true,
                         },
                     },
                 ],
@@ -230,7 +226,6 @@ impl Targets {
         let attachment = device.create_texture(&wgpu::TextureDescriptor {
             label: None,
             size: extent,
-            array_layer_count: 1,
             mip_level_count: 1,
             sample_count,
             dimension: wgpu::TextureDimension::D2,
@@ -241,7 +236,6 @@ impl Targets {
         let resolve = device.create_texture(&wgpu::TextureDescriptor {
             label: None,
             size: extent,
-            array_layer_count: 1,
             mip_level_count: 1,
             sample_count: 1,
             dimension: wgpu::TextureDimension::D2,
@@ -250,13 +244,16 @@ impl Targets {
                 | wgpu::TextureUsage::SAMPLED,
         });
 
-        let attachment = attachment.create_default_view();
-        let resolve = resolve.create_default_view();
+        let attachment =
+            attachment.create_view(&wgpu::TextureViewDescriptor::default());
+
+        let resolve =
+            resolve.create_view(&wgpu::TextureViewDescriptor::default());
 
         let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
             label: None,
             layout: texture_layout,
-            bindings: &[wgpu::Binding {
+            entries: &[wgpu::BindGroupEntry {
                 binding: 0,
                 resource: wgpu::BindingResource::TextureView(&resolve),
             }],
diff --git a/wgpu/src/window/compositor.rs b/wgpu/src/window/compositor.rs
index 5bdd34bc..0c94c281 100644
--- a/wgpu/src/window/compositor.rs
+++ b/wgpu/src/window/compositor.rs
@@ -1,18 +1,24 @@
 use crate::{Backend, Color, Renderer, Settings};
 
+use futures::task::SpawnExt;
 use iced_graphics::Viewport;
 use iced_native::{futures, mouse};
 use raw_window_handle::HasRawWindowHandle;
 
 /// A window graphics backend for iced powered by `wgpu`.
-#[derive(Debug)]
+#[allow(missing_debug_implementations)]
 pub struct Compositor {
     settings: Settings,
+    instance: wgpu::Instance,
     device: wgpu::Device,
     queue: wgpu::Queue,
+    staging_belt: wgpu::util::StagingBelt,
+    local_pool: futures::executor::LocalPool,
 }
 
 impl Compositor {
+    const CHUNK_SIZE: u64 = 10 * 1024;
+
     /// Requests a new [`Compositor`] with the given [`Settings`].
     ///
     /// Returns `None` if no compatible graphics adapter could be found.
@@ -20,32 +26,44 @@ impl Compositor {
     /// [`Compositor`]: struct.Compositor.html
     /// [`Settings`]: struct.Settings.html
     pub async fn request(settings: Settings) -> Option<Self> {
-        let adapter = wgpu::Adapter::request(
-            &wgpu::RequestAdapterOptions {
+        let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
+
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
                 power_preference: if settings.antialiasing.is_none() {
                     wgpu::PowerPreference::Default
                 } else {
                     wgpu::PowerPreference::HighPerformance
                 },
                 compatible_surface: None,
-            },
-            wgpu::BackendBit::PRIMARY,
-        )
-        .await?;
+            })
+            .await?;
 
         let (device, queue) = adapter
-            .request_device(&wgpu::DeviceDescriptor {
-                extensions: wgpu::Extensions {
-                    anisotropic_filtering: false,
+            .request_device(
+                &wgpu::DeviceDescriptor {
+                    features: wgpu::Features::empty(),
+                    limits: wgpu::Limits {
+                        max_bind_groups: 2,
+                        ..wgpu::Limits::default()
+                    },
+                    shader_validation: false,
                 },
-                limits: wgpu::Limits { max_bind_groups: 2 },
-            })
-            .await;
+                None,
+            )
+            .await
+            .ok()?;
+
+        let staging_belt = wgpu::util::StagingBelt::new(Self::CHUNK_SIZE);
+        let local_pool = futures::executor::LocalPool::new();
 
         Some(Compositor {
+            instance,
             settings,
             device,
             queue,
+            staging_belt,
+            local_pool,
         })
     }
 
@@ -77,7 +95,10 @@ impl iced_graphics::window::Compositor for Compositor {
         &mut self,
         window: &W,
     ) -> wgpu::Surface {
-        wgpu::Surface::create(window)
+        #[allow(unsafe_code)]
+        unsafe {
+            self.instance.create_surface(window)
+        }
     }
 
     fn create_swap_chain(
@@ -107,7 +128,7 @@ impl iced_graphics::window::Compositor for Compositor {
         output: &<Self::Renderer as iced_native::Renderer>::Output,
         overlay: &[T],
     ) -> mouse::Interaction {
-        let frame = swap_chain.get_next_texture().expect("Next frame");
+        let frame = swap_chain.get_current_frame().expect("Next frame");
 
         let mut encoder = self.device.create_command_encoder(
             &wgpu::CommandEncoderDescriptor { label: None },
@@ -115,19 +136,20 @@ impl iced_graphics::window::Compositor for Compositor {
 
         let _ = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
-                attachment: &frame.view,
+                attachment: &frame.output.view,
                 resolve_target: None,
-                load_op: wgpu::LoadOp::Clear,
-                store_op: wgpu::StoreOp::Store,
-                clear_color: {
-                    let [r, g, b, a] = background_color.into_linear();
-
-                    wgpu::Color {
-                        r: f64::from(r),
-                        g: f64::from(g),
-                        b: f64::from(b),
-                        a: f64::from(a),
-                    }
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Clear({
+                        let [r, g, b, a] = background_color.into_linear();
+
+                        wgpu::Color {
+                            r: f64::from(r),
+                            g: f64::from(g),
+                            b: f64::from(b),
+                            a: f64::from(a),
+                        }
+                    }),
+                    store: true,
                 },
             }],
             depth_stencil_attachment: None,
@@ -135,14 +157,25 @@ impl iced_graphics::window::Compositor for Compositor {
 
         let mouse_interaction = renderer.backend_mut().draw(
             &mut self.device,
+            &mut self.staging_belt,
             &mut encoder,
-            &frame.view,
+            &frame.output.view,
             viewport,
             output,
             overlay,
         );
 
-        self.queue.submit(&[encoder.finish()]);
+        // Submit work
+        self.staging_belt.finish();
+        self.queue.submit(Some(encoder.finish()));
+
+        // Recall staging buffers
+        self.local_pool
+            .spawner()
+            .spawn(self.staging_belt.recall())
+            .expect("Recall staging belt");
+
+        self.local_pool.run_until_stalled();
 
         mouse_interaction
     }