Merge pull request #26 from keller-mark/keller-mark/wgpu-26_0_1

Upgrade wgpu to v26.0.1

Author: wtholliday

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2" # What does this do?
 [package]
 name = "vger"
 description = "2D GPU renderer for dynamic UIs"
-version = "0.4.0"
+version = "0.5.0"
 license = "MIT"
 readme = "README.md"
 authors = ["Taylor Holliday <taylor@audulus.com>"]
@@ -16,9 +16,9 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-wgpu = "22"
+wgpu = "26.0.1"
 euclid = "0.22.7"
-fontdue = "0.9.0"
+fontdue = "0.9.3"
 rect_packer = "0.2.1"
 
 [dev-dependencies]

src/atlas.rs

@@ -98,15 +98,15 @@ impl Atlas {
             };
 
             encoder.copy_buffer_to_texture(
-                wgpu::ImageCopyBuffer {
+                wgpu::TexelCopyBufferInfo {
                     buffer: &buffer,
-                    layout: wgpu::ImageDataLayout {
+                    layout: wgpu::TexelCopyBufferLayout {
                         offset: 0,
                         bytes_per_row: Some(sz as u32),
                         rows_per_image: None,
                     },
                 },
-                wgpu::ImageCopyTexture {
+                wgpu::TexelCopyTextureInfo {
                     texture: &self.atlas_texture,
                     mip_level: 0,
                     aspect: wgpu::TextureAspect::All,
@@ -152,15 +152,15 @@ impl Atlas {
             };
 
             encoder.copy_buffer_to_texture(
-                wgpu::ImageCopyBuffer {
+                wgpu::TexelCopyBufferInfo {
                     buffer: &buffer,
-                    layout: wgpu::ImageDataLayout {
+                    layout: wgpu::TexelCopyBufferLayout {
                         offset: 0,
                         bytes_per_row: Some(padded_width as u32),
                         rows_per_image: None,
                     },
                 },
-                wgpu::ImageCopyTexture {
+                wgpu::TexelCopyTextureInfo {
                     texture: &self.atlas_texture,
                     mip_level: 0,
                     aspect: wgpu::TextureAspect::All,

src/lib.rs

@@ -227,13 +227,13 @@ impl Vger {
             layout: Some(&pipeline_layout),
             vertex: wgpu::VertexState {
                 module: &shader,
-                entry_point: "vs_main",
+                entry_point: Some("vs_main"),
                 compilation_options: wgpu::PipelineCompilationOptions::default(),
                 buffers: &[],
             },
             fragment: Some(wgpu::FragmentState {
                 module: &shader,
-                entry_point: "fs_main",
+                entry_point: Some("fs_main"),
                 compilation_options: wgpu::PipelineCompilationOptions::default(),
                 targets: &[Some(wgpu::ColorTargetState {
                     format: texture_format,
@@ -988,15 +988,15 @@ impl Vger {
         };
 
         encoder.copy_buffer_to_texture(
-            wgpu::ImageCopyBuffer {
+            wgpu::TexelCopyBufferInfo {
                 buffer: &buffer,
-                layout: wgpu::ImageDataLayout {
+                layout: wgpu::TexelCopyBufferLayout {
                     offset: 0,
                     bytes_per_row: Some(width * 4),
                     rows_per_image: Some(height),
                 },
             },
-            wgpu::ImageCopyTexture {
+            wgpu::TexelCopyTextureInfo {
                 texture: &texture,
                 mip_level: 0,
                 aspect: wgpu::TextureAspect::All,

src/shader.wgsl

@@ -505,7 +505,7 @@ var<storage> xforms: XForms;
 
 struct VertexOutput {
     @builtin(position) position: vec4<f32>,
-    @location(0) prim_index: u32,
+    @location(0) @interpolate(flat) prim_index: u32,
 
     /// Texture space point.
     @location(1) t: vec2<f32>,

tests/common.rs

@@ -5,7 +5,7 @@ use vger::*;
 pub async fn setup() -> (wgpu::Device, wgpu::Queue) {
     let instance_desc = wgpu::InstanceDescriptor::default();
 
-    let instance = wgpu::Instance::new(instance_desc);
+    let instance = wgpu::Instance::new(&instance_desc);
 
     let adapter = wgpu::util::initialize_adapter_from_env_or_default(&instance, None)
         .await
@@ -14,17 +14,15 @@ pub async fn setup() -> (wgpu::Device, wgpu::Queue) {
     let adapter_info = adapter.get_info();
     println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
 
-    let trace_dir = std::env::var("WGPU_TRACE");
+    let _trace_dir = std::env::var("WGPU_TRACE");
     adapter
-        .request_device(
-            &wgpu::DeviceDescriptor {
-                label: None,
-                required_features: wgpu::Features::default(),
-                required_limits: wgpu::Limits::default(),
-                memory_hints: wgpu::MemoryHints::Performance,
-            },
-            trace_dir.ok().as_ref().map(std::path::Path::new),
-        )
+        .request_device(&wgpu::DeviceDescriptor {
+            label: None,
+            required_features: wgpu::Features::default(),
+            required_limits: wgpu::Limits::default(),
+            memory_hints: wgpu::MemoryHints::Performance,
+            trace: wgpu::Trace::Off,
+        })
         .await
         .expect("Unable to find a suitable GPU adapter!")
 }
@@ -49,7 +47,7 @@ pub async fn create_png(
     // Poll the device in a blocking manner so that our future resolves.
     // In an actual application, `device.poll(...)` should
     // be called in an event loop or on another thread.
-    device.poll(wgpu::Maintain::Wait);
+    device.poll(wgpu::PollType::Wait);
     // If a file system is available, write the buffer as a PNG
     let has_file_system_available = cfg!(not(target_arch = "wasm32"));
     if !has_file_system_available {
@@ -112,9 +110,9 @@ fn get_texture_data(
         // Copy the data from the texture to the buffer
         encoder.copy_texture_to_buffer(
             texture.as_image_copy(),
-            wgpu::ImageCopyBuffer {
+            wgpu::TexelCopyBufferInfo {
                 buffer: &output_buffer,
-                layout: wgpu::ImageDataLayout {
+                layout: wgpu::TexelCopyBufferLayout {
                     offset: 0,
                     bytes_per_row: Some(texture_extent.width * bytes_per_pixel),
                     rows_per_image: None,
@@ -128,7 +126,7 @@ fn get_texture_data(
 
     queue.submit(Some(command_buffer));
 
-    device.poll(wgpu::Maintain::Wait);
+    device.poll(wgpu::PollType::Wait);
 
     output_buffer
 }
@@ -141,7 +139,7 @@ pub fn render_test(
     capture: bool,
 ) {
     if capture {
-        device.start_capture();
+        unsafe { device.start_graphics_debugger_capture() }
     }
 
     let texture_size = wgpu::Extent3d {
@@ -174,6 +172,7 @@ pub fn render_test(
                 load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                 store: wgpu::StoreOp::Store,
             },
+            depth_slice: None,
         })],
         depth_stencil_attachment: None,
         occlusion_query_set: None,
@@ -185,7 +184,7 @@ pub fn render_test(
     let output_buffer = get_texture_data(&texture_desc, device, queue, &render_texture);
 
     if capture {
-        device.stop_capture();
+        unsafe { device.stop_graphics_debugger_capture() }
     }
 
     block_on(create_png(name, device, output_buffer, &texture_desc));