wgpu 27

examples/runners/wgpu/Cargo.toml

@@ -22,7 +22,7 @@ cfg-if = "1.0.0"
 shared = { path = "../../shaders/shared" }
 futures = { version = "0.3", default-features = false, features = ["std", "executor"] }
 # Vulkan SDK or MoltenVK needs to be installed for `vulkan-portability` to work on macOS
-wgpu = { version = "26.0.1", features = ["spirv", "vulkan-portability"] }
+wgpu = { version = "27.0.1", features = ["spirv", "vulkan-portability"] }
 winit = { version = "0.30.0", features = ["android-native-activity", "rwh_05"] }
 clap = { version = "4", features = ["derive"] }
 strum = { version = "0.27.2", default-features = false, features = ["std", "derive"] }

examples/runners/wgpu/src/compute.rs

@@ -9,9 +9,11 @@
 //! The individual Collatz sequence lengths are computed via a computer shader on the GPU.
 
 use crate::{CompiledShaderModules, Options, maybe_watch};
+use std::borrow::Cow;
 
 use std::time::Duration;
 use wgpu::util::DeviceExt;
+use wgpu::{ExperimentalFeatures, ShaderSource};
 
 pub fn start(options: &Options) {
     env_logger::init();
@@ -48,14 +50,19 @@ async fn start_internal(options: &Options, compiled_shader_modules: CompiledShad
         );
     }
     if options.force_spirv_passthru {
-        required_features |= wgpu::Features::SPIRV_SHADER_PASSTHROUGH;
+        required_features |= wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS;
     }
 
     let (device, queue) = adapter
         .request_device(&wgpu::DeviceDescriptor {
             label: None,
             required_features,
             required_limits: wgpu::Limits::default(),
+            experimental_features: if options.force_spirv_passthru {
+                unsafe { ExperimentalFeatures::enabled() }
+            } else {
+                ExperimentalFeatures::disabled()
+            },
             memory_hints: wgpu::MemoryHints::Performance,
             trace: Default::default(),
         })
@@ -75,16 +82,18 @@ async fn start_internal(options: &Options, compiled_shader_modules: CompiledShad
     let module = compiled_shader_modules.spv_module_for_entry_point(entry_point);
     let module = if options.force_spirv_passthru {
         unsafe {
-            device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough::SpirV(
-                module,
-            ))
+            let spirv = match &module.source {
+                ShaderSource::SpirV(spirv) => spirv,
+                _ => unreachable!(),
+            };
+            device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
+                label: module.label,
+                spirv: Some(Cow::Borrowed(spirv)),
+                ..Default::default()
+            })
         }
     } else {
-        let wgpu::ShaderModuleDescriptorSpirV { label, source } = module;
-        device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label,
-            source: wgpu::ShaderSource::SpirV(source),
-        })
+        device.create_shader_module(module)
     };
 
     let top = 2u32.pow(20);
