wgpu 27: update example-runner-wgpu

Firestar99 · Firestar99 · commit 1f662d72f651 · 2025-12-19T12:18:29.000+01:00
diff --git a/examples/runners/wgpu/src/compute.rs b/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)) =
diff --git a/examples/runners/wgpu/src/graphics.rs b/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,
diff --git a/examples/runners/wgpu/src/lib.rs b/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 {
