Merge pull request #830 from Dispersia/upgrade-wgpu

Upgrade wgpu

examples/integration/src/scene.rs

@@ -20,8 +20,8 @@ impl Scene {
     ) -> wgpu::RenderPass<'a> {
         encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: None,
-            color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
+            color_attachments: &[wgpu::RenderPassColorAttachment {
-                attachment: target,
+                view: target,
                 resolve_target: None,
                 ops: wgpu::Operations {
                     load: wgpu::LoadOp::Clear({
@@ -75,15 +75,16 @@ fn build_pipeline(device: &wgpu::Device) -> wgpu::RenderPipeline {
                 entry_point: "main",
                 targets: &[wgpu::ColorTargetState {
                     format: wgpu::TextureFormat::Bgra8UnormSrgb,
-                    color_blend: wgpu::BlendState::REPLACE,
+                    blend: Some(wgpu::BlendState {
-                    alpha_blend: wgpu::BlendState::REPLACE,
+                        color: wgpu::BlendComponent::REPLACE,
+                        alpha: wgpu::BlendComponent::REPLACE,
+                    }),
                     write_mask: wgpu::ColorWrite::ALL,
                 }],
             }),
             primitive: wgpu::PrimitiveState {
                 topology: wgpu::PrimitiveTopology::TriangleList,
                 front_face: wgpu::FrontFace::Ccw,
-                cull_mode: wgpu::CullMode::None,
                 ..Default::default()
             },
             depth_stencil: None,

examples/pokedex/src/main.rs

@@ -213,7 +213,10 @@ impl Pokemon {
     }
 
     async fn fetch_image(id: u16) -> Result<image::Handle, reqwest::Error> {
-        let url = format!("https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/{}.png", id);
+        let url = format!(
+            "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/{}.png",
+            id
+        );
 
         #[cfg(not(target_arch = "wasm32"))]
         {

examples/styling/src/main.rs

@@ -44,7 +44,7 @@ impl Sandbox for Styling {
         match message {
             Message::ThemeChanged(theme) => self.theme = theme,
             Message::InputChanged(value) => self.input_value = value,
-            Message::ButtonPressed => (),
+            Message::ButtonPressed => {}
             Message::SliderChanged(value) => self.slider_value = value,
             Message::CheckboxToggled(value) => self.toggle_value = value,
         }

native/src/widget/text_input/cursor.rs

@@ -113,7 +113,7 @@ impl Cursor {
             State::Selection { start, end } if end > 0 => {
                 self.select_range(start, end - 1)
             }
-            _ => (),
+            _ => {}
         }
     }
 
@@ -125,7 +125,7 @@ impl Cursor {
             State::Selection { start, end } if end < value.len() => {
                 self.select_range(start, end + 1)
             }
-            _ => (),
+            _ => {}
         }
     }
 

native/src/widget/text_input/editor.rs

@@ -20,7 +20,7 @@ impl<'a> Editor<'a> {
                 self.cursor.move_left(self.value);
                 self.value.remove_many(left, right);
             }
-            _ => (),
+            _ => {}
         }
 
         self.value.insert(self.cursor.end(self.value), character);
@@ -35,7 +35,7 @@ impl<'a> Editor<'a> {
                 self.cursor.move_left(self.value);
                 self.value.remove_many(left, right);
             }
-            _ => (),
+            _ => {}
         }
 
         self.value.insert_many(self.cursor.end(self.value), content);

src/window/icon.rs

@@ -97,23 +97,25 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Error::InvalidData { byte_count } => {
-                write!(f,
+                write!(
-                "The provided RGBA data (with length {:?}) isn't divisble by \
+                    f,
+                    "The provided RGBA data (with length {:?}) isn't divisble by \
                 4. Therefore, it cannot be safely interpreted as 32bpp RGBA \
                 pixels.",
-                byte_count,
+                    byte_count,
-            )
+                )
             }
             Error::DimensionsMismatch {
                 width,
                 height,
                 pixel_count,
             } => {
-                write!(f,
+                write!(
-                "The number of RGBA pixels ({:?}) does not match the provided \
+                    f,
+                    "The number of RGBA pixels ({:?}) does not match the provided \
                 dimensions ({:?}x{:?}).",
-                pixel_count, width, height,
+                    pixel_count, width, height,
-            )
+                )
             }
             Error::OsError(e) => write!(
                 f,

wgpu/Cargo.toml

@@ -26,8 +26,8 @@ qr_code = ["iced_graphics/qr_code"]
 default_system_font = ["iced_graphics/font-source"]
 
 [dependencies]
-wgpu = "0.7"
+wgpu = "0.8"
-wgpu_glyph = "0.11"
+wgpu_glyph = "0.12"
 glyph_brush = "0.7"
 raw-window-handle = "0.3"
 log = "0.4"

wgpu/src/image.rs

@@ -97,11 +97,13 @@ impl Pipeline {
                 entries: &[
                     wgpu::BindGroupEntry {
                         binding: 0,
-                        resource: wgpu::BindingResource::Buffer {
+                        resource: wgpu::BindingResource::Buffer(
-                            buffer: &uniforms_buffer,
+                            wgpu::BufferBinding {
-                            offset: 0,
+                                buffer: &uniforms_buffer,
-                            size: None,
+                                offset: 0,
-                        },
+                                size: None,
+                            },
+                        ),
                     },
                     wgpu::BindGroupEntry {
                         binding: 1,
@@ -134,28 +136,29 @@ impl Pipeline {
                 bind_group_layouts: &[&constant_layout, &texture_layout],
             });
 
-        let vs_module = device.create_shader_module(&wgpu::include_spirv!(
+        let shader =
-            "shader/image.vert.spv"
+            device.create_shader_module(&wgpu::ShaderModuleDescriptor {
-        ));
+                label: Some("iced_wgpu::image::shader"),
-
+                source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
-        let fs_module = device.create_shader_module(&wgpu::include_spirv!(
+                    include_str!("shader/image.wgsl"),
-            "shader/image.frag.spv"
+                )),
-        ));
+                flags: wgpu::ShaderFlags::all(),
+            });
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some("iced_wgpu::image pipeline"),
                 layout: Some(&layout),
                 vertex: wgpu::VertexState {
-                    module: &vs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "vs_main",
                     buffers: &[
                         wgpu::VertexBufferLayout {
                             array_stride: mem::size_of::<Vertex>() as u64,
                             step_mode: wgpu::InputStepMode::Vertex,
                             attributes: &[wgpu::VertexAttribute {
                                 shader_location: 0,
-                                format: wgpu::VertexFormat::Float2,
+                                format: wgpu::VertexFormat::Float32x2,
                                 offset: 0,
                             }],
                         },
@@ -165,27 +168,27 @@ impl Pipeline {
                             attributes: &[
                                 wgpu::VertexAttribute {
                                     shader_location: 1,
-                                    format: wgpu::VertexFormat::Float2,
+                                    format: wgpu::VertexFormat::Float32x2,
                                     offset: 0,
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 2,
-                                    format: wgpu::VertexFormat::Float2,
+                                    format: wgpu::VertexFormat::Float32x2,
                                     offset: 4 * 2,
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 3,
-                                    format: wgpu::VertexFormat::Float2,
+                                    format: wgpu::VertexFormat::Float32x2,
                                     offset: 4 * 4,
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 4,
-                                    format: wgpu::VertexFormat::Float2,
+                                    format: wgpu::VertexFormat::Float32x2,
                                     offset: 4 * 6,
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 5,
-                                    format: wgpu::VertexFormat::Uint,
+                                    format: wgpu::VertexFormat::Sint32,
                                     offset: 4 * 8,
                                 },
                             ],
@@ -193,27 +196,28 @@ impl Pipeline {
                     ],
                 },
                 fragment: Some(wgpu::FragmentState {
-                    module: &fs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "fs_main",
                     targets: &[wgpu::ColorTargetState {
                         format,
-                        color_blend: wgpu::BlendState {
+                        blend: Some(wgpu::BlendState {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
+                            color: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::SrcAlpha,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
-                        alpha_blend: wgpu::BlendState {
+                            },
-                            src_factor: wgpu::BlendFactor::One,
+                            alpha: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::One,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
+                            },
+                        }),
                         write_mask: wgpu::ColorWrite::ALL,
                     }],
                 }),
                 primitive: wgpu::PrimitiveState {
                     topology: wgpu::PrimitiveTopology::TriangleList,
                     front_face: wgpu::FrontFace::Cw,
-                    cull_mode: wgpu::CullMode::None,
                     ..Default::default()
                 },
                 depth_stencil: None,
@@ -423,16 +427,14 @@ impl Pipeline {
             let mut render_pass =
                 encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                     label: Some("iced_wgpu::image render pass"),
-                    color_attachments: &[
+                    color_attachments: &[wgpu::RenderPassColorAttachment {
-                        wgpu::RenderPassColorAttachmentDescriptor {
+                        view: target,
-                            attachment: target,
+                        resolve_target: None,
-                            resolve_target: None,
+                        ops: wgpu::Operations {
-                            ops: wgpu::Operations {
+                            load: wgpu::LoadOp::Load,
-                                load: wgpu::LoadOp::Load,
+                            store: true,
-                                store: true,
-                            },
                         },
-                    ],
+                    }],
                     depth_stencil_attachment: None,
                 });
 

wgpu/src/image/atlas.rs

@@ -4,6 +4,8 @@ mod allocation;
 mod allocator;
 mod layer;
 
+use std::num::NonZeroU32;
+
 pub use allocation::Allocation;
 pub use entry::Entry;
 pub use layer::Layer;
@@ -24,7 +26,7 @@ impl Atlas {
         let extent = wgpu::Extent3d {
             width: SIZE,
             height: SIZE,
-            depth: 1,
+            depth_or_array_layers: 1,
         };
 
         let texture = device.create_texture(&wgpu::TextureDescriptor {
@@ -294,19 +296,19 @@ impl Atlas {
         let extent = wgpu::Extent3d {
             width,
             height,
-            depth: 1,
+            depth_or_array_layers: 1,
         };
 
         encoder.copy_buffer_to_texture(
-            wgpu::BufferCopyView {
+            wgpu::ImageCopyBuffer {
                 buffer,
-                layout: wgpu::TextureDataLayout {
+                layout: wgpu::ImageDataLayout {
                     offset: offset as u64,
-                    bytes_per_row: 4 * image_width + padding,
+                    bytes_per_row: NonZeroU32::new(4 * image_width + padding),
-                    rows_per_image: image_height,
+                    rows_per_image: NonZeroU32::new(image_height),
                 },
             },
-            wgpu::TextureCopyView {
+            wgpu::ImageCopyTexture {
                 texture: &self.texture,
                 mip_level: 0,
                 origin: wgpu::Origin3d {
@@ -334,7 +336,7 @@ impl Atlas {
             size: wgpu::Extent3d {
                 width: SIZE,
                 height: SIZE,
-                depth: self.layers.len() as u32,
+                depth_or_array_layers: self.layers.len() as u32,
             },
             mip_level_count: 1,
             sample_count: 1,
@@ -355,7 +357,7 @@ impl Atlas {
             }
 
             encoder.copy_texture_to_texture(
-                wgpu::TextureCopyView {
+                wgpu::ImageCopyTexture {
                     texture: &self.texture,
                     mip_level: 0,
                     origin: wgpu::Origin3d {
@@ -364,7 +366,7 @@ impl Atlas {
                         z: i as u32,
                     },
                 },
-                wgpu::TextureCopyView {
+                wgpu::ImageCopyTexture {
                     texture: &new_texture,
                     mip_level: 0,
                     origin: wgpu::Origin3d {
@@ -376,7 +378,7 @@ impl Atlas {
                 wgpu::Extent3d {
                     width: SIZE,
                     height: SIZE,
-                    depth: 1,
+                    depth_or_array_layers: 1,
                 },
             );
         }

wgpu/src/quad.rs

@@ -28,7 +28,7 @@ impl Pipeline {
                         ty: wgpu::BufferBindingType::Uniform,
                         has_dynamic_offset: false,
                         min_binding_size: wgpu::BufferSize::new(
-                            mem::size_of::<Uniforms>() as u64,
+                            mem::size_of::<Uniforms>() as wgpu::BufferAddress,
                         ),
                     },
                     count: None,
@@ -37,7 +37,7 @@ impl Pipeline {
 
         let constants_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("iced_wgpu::quad uniforms buffer"),
-            size: mem::size_of::<Uniforms>() as u64,
+            size: mem::size_of::<Uniforms>() as wgpu::BufferAddress,
             usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
             mapped_at_creation: false,
         });
@@ -47,11 +47,7 @@ impl Pipeline {
             layout: &constant_layout,
             entries: &[wgpu::BindGroupEntry {
                 binding: 0,
-                resource: wgpu::BindingResource::Buffer {
+                resource: constants_buffer.as_entire_binding(),
-                    buffer: &constants_buffer,
-                    offset: 0,
-                    size: None,
-                },
             }],
         });
 
@@ -62,28 +58,29 @@ impl Pipeline {
                 bind_group_layouts: &[&constant_layout],
             });
 
-        let vs_module = device.create_shader_module(&wgpu::include_spirv!(
+        let shader =
-            "shader/quad.vert.spv"
+            device.create_shader_module(&wgpu::ShaderModuleDescriptor {
-        ));
+                label: Some("iced_wgpu::quad::shader"),
-
+                source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
-        let fs_module = device.create_shader_module(&wgpu::include_spirv!(
+                    include_str!("shader/quad.wgsl"),
-            "shader/quad.frag.spv"
+                )),
-        ));
+                flags: wgpu::ShaderFlags::all(),
+            });
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some("iced_wgpu::quad pipeline"),
                 layout: Some(&layout),
                 vertex: wgpu::VertexState {
-                    module: &vs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "vs_main",
                     buffers: &[
                         wgpu::VertexBufferLayout {
                             array_stride: mem::size_of::<Vertex>() as u64,
                             step_mode: wgpu::InputStepMode::Vertex,
                             attributes: &[wgpu::VertexAttribute {
                                 shader_location: 0,
-                                format: wgpu::VertexFormat::Float2,
+                                format: wgpu::VertexFormat::Float32x2,
                                 offset: 0,
                             }],
                         },
@@ -93,32 +90,32 @@ impl Pipeline {
                             attributes: &[
                                 wgpu::VertexAttribute {
                                     shader_location: 1,
-                                    format: wgpu::VertexFormat::Float2,
+                                    format: wgpu::VertexFormat::Float32x2,
                                     offset: 0,
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 2,
-                                    format: wgpu::VertexFormat::Float2,
+                                    format: wgpu::VertexFormat::Float32x2,
                                     offset: 4 * 2,
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 3,
-                                    format: wgpu::VertexFormat::Float4,
+                                    format: wgpu::VertexFormat::Float32x4,
                                     offset: 4 * (2 + 2),
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 4,
-                                    format: wgpu::VertexFormat::Float4,
+                                    format: wgpu::VertexFormat::Float32x4,
                                     offset: 4 * (2 + 2 + 4),
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 5,
-                                    format: wgpu::VertexFormat::Float,
+                                    format: wgpu::VertexFormat::Float32,
                                     offset: 4 * (2 + 2 + 4 + 4),
                                 },
                                 wgpu::VertexAttribute {
                                     shader_location: 6,
-                                    format: wgpu::VertexFormat::Float,
+                                    format: wgpu::VertexFormat::Float32,
                                     offset: 4 * (2 + 2 + 4 + 4 + 1),
                                 },
                             ],
@@ -126,27 +123,28 @@ impl Pipeline {
                     ],
                 },
                 fragment: Some(wgpu::FragmentState {
-                    module: &fs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "fs_main",
                     targets: &[wgpu::ColorTargetState {
                         format,
-                        color_blend: wgpu::BlendState {
+                        blend: Some(wgpu::BlendState {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
+                            color: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::SrcAlpha,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
-                        alpha_blend: wgpu::BlendState {
+                            },
-                            src_factor: wgpu::BlendFactor::One,
+                            alpha: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::One,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
+                            },
+                        }),
                         write_mask: wgpu::ColorWrite::ALL,
                     }],
                 }),
                 primitive: wgpu::PrimitiveState {
                     topology: wgpu::PrimitiveTopology::TriangleList,
                     front_face: wgpu::FrontFace::Cw,
-                    cull_mode: wgpu::CullMode::None,
                     ..Default::default()
                 },
                 depth_stencil: None,
@@ -237,16 +235,14 @@ impl Pipeline {
                 let mut render_pass =
                     encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                         label: Some("iced_wgpu::quad render pass"),
-                        color_attachments: &[
+                        color_attachments: &[wgpu::RenderPassColorAttachment {
-                            wgpu::RenderPassColorAttachmentDescriptor {
+                            view: target,
-                                attachment: target,
+                            resolve_target: None,
-                                resolve_target: None,
+                            ops: wgpu::Operations {
-                                ops: wgpu::Operations {
+                                load: wgpu::LoadOp::Load,
-                                    load: wgpu::LoadOp::Load,
+                                store: true,
-                                    store: true,
-                                },
                             },
-                        ],
+                        }],
                         depth_stencil_attachment: None,
                     });
 
@@ -309,6 +305,9 @@ const MAX_INSTANCES: usize = 100_000;
 struct Uniforms {
     transform: [f32; 16],
     scale: f32,
+    // Uniforms must be aligned to their largest member,
+    // this uses a mat4x4<f32> which aligns to 16, so align to that
+    _padding: [f32; 3],
 }
 
 impl Uniforms {
@@ -316,6 +315,7 @@ impl Uniforms {
         Self {
             transform: *transformation.as_ref(),
             scale,
+            _padding: [0.0; 3],
         }
     }
 }
@@ -325,6 +325,7 @@ impl Default for Uniforms {
         Self {
             transform: *Transformation::identity().as_ref(),
             scale: 1.0,
+            _padding: [0.0; 3],
         }
     }
 }

wgpu/src/shader/blit.frag

@@ -1,12 +0,0 @@
-#version 450
-
-layout(location = 0) in vec2 v_Uv;
-
-layout(set = 0, binding = 0) uniform sampler u_Sampler;
-layout(set = 1, binding = 0) uniform texture2D u_Texture;
-
-layout(location = 0) out vec4 o_Color;
-
-void main() {
-    o_Color = texture(sampler2D(u_Texture, u_Sampler), v_Uv);
-}

wgpu/src/shader/blit.vert

@@ -1,26 +0,0 @@
-#version 450
-
-layout(location = 0) out vec2 o_Uv;
-
-const vec2 positions[6] = vec2[6](
-    vec2(-1.0, 1.0),
-    vec2(-1.0, -1.0),
-    vec2(1.0, -1.0),
-    vec2(-1.0, 1.0),
-    vec2(1.0, 1.0),
-    vec2(1.0, -1.0)
-);
-
-const vec2 uvs[6] = vec2[6](
-    vec2(0.0, 0.0),
-    vec2(0.0, 1.0),
-    vec2(1.0, 1.0),
-    vec2(0.0, 0.0),
-    vec2(1.0, 0.0),
-    vec2(1.0, 1.0)
-);
-
-void main() {
-    o_Uv = uvs[gl_VertexIndex];
-    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
-}

wgpu/src/shader/blit.wgsl

@@ -0,0 +1,43 @@
+var positions: array<vec2<f32>, 6> = array<vec2<f32>, 6>(
+    vec2<f32>(-1.0, 1.0),
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>(1.0, -1.0),
+    vec2<f32>(-1.0, 1.0),
+    vec2<f32>(1.0, 1.0),
+    vec2<f32>(1.0, -1.0)
+);
+
+var uvs: array<vec2<f32>, 6> = array<vec2<f32>, 6>(
+    vec2<f32>(0.0, 0.0),
+    vec2<f32>(0.0, 1.0),
+    vec2<f32>(1.0, 1.0),
+    vec2<f32>(0.0, 0.0),
+    vec2<f32>(1.0, 0.0),
+    vec2<f32>(1.0, 1.0)
+);
+
+[[group(0), binding(0)]] var u_sampler: sampler;
+[[group(1), binding(0)]] var u_texture: texture_2d<f32>;
+
+struct VertexInput {
+    [[builtin(vertex_index)]] vertex_index: u32;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] position: vec4<f32>;
+    [[location(0)]] uv: vec2<f32>;
+};
+
+[[stage(vertex)]]
+fn vs_main(input: VertexInput) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = uvs[input.vertex_index];
+    out.position = vec4<f32>(positions[input.vertex_index], 0.0, 1.0);
+
+    return out;
+}
+
+[[stage(fragment)]]
+fn fs_main(input: VertexOutput) -> [[location(0)]] vec4<f32> {
+    return textureSample(u_texture, u_sampler, input.uv);
+}

wgpu/src/shader/image.frag

@@ -1,12 +0,0 @@
-#version 450
-
-layout(location = 0) in vec3 v_Uv;
-
-layout(set = 0, binding = 1) uniform sampler u_Sampler;
-layout(set = 1, binding = 0) uniform texture2DArray u_Texture;
-
-layout(location = 0) out vec4 o_Color;
-
-void main() {
-    o_Color = texture(sampler2DArray(u_Texture, u_Sampler), v_Uv);
-}

wgpu/src/shader/image.vert

@@ -1,27 +0,0 @@
-#version 450
-
-layout(location = 0) in vec2 v_Pos;
-layout(location = 1) in vec2 i_Pos;
-layout(location = 2) in vec2 i_Scale;
-layout(location = 3) in vec2 i_Atlas_Pos;
-layout(location = 4) in vec2 i_Atlas_Scale;
-layout(location = 5) in uint i_Layer;
-
-layout (set = 0, binding = 0) uniform Globals {
-    mat4 u_Transform;
-};
-
-layout(location = 0) out vec3 o_Uv;
-
-void main() {
-    o_Uv = vec3(v_Pos * i_Atlas_Scale + i_Atlas_Pos, i_Layer);
-
-    mat4 i_Transform = mat4(
-        vec4(i_Scale.x, 0.0, 0.0, 0.0),
-        vec4(0.0, i_Scale.y, 0.0, 0.0),
-        vec4(0.0, 0.0, 1.0, 0.0),
-        vec4(i_Pos, 0.0, 1.0)
-    );
-
-    gl_Position = u_Transform * i_Transform * vec4(v_Pos, 0.0, 1.0);
-}

wgpu/src/shader/image.wgsl

@@ -0,0 +1,47 @@
+[[block]]
+struct Globals {
+    transform: mat4x4<f32>;
+};
+
+[[group(0), binding(0)]] var<uniform> globals: Globals;
+[[group(0), binding(1)]] var u_sampler: sampler;
+[[group(1), binding(0)]] var u_texture: texture_2d_array<f32>;
+
+struct VertexInput {
+    [[location(0)]] v_pos: vec2<f32>;
+    [[location(1)]] pos: vec2<f32>;
+    [[location(2)]] scale: vec2<f32>;
+    [[location(3)]] atlas_pos: vec2<f32>;
+    [[location(4)]] atlas_scale: vec2<f32>;
+    [[location(5)]] layer: i32;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] position: vec4<f32>;
+    [[location(0)]] uv: vec2<f32>;
+    [[location(1)]] layer: f32; // this should be an i32, but naga currently reads that as requiring interpolation.
+};
+
+[[stage(vertex)]]
+fn vs_main(input: VertexInput) -> VertexOutput {
+    var out: VertexOutput;
+
+    out.uv = vec2<f32>(input.v_pos * input.atlas_scale + input.atlas_pos);
+    out.layer = f32(input.layer);
+
+    var transform: mat4x4<f32> = mat4x4<f32>(
+        vec4<f32>(input.scale.x, 0.0, 0.0, 0.0),
+        vec4<f32>(0.0, input.scale.y, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0),
+        vec4<f32>(input.pos, 0.0, 1.0)
+    );
+
+    out.position = globals.transform * transform * vec4<f32>(input.v_pos, 0.0, 1.0);
+
+    return out;
+}
+
+[[stage(fragment)]]
+fn fs_main(input: VertexOutput) -> [[location(0)]] vec4<f32> {
+    return textureSample(u_texture, u_sampler, input.uv, i32(input.layer));
+}

wgpu/src/shader/quad.frag

@@ -1,66 +0,0 @@
-#version 450
-
-layout(location = 0) in vec4 v_Color;
-layout(location = 1) in vec4 v_BorderColor;
-layout(location = 2) in vec2 v_Pos;
-layout(location = 3) in vec2 v_Scale;
-layout(location = 4) in float v_BorderRadius;
-layout(location = 5) in float v_BorderWidth;
-
-layout(location = 0) out vec4 o_Color;
-
-float distance(in vec2 frag_coord, in vec2 position, in vec2 size, float radius)
-{
-    // TODO: Try SDF approach: https://www.shadertoy.com/view/wd3XRN
-    vec2 inner_size = size - vec2(radius, radius) * 2.0;
-    vec2 top_left = position + vec2(radius, radius);
-    vec2 bottom_right = top_left + inner_size;
-
-    vec2 top_left_distance = top_left - frag_coord;
-    vec2 bottom_right_distance = frag_coord - bottom_right;
-
-    vec2 distance = vec2(
-        max(max(top_left_distance.x, bottom_right_distance.x), 0),
-        max(max(top_left_distance.y, bottom_right_distance.y), 0)
-    );
-
-    return sqrt(distance.x * distance.x + distance.y * distance.y);
-}
-
-void main() {
-    vec4 mixed_color;
-
-    // TODO: Remove branching (?)
-    if(v_BorderWidth > 0) {
-        float internal_border = max(v_BorderRadius - v_BorderWidth, 0);
-
-        float internal_distance = distance(
-            gl_FragCoord.xy,
-            v_Pos + vec2(v_BorderWidth),
-            v_Scale - vec2(v_BorderWidth * 2.0),
-            internal_border
-        );
-
-        float border_mix = smoothstep(
-            max(internal_border - 0.5, 0.0),
-            internal_border + 0.5,
-            internal_distance
-        );
-
-        mixed_color = mix(v_Color, v_BorderColor, border_mix);
-    } else {
-        mixed_color = v_Color;
-    }
-
-    float d = distance(
-        gl_FragCoord.xy,
-        v_Pos,
-        v_Scale,
-        v_BorderRadius
-    );
-
-    float radius_alpha =
-        1.0 - smoothstep(max(v_BorderRadius - 0.5, 0), v_BorderRadius + 0.5, d);
-
-    o_Color = vec4(mixed_color.xyz, mixed_color.w * radius_alpha);
-}

wgpu/src/shader/quad.vert

@@ -1,47 +0,0 @@
-#version 450
-
-layout(location = 0) in vec2 v_Pos;
-layout(location = 1) in vec2 i_Pos;
-layout(location = 2) in vec2 i_Scale;
-layout(location = 3) in vec4 i_Color;
-layout(location = 4) in vec4 i_BorderColor;
-layout(location = 5) in float i_BorderRadius;
-layout(location = 6) in float i_BorderWidth;
-
-layout (set = 0, binding = 0) uniform Globals {
-    mat4 u_Transform;
-    float u_Scale;
-};
-
-layout(location = 0) out vec4 o_Color;
-layout(location = 1) out vec4 o_BorderColor;
-layout(location = 2) out vec2 o_Pos;
-layout(location = 3) out vec2 o_Scale;
-layout(location = 4) out float o_BorderRadius;
-layout(location = 5) out float o_BorderWidth;
-
-void main() {
-    vec2 p_Pos = i_Pos * u_Scale;
-    vec2 p_Scale = i_Scale  * u_Scale;
-
-    float i_BorderRadius = min(
-        i_BorderRadius,
-        min(i_Scale.x, i_Scale.y) / 2.0
-    );
-
-    mat4 i_Transform = mat4(
-        vec4(p_Scale.x + 1.0, 0.0, 0.0, 0.0),
-        vec4(0.0, p_Scale.y + 1.0, 0.0, 0.0),
-        vec4(0.0, 0.0, 1.0, 0.0),
-        vec4(p_Pos - vec2(0.5, 0.5), 0.0, 1.0)
-    );
-
-    o_Color = i_Color;
-    o_BorderColor = i_BorderColor;
-    o_Pos = p_Pos;
-    o_Scale = p_Scale;
-    o_BorderRadius = i_BorderRadius * u_Scale;
-    o_BorderWidth = i_BorderWidth * u_Scale;
-
-    gl_Position = u_Transform * i_Transform * vec4(v_Pos, 0.0, 1.0);
-}

wgpu/src/shader/quad.wgsl

@@ -0,0 +1,122 @@
+[[block]]
+struct Globals {
+    transform: mat4x4<f32>;
+    scale: f32;
+};
+
+[[group(0), binding(0)]] var<uniform> globals: Globals;
+
+struct VertexInput {
+    [[location(0)]] v_pos: vec2<f32>;
+    [[location(1)]] pos: vec2<f32>;
+    [[location(2)]] scale: vec2<f32>;
+    [[location(3)]] color: vec4<f32>;
+    [[location(4)]] border_color: vec4<f32>;
+    [[location(5)]] border_radius: f32;
+    [[location(6)]] border_width: f32;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] position: vec4<f32>;
+    [[location(0)]] color: vec4<f32>;
+    [[location(1)]] border_color: vec4<f32>;
+    [[location(2)]] pos: vec2<f32>;
+    [[location(3)]] scale: vec2<f32>;
+    [[location(4)]] border_radius: f32;
+    [[location(5)]] border_width: f32;
+};
+
+[[stage(vertex)]]
+fn vs_main(input: VertexInput) -> VertexOutput {
+    var out: VertexOutput;
+
+    var pos: vec2<f32> = input.pos * globals.scale;
+    var scale: vec2<f32> = input.scale * globals.scale;
+
+    var border_radius: f32 = min(
+        input.border_radius,
+        min(input.scale.x, input.scale.y) / 2.0
+    );
+
+    var transform: mat4x4<f32> = mat4x4<f32>(
+        vec4<f32>(scale.x + 1.0, 0.0, 0.0, 0.0),
+        vec4<f32>(0.0, scale.y + 1.0, 0.0, 0.0),
+        vec4<f32>(0.0, 0.0, 1.0, 0.0),
+        vec4<f32>(pos - vec2<f32>(0.5, 0.5), 0.0, 1.0)
+    );
+
+    out.color = input.color;
+    out.border_color = input.border_color;
+    out.pos = pos;
+    out.scale = scale;
+    out.border_radius = border_radius * globals.scale;
+    out.border_width = input.border_width * globals.scale;
+    out.position = globals.transform * transform * vec4<f32>(input.v_pos, 0.0, 1.0);
+
+    return out;
+}
+
+fn distance_alg(
+    frag_coord: vec2<f32>,
+    position: vec2<f32>,
+    size: vec2<f32>,
+    radius: f32
+) -> f32 {
+    var inner_size: vec2<f32> = size - vec2<f32>(radius, radius) * 2.0;
+    var top_left: vec2<f32> = position + vec2<f32>(radius, radius);
+    var bottom_right: vec2<f32> = top_left + inner_size;
+
+    var top_left_distance: vec2<f32> = top_left - frag_coord;
+    var bottom_right_distance: vec2<f32> = frag_coord - bottom_right;
+
+    var dist: vec2<f32> = vec2<f32>(
+        max(max(top_left_distance.x, bottom_right_distance.x), 0.0),
+        max(max(top_left_distance.y, bottom_right_distance.y), 0.0)
+    );
+
+    return sqrt(dist.x * dist.x + dist.y * dist.y);
+}
+
+
+[[stage(fragment)]]
+fn fs_main(
+    input: VertexOutput
+) -> [[location(0)]] vec4<f32> {
+    var mixed_color: vec4<f32> = input.color;
+
+    if (input.border_width > 0.0) {
+        var internal_border: f32 = max(
+            input.border_radius - input.border_width,
+            0.0
+        );
+
+        var internal_distance: f32 = distance_alg(
+            vec2<f32>(input.position.x, input.position.y),
+            input.pos + vec2<f32>(input.border_width, input.border_width),
+            input.scale - vec2<f32>(input.border_width * 2.0, input.border_width * 2.0),
+            internal_border
+        );
+
+        var border_mix: f32 = smoothStep(
+            max(internal_border - 0.5, 0.0),
+            internal_border + 0.5,
+            internal_distance
+        );
+
+        mixed_color = mix(input.color, input.border_color, vec4<f32>(border_mix, border_mix, border_mix, border_mix));
+    }
+
+    var dist: f32 = distance_alg(
+        vec2<f32>(input.position.x, input.position.y),
+        input.pos,
+        input.scale,
+        input.border_radius
+    );
+
+    var radius_alpha: f32 = 1.0 - smoothStep(
+        max(input.border_radius - 0.5, 0.0),
+        input.border_radius + 0.5,
+        dist);
+
+    return vec4<f32>(mixed_color.x, mixed_color.y, mixed_color.z, mixed_color.w * radius_alpha);
+}

wgpu/src/shader/triangle.frag

@@ -1,8 +0,0 @@
-#version 450
-
-layout(location = 0) in vec4 i_Color;
-layout(location = 0) out vec4 o_Color;
-
-void main() {
-    o_Color = i_Color;
-}

wgpu/src/shader/triangle.vert

@@ -1,15 +0,0 @@
-#version 450
-
-layout(location = 0) in vec2 i_Position;
-layout(location = 1) in vec4 i_Color;
-
-layout(location = 0) out vec4 o_Color;
-
-layout (set = 0, binding = 0) uniform Globals {
-    mat4 u_Transform;
-};
-
-void main() {
-    gl_Position = u_Transform * vec4(i_Position, 0.0, 1.0);
-    o_Color = i_Color;
-}

wgpu/src/shader/triangle.wgsl

@@ -0,0 +1,31 @@
+[[block]]
+struct Globals {
+    transform: mat4x4<f32>;
+};
+
+[[group(0), binding(0)]] var<uniform> globals: Globals;
+
+struct VertexInput {
+    [[location(0)]] position: vec2<f32>;
+    [[location(1)]] color: vec4<f32>;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] position: vec4<f32>;
+    [[location(0)]] color: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vs_main(input: VertexInput) -> VertexOutput {
+    var out: VertexOutput;
+
+    out.color = input.color;
+    out.position = globals.transform * vec4<f32>(input.position, 0.0, 1.0);
+
+    return out;
+}
+
+[[stage(fragment)]]
+fn fs_main(input: VertexOutput) -> [[location(0)]] vec4<f32> {
+    return input.color;
+}

wgpu/src/triangle.rs

@@ -110,13 +110,17 @@ impl Pipeline {
                 layout: &constants_layout,
                 entries: &[wgpu::BindGroupEntry {
                     binding: 0,
-                    resource: wgpu::BindingResource::Buffer {
+                    resource: wgpu::BindingResource::Buffer(
-                        buffer: &constants_buffer.raw,
+                        wgpu::BufferBinding {
-                        offset: 0,
+                            buffer: &constants_buffer.raw,
-                        size: wgpu::BufferSize::new(
+                            offset: 0,
-                            std::mem::size_of::<Uniforms>() as u64,
+                            size: wgpu::BufferSize::new(std::mem::size_of::<
-                        ),
+                                Uniforms,
-                    },
+                            >(
+                            )
+                                as u64),
+                        },
+                    ),
                 }],
             });
 
@@ -127,21 +131,22 @@ impl Pipeline {
                 bind_group_layouts: &[&constants_layout],
             });
 
-        let vs_module = device.create_shader_module(&wgpu::include_spirv!(
+        let shader =
-            "shader/triangle.vert.spv"
+            device.create_shader_module(&wgpu::ShaderModuleDescriptor {
-        ));
+                label: Some("iced_wgpu::triangle::shader"),
-
+                source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
-        let fs_module = device.create_shader_module(&wgpu::include_spirv!(
+                    include_str!("shader/triangle.wgsl"),
-            "shader/triangle.frag.spv"
+                )),
-        ));
+                flags: wgpu::ShaderFlags::all(),
+            });
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some("iced_wgpu::triangle pipeline"),
                 layout: Some(&layout),
                 vertex: wgpu::VertexState {
-                    module: &vs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "vs_main",
                     buffers: &[wgpu::VertexBufferLayout {
                         array_stride: mem::size_of::<Vertex2D>() as u64,
                         step_mode: wgpu::InputStepMode::Vertex,
@@ -149,40 +154,41 @@ impl Pipeline {
                             // Position
                             wgpu::VertexAttribute {
                                 shader_location: 0,
-                                format: wgpu::VertexFormat::Float2,
+                                format: wgpu::VertexFormat::Float32x2,
                                 offset: 0,
                             },
                             // Color
                             wgpu::VertexAttribute {
                                 shader_location: 1,
-                                format: wgpu::VertexFormat::Float4,
+                                format: wgpu::VertexFormat::Float32x4,
                                 offset: 4 * 2,
                             },
                         ],
                     }],
                 },
                 fragment: Some(wgpu::FragmentState {
-                    module: &fs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "fs_main",
                     targets: &[wgpu::ColorTargetState {
                         format,
-                        color_blend: wgpu::BlendState {
+                        blend: Some(wgpu::BlendState {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
+                            color: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::SrcAlpha,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
-                        alpha_blend: wgpu::BlendState {
+                            },
-                            src_factor: wgpu::BlendFactor::One,
+                            alpha: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::One,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
+                            },
+                        }),
                         write_mask: wgpu::ColorWrite::ALL,
                     }],
                 }),
                 primitive: wgpu::PrimitiveState {
                     topology: wgpu::PrimitiveTopology::TriangleList,
                     front_face: wgpu::FrontFace::Cw,
-                    cull_mode: wgpu::CullMode::None,
                     ..Default::default()
                 },
                 depth_stencil: None,
@@ -254,15 +260,15 @@ impl Pipeline {
                     layout: &self.constants_layout,
                     entries: &[wgpu::BindGroupEntry {
                         binding: 0,
-                        resource: wgpu::BindingResource::Buffer {
+                        resource: wgpu::BindingResource::Buffer(
-                            buffer: &self.uniforms_buffer.raw,
+                            wgpu::BufferBinding {
-                            offset: 0,
+                                buffer: &self.uniforms_buffer.raw,
-                            size: wgpu::BufferSize::new(std::mem::size_of::<
+                                offset: 0,
-                                Uniforms,
+                                size: wgpu::BufferSize::new(
-                            >(
+                                    std::mem::size_of::<Uniforms>() as u64,
-                            )
+                                ),
-                                as u64),
+                            },
-                        },
+                        ),
                     }],
                 });
         }
@@ -363,13 +369,11 @@ impl Pipeline {
             let mut render_pass =
                 encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                     label: Some("iced_wgpu::triangle render pass"),
-                    color_attachments: &[
+                    color_attachments: &[wgpu::RenderPassColorAttachment {
-                        wgpu::RenderPassColorAttachmentDescriptor {
+                        view: attachment,
-                            attachment,
+                        resolve_target,
-                            resolve_target,
+                        ops: wgpu::Operations { load, store: true },
-                            ops: wgpu::Operations { load, store: true },
+                    }],
-                        },
-                    ],
                     depth_stencil_attachment: None,
                 });
 

wgpu/src/triangle/msaa.rs

@@ -20,9 +20,9 @@ impl Blit {
             address_mode_u: wgpu::AddressMode::ClampToEdge,
             address_mode_v: wgpu::AddressMode::ClampToEdge,
             address_mode_w: wgpu::AddressMode::ClampToEdge,
-            mag_filter: wgpu::FilterMode::Linear,
+            mag_filter: wgpu::FilterMode::Nearest,
-            min_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Nearest,
-            mipmap_filter: wgpu::FilterMode::Linear,
+            mipmap_filter: wgpu::FilterMode::Nearest,
             ..Default::default()
         });
 
@@ -74,45 +74,47 @@ impl Blit {
                 bind_group_layouts: &[&constant_layout, &texture_layout],
             });
 
-        let vs_module = device.create_shader_module(&wgpu::include_spirv!(
+        let shader =
-            "../shader/blit.vert.spv"
+            device.create_shader_module(&wgpu::ShaderModuleDescriptor {
-        ));
+                label: Some("iced_wgpu::triangle::blit_shader"),
-
+                source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(
-        let fs_module = device.create_shader_module(&wgpu::include_spirv!(
+                    include_str!("../shader/blit.wgsl"),
-            "../shader/blit.frag.spv"
+                )),
-        ));
+                flags: wgpu::ShaderFlags::all(),
+            });
 
         let pipeline =
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some("iced_wgpu::triangle::msaa pipeline"),
                 layout: Some(&layout),
                 vertex: wgpu::VertexState {
-                    module: &vs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "vs_main",
                     buffers: &[],
                 },
                 fragment: Some(wgpu::FragmentState {
-                    module: &fs_module,
+                    module: &shader,
-                    entry_point: "main",
+                    entry_point: "fs_main",
                     targets: &[wgpu::ColorTargetState {
                         format,
-                        color_blend: wgpu::BlendState {
+                        blend: Some(wgpu::BlendState {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
+                            color: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::SrcAlpha,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
-                        alpha_blend: wgpu::BlendState {
+                            },
-                            src_factor: wgpu::BlendFactor::One,
+                            alpha: wgpu::BlendComponent {
-                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                                src_factor: wgpu::BlendFactor::One,
-                            operation: wgpu::BlendOperation::Add,
+                                dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                        },
+                                operation: wgpu::BlendOperation::Add,
+                            },
+                        }),
                         write_mask: wgpu::ColorWrite::ALL,
                     }],
                 }),
                 primitive: wgpu::PrimitiveState {
                     topology: wgpu::PrimitiveTopology::TriangleList,
                     front_face: wgpu::FrontFace::Cw,
-                    cull_mode: wgpu::CullMode::None,
                     ..Default::default()
                 },
                 depth_stencil: None,
@@ -177,16 +179,14 @@ impl Blit {
         let mut render_pass =
             encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                 label: Some("iced_wgpu::triangle::msaa render pass"),
-                color_attachments: &[
+                color_attachments: &[wgpu::RenderPassColorAttachment {
-                    wgpu::RenderPassColorAttachmentDescriptor {
+                    view: target,
-                        attachment: target,
+                    resolve_target: None,
-                        resolve_target: None,
+                    ops: wgpu::Operations {
-                        ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Load,
-                            load: wgpu::LoadOp::Load,
+                        store: true,
-                            store: true,
-                        },
                     },
-                ],
+                }],
                 depth_stencil_attachment: None,
             });
 
@@ -222,7 +222,7 @@ impl Targets {
         let extent = wgpu::Extent3d {
             width,
             height,
-            depth: 1,
+            depth_or_array_layers: 1,
         };
 
         let attachment = device.create_texture(&wgpu::TextureDescriptor {

wgpu/src/window/compositor.rs

@@ -146,8 +146,8 @@ impl iced_graphics::window::Compositor for Compositor {
 
         let _ = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             label: Some("iced_wgpu::window::Compositor render pass"),
-            color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
+            color_attachments: &[wgpu::RenderPassColorAttachment {
-                attachment: &frame.output.view,
+                view: &frame.output.view,
                 resolve_target: None,
                 ops: wgpu::Operations {
                     load: wgpu::LoadOp::Clear({