@@ -230,7 +239,7 @@ async fn start_internal(options: &Options, compiled_shader_modules: CompiledShad
     buffer_slice.map_async(wgpu::MapMode::Read, |r| r.unwrap());
     // NOTE(eddyb) `poll` should return only after the above callbacks fire
     // (see also https://github.com/gfx-rs/wgpu/pull/2698 for more details).
-    device.poll(wgpu::PollType::Wait).unwrap();
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
 
     if timestamping
         && let (Some(timestamp_readback_buffer), Some(timestamp_period)) =

examples/runners/wgpu/src/graphics.rs

@@ -1,5 +1,6 @@
 use crate::{CompiledShaderModules, Options, maybe_watch};
-use wgpu::ShaderModuleDescriptorPassthrough;
+use std::borrow::Cow;
+use wgpu::{ExperimentalFeatures, ShaderModuleDescriptor, ShaderSource};
 
 use shared::ShaderConstants;
 use std::slice;
@@ -77,7 +78,7 @@ async fn run(
 
     let mut required_features = wgpu::Features::PUSH_CONSTANTS;
     if options.force_spirv_passthru {
-        required_features |= wgpu::Features::SPIRV_SHADER_PASSTHROUGH;
+        required_features |= wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS;
     }
     let required_limits = wgpu::Limits {
         max_push_constant_size: 128,
@@ -90,6 +91,11 @@ async fn run(
             label: None,
             required_features,
             required_limits,
+            experimental_features: if options.force_spirv_passthru {
+                unsafe { ExperimentalFeatures::enabled() }
+            } else {
+                ExperimentalFeatures::disabled()
+            },
             memory_hints: wgpu::MemoryHints::Performance,
             trace: Default::default(),
         })
@@ -438,8 +444,12 @@ fn create_pipeline(
     if options.emulate_push_constants_with_storage_buffer {
         let (ds, b) = (0, 0);
 
-        for (_, shader_module_descr) in &mut compiled_shader_modules.named_spv_modules {
-            let w = shader_module_descr.source.to_mut();
+        for (_, module) in &mut compiled_shader_modules.named_spv_modules {
+            let spirv = match &mut module.source {
+                ShaderSource::SpirV(spirv) => spirv,
+                _ => unreachable!(),
+            };
+            let w = spirv.to_mut();
             assert_eq!((w[0], w[4]), (0x07230203, 0));
             let mut last_op_decorate_start = None;
             let mut i = 5;
@@ -467,39 +477,30 @@ fn create_pipeline(
     }
 
     // FIXME(eddyb) automate this decision by default.
-    let create_module = |module| {
+    let create_module = |module: ShaderModuleDescriptor<'_>| {
         if options.force_spirv_passthru {
             unsafe {
-                device.create_shader_module_passthrough(ShaderModuleDescriptorPassthrough::SpirV(
-                    module,
-                ))
+                let spirv = match &module.source {
+                    ShaderSource::SpirV(spirv) => spirv,
+                    _ => unreachable!(),
+                };
+                device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
+                    label: module.label,
+                    spirv: Some(Cow::Borrowed(spirv)),
+                    ..Default::default()
+                })
             }
         } else {
-            let wgpu::ShaderModuleDescriptorSpirV { label, source } = module;
-            device.create_shader_module(wgpu::ShaderModuleDescriptor {
-                label,
-                source: wgpu::ShaderSource::SpirV(source),
-            })
+            device.create_shader_module(module)
         }
     };
 
     let vs_entry_point = shaders::main_vs;
     let fs_entry_point = shaders::main_fs;
-
     let vs_module_descr = compiled_shader_modules.spv_module_for_entry_point(vs_entry_point);
     let fs_module_descr = compiled_shader_modules.spv_module_for_entry_point(fs_entry_point);
-
-    // HACK(eddyb) avoid calling `device.create_shader_module` twice unnecessarily.
-    let vs_fs_same_module = std::ptr::eq(&vs_module_descr.source[..], &fs_module_descr.source[..]);
-
     let vs_module = &create_module(vs_module_descr);
-    let fs_module;
-    let fs_module = if vs_fs_same_module {
-        vs_module
-    } else {
-        fs_module = create_module(fs_module_descr);
-        &fs_module
-    };
+    let fs_module = &create_module(fs_module_descr);
 
     device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
         cache: None,

examples/runners/wgpu/src/lib.rs

@@ -74,6 +74,7 @@ use clap::Parser;
 use clap::ValueEnum;
 use std::borrow::Cow;
 use strum::{Display, EnumString};
+use wgpu::ShaderSource;
 
 // NOTE(eddyb) while this could theoretically work on the web, it needs more work.
 #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
@@ -90,19 +91,23 @@ pub enum RustGPUShader {
 }
 
 struct CompiledShaderModules {
-    named_spv_modules: Vec<(Option<String>, wgpu::ShaderModuleDescriptorSpirV<'static>)>,
+    named_spv_modules: Vec<(Option<String>, wgpu::ShaderModuleDescriptor<'static>)>,
 }
 
 impl CompiledShaderModules {
     fn spv_module_for_entry_point<'a>(
         &'a self,
         wanted_entry: &str,
-    ) -> wgpu::ShaderModuleDescriptorSpirV<'a> {
+    ) -> wgpu::ShaderModuleDescriptor<'a> {
         for (name, spv_module) in &self.named_spv_modules {
             if name.as_ref().is_none_or(|name| name == wanted_entry) {
-                return wgpu::ShaderModuleDescriptorSpirV {
+                let spirv = match &spv_module.source {
+                    ShaderSource::SpirV(spirv) => spirv,
+                    _ => unreachable!(),
+                };
+                return wgpu::ShaderModuleDescriptor {
                     label: name.as_deref(),
-                    source: Cow::Borrowed(&spv_module.source),
+                    source: ShaderSource::SpirV(Cow::Borrowed(spirv)),
                 };
             }
         }
@@ -158,9 +163,9 @@ fn maybe_watch(
                 // FIXME(eddyb) this reallocates all the data pointlessly, there is
                 // not a good reason to use `ShaderModuleDescriptorSpirV` specifically.
                 let spirv = Cow::Owned(wgpu::util::make_spirv_raw(&data).into_owned());
-                wgpu::ShaderModuleDescriptorSpirV {
+                wgpu::ShaderModuleDescriptor {
                     label: None,
-                    source: spirv,
+                    source: ShaderSource::SpirV(spirv),
                 }
             };
             CompiledShaderModules {
@@ -205,18 +210,14 @@ fn maybe_watch(
     {
         let module = match options.shader {
             RustGPUShader::Simplest => {
-                wgpu::include_spirv_raw!(env!("simplest_shader.spv"))
+                wgpu::include_spirv!(env!("simplest_shader.spv"))
             }
-            RustGPUShader::Sky => wgpu::include_spirv_raw!(env!("sky_shader.spv")),
-            RustGPUShader::Compute => wgpu::include_spirv_raw!(env!("compute_shader.spv")),
-            RustGPUShader::Mouse => wgpu::include_spirv_raw!(env!("mouse_shader.spv")),
-        };
-        let spirv = match module {
-            wgpu::ShaderModuleDescriptorPassthrough::SpirV(spirv) => spirv,
-            _ => panic!("not spirv"),
+            RustGPUShader::Sky => wgpu::include_spirv!(env!("sky_shader.spv")),
+            RustGPUShader::Compute => wgpu::include_spirv!(env!("compute_shader.spv")),
+            RustGPUShader::Mouse => wgpu::include_spirv!(env!("mouse_shader.spv")),
         };
         CompiledShaderModules {
-            named_spv_modules: vec![(None, spirv)],
+            named_spv_modules: vec![(None, module)],
         }
     }
 }

tests/difftests/lib/Cargo.toml

@@ -20,7 +20,7 @@ use-compiled-tools = [
 spirv-builder.workspace = true
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-wgpu = { version = "26.0.1", default-features = false, features = ["std", "parking_lot", "spirv", "wgsl", "vulkan", "vulkan-portability", "metal"] }
+wgpu = { version = "27.0.1", default-features = false, features = ["std", "parking_lot", "spirv", "wgsl", "vulkan", "vulkan-portability", "metal"] }
 ash = { version = "0.38" }
 tempfile = "3.5"
 futures = "0.3.31"

tests/difftests/lib/src/scaffold/compute/wgpu.rs

@@ -7,7 +7,7 @@ use anyhow::Context;
 use bytemuck::Pod;
 use futures::executor::block_on;
 use std::{borrow::Cow, sync::Arc};
-use wgpu::{PipelineCompilationOptions, util::DeviceExt};
+use wgpu::{ExperimentalFeatures, PipelineCompilationOptions, util::DeviceExt};
 
 pub type BufferConfig = backend::BufferConfig;
 pub type BufferUsage = backend::BufferUsage;
@@ -81,13 +81,14 @@ where
                 .request_device(&wgpu::DeviceDescriptor {
                     label: Some("wgpu Device"),
                     #[cfg(target_os = "linux")]
-                    required_features: wgpu::Features::SPIRV_SHADER_PASSTHROUGH | features,
+                    required_features: wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS | features,
                     #[cfg(not(target_os = "linux"))]
                     required_features: features,
                     required_limits: wgpu::Limits {
                         max_push_constant_size: 128,
                         ..wgpu::Limits::default()
                     },
+                    experimental_features: unsafe { ExperimentalFeatures::enabled() },
                     memory_hints: Default::default(),
                     trace: Default::default(),
                 })
@@ -193,7 +194,7 @@ where
         buffer_slice.map_async(wgpu::MapMode::Read, move |res| {
             let _ = sender.send(res);
         });
-        device.poll(wgpu::PollType::Wait)?;
+        device.poll(wgpu::PollType::wait_indefinitely())?;
         block_on(receiver)
             .context("mapping canceled")?
             .context("mapping failed")?;
@@ -387,7 +388,7 @@ impl ComputeBackend for WgpuBackend {
                 buffer_slice.map_async(wgpu::MapMode::Read, move |res| {
                     let _ = sender.send(res);
                 });
-                self.device.poll(wgpu::PollType::Wait)?;
+                self.device.poll(wgpu::PollType::wait_indefinitely())?;
                 block_on(receiver)
                     .context("mapping canceled")?
                     .context("mapping failed")?;
@@ -543,7 +544,7 @@ where
                 buffer_slice.map_async(wgpu::MapMode::Read, move |res| {
                     let _ = sender.send(res);
                 });
-                device.poll(wgpu::PollType::Wait)?;
+                device.poll(wgpu::PollType::wait_indefinitely())?;
                 block_on(receiver)
                     .context("mapping canceled")?
                     .context("mapping failed")?;
@@ -752,7 +753,7 @@ where
                 buffer_slice.map_async(wgpu::MapMode::Read, move |res| {
                     let _ = sender.send(res);
                 });
-                device.poll(wgpu::PollType::Wait)?;
+                device.poll(wgpu::PollType::wait_indefinitely())?;
                 block_on(receiver)
                     .context("mapping canceled")?
                     .context("mapping failed")?;