Precompiled shaders macro

CHANGELOG.md

@@ -109,14 +109,30 @@ Difference for SPIR-V passthrough:
 -     },
 - ))
 + device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
-+     entry_point: "main".into(),
 +     label: None,
-+     spirv: Some(spirv_code),
++     spirv: Some(wgpu::SpirvPassthroughDescriptor {
++         code: spirv_code
++     }),
 +     ..Default::default()
 })
 ```
 This allows using precompiled shaders without manually checking which backend's code to pass, for example if you have shaders precompiled for both DXIL and SPIR-V.
 
+This comes along with an optional wgpu feature, `precompiled`, which provides a macro for precompiling shaders. For example, the following code is used in a test to precompile the `vs_main` entry point of `shader.wgsl` for all shader backends, excluding DXIL.
+```rust
+ctx
+    .device
+    .create_shader_module_passthrough(wgpu::include_precompiled_wgsl!(
+        // Shader source file
+        "shader.wgsl",
+        // Shader entry point
+        "vs_main",
+        // Target formats: a space separated list of backends, for example "all" or "hlsl glsl spirv"
+        all
+    ))
+```
+You can also precompile SPIR-V and GLSL, and you can precompile raw shader code (code that lives in the rust file) using `precompile_wgsl` instead of `include_precompiled_wgsl`, and the analogous functions for GLSL.
+
 #### Buffer mapping apis no longer have lifetimes
 
 `Buffer::get_mapped_range()`, `Buffer::get_mapped_range_mut()`, and `Queue::write_buffer_with()` now return guard objects without any lifetimes. This

Cargo.toml

@@ -24,6 +24,7 @@ members = [
     "wgpu-macros",
     "wgpu-types",
     "wgpu",
+    "wgpu-precompile-macro",
     "xtask",
 ]
 exclude = []
@@ -47,6 +48,7 @@ default-members = [
     "wgpu-macros",
     "wgpu-types",
     "wgpu",
+    "wgpu-precompile-macro",
     "xtask",
 ]
 
@@ -80,6 +82,7 @@ wgpu = { version = "26.0.0", path = "./wgpu", default-features = false, features
 wgpu-core = { version = "26.0.0", path = "./wgpu-core" }
 wgpu-hal = { version = "26.0.0", path = "./wgpu-hal" }
 wgpu-macros = { version = "26.0.0", path = "./wgpu-macros" }
+wgpu-precompile-macro = { version = "26.0.0", path = "./wgpu-precompile-macro" }
 wgpu-test = { version = "26.0.0", path = "./tests" }
 wgpu-types = { version = "26.0.0", path = "./wgpu-types", default-features = false }
 
@@ -166,6 +169,7 @@ pollster = "0.4"
 portable-atomic = "1.8"
 portable-atomic-util = "0.2.4"
 pp-rs = "0.2.1"
+proc-macro2 = "1.0.101"
 profiling = { version = "1.0.1", default-features = false }
 quote = "1.0.38"
 raw-window-handle = { version = "0.6.2", default-features = false }

examples/features/Cargo.toml

@@ -56,7 +56,7 @@ wgpu-test.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 env_logger.workspace = true
-wgpu.workspace = true
+wgpu = { workspace = true, features = ["precompile"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_error_panic_hook.workspace = true
@@ -67,6 +67,7 @@ wasm-bindgen-futures.workspace = true
 wgpu = { path = "../../wgpu", default-features = false, features = [
     "wgsl",
     "std",
+    "precompile",
 ] }
 # We need these features in the framework examples and tests
 web-sys = { workspace = true, features = [

examples/features/src/hello_triangle/mod.rs

@@ -1,4 +1,3 @@
-use std::borrow::Cow;
 use winit::{
     event::{Event, WindowEvent},
     event_loop::EventLoop,
@@ -27,23 +26,17 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
     let (device, queue) = adapter
         .request_device(&wgpu::DeviceDescriptor {
             label: None,
-            required_features: wgpu::Features::empty(),
+            required_features: wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS,
             // Make sure we use the texture resolution limits from the adapter, so we can support images the size of the swapchain.
             required_limits: wgpu::Limits::downlevel_webgl2_defaults()
                 .using_resolution(adapter.limits()),
-            experimental_features: wgpu::ExperimentalFeatures::disabled(),
+            experimental_features: unsafe { wgpu::ExperimentalFeatures::enabled() },
             memory_hints: wgpu::MemoryHints::MemoryUsage,
             trace: wgpu::Trace::Off,
         })
         .await
         .expect("Failed to create device");
 
-    // Load the shaders from disk
-    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-        label: None,
-        source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
-    });
-
     let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
         label: None,
         bind_group_layouts: &[],
@@ -52,18 +45,32 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
 
     let swapchain_capabilities = surface.get_capabilities(&adapter);
     let swapchain_format = swapchain_capabilities.formats[0];
+    let vs_shader = unsafe {
+        device.create_shader_module_passthrough(wgpu::include_precompiled_wgsl!(
+            "src/hello_triangle/shader.wgsl",
+            "vs_main",
+            all
+        ))
+    };
+    let fs_shader = unsafe {
+        device.create_shader_module_passthrough(wgpu::include_precompiled_wgsl!(
+            "src/hello_triangle/shader.wgsl",
+            "fs_main",
+            all
+        ))
+    };
 
     let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
         label: None,
         layout: Some(&pipeline_layout),
         vertex: wgpu::VertexState {
-            module: &shader,
+            module: &vs_shader,
             entry_point: Some("vs_main"),
             buffers: &[],
             compilation_options: Default::default(),
         },
         fragment: Some(wgpu::FragmentState {
-            module: &shader,
+            module: &fs_shader,
             entry_point: Some("fs_main"),
             compilation_options: Default::default(),
             targets: &[Some(swapchain_format.into())],
@@ -86,7 +93,13 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
             // Have the closure take ownership of the resources.
             // `event_loop.run` never returns, therefore we must do this to ensure
             // the resources are properly cleaned up.
-            let _ = (&instance, &adapter, &shader, &pipeline_layout);
+            let _ = (
+                &instance,
+                &adapter,
+                &vs_shader,
+                &fs_shader,
+                &pipeline_layout,
+            );
 
             if let Event::WindowEvent {
                 window_id: _,

examples/features/src/mesh_shader/mod.rs

@@ -25,9 +25,10 @@ fn compile_glsl(
     assert!(output.status.success());
     unsafe {
         device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
-            entry_point: "main".into(),
             label: None,
-            spirv: Some(wgpu::util::make_spirv_raw(&output.stdout)),
+            spirv: Some(wgpu::SpirvPassthroughDescriptor {
+                code: wgpu::util::make_spirv_raw(&output.stdout),
+            }),
             ..Default::default()
         })
     }

player/src/lib.rs

@@ -316,7 +316,7 @@ impl GlobalPlay for wgc::global::Global {
             Action::CreateShaderModulePassthrough {
                 id,
                 data,
-                entry_point,
+                entry_points,
                 label,
                 num_workgroups,
                 runtime_checks,
@@ -326,53 +326,69 @@ impl GlobalPlay for wgc::global::Global {
                         let data = fs::read(dir.join(a)).unwrap();
                         assert!(data.len() % 4 == 0);
 
-                        Some(Cow::Owned(bytemuck::pod_collect_to_vec(&data)))
+                        Some(wgt::SpirvPassthroughDescriptor {
+                            code: Cow::Owned(bytemuck::pod_collect_to_vec(&data)),
+                        })
                     } else {
                         None
                     }
                 });
-                let dxil = data.iter().find_map(|a| {
+                let dxil = data.iter().zip(&entry_points).find_map(|(a, entry_point)| {
                     if a.ends_with(".dxil") {
                         let vec = std::fs::read(dir.join(a)).unwrap();
-                        Some(Cow::Owned(vec))
+                        Some(wgt::DxilPassthroughDescriptor {
+                            code: Cow::Owned(vec),
+                            entry_point: entry_point.to_owned(),
+                        })
                     } else {
                         None
                     }
                 });
-                let hlsl = data.iter().find_map(|a| {
+                let hlsl = data.iter().zip(&entry_points).find_map(|(a, entry_point)| {
                     if a.ends_with(".hlsl") {
                         let code = fs::read_to_string(dir.join(a)).unwrap();
-                        Some(Cow::Owned(code))
+
+                        Some(wgt::HlslPassthroughDescriptor {
+                            code: Cow::Owned(code),
+                            entry_point: entry_point.to_owned(),
+                        })
                     } else {
                         None
                     }
                 });
-                let msl = data.iter().find_map(|a| {
+                let msl = data.iter().zip(&entry_points).find_map(|(a, entry_point)| {
                     if a.ends_with(".msl") {
                         let code = fs::read_to_string(dir.join(a)).unwrap();
-                        Some(Cow::Owned(code))
+                        Some(wgt::MslPassthroughDescriptor {
+                            code: Cow::Owned(code),
+                            entry_point: entry_point.to_owned(),
+                        })
                     } else {
                         None
                     }
                 });
                 let glsl = data.iter().find_map(|a| {
                     if a.ends_with(".glsl") {
                         let code = fs::read_to_string(dir.join(a)).unwrap();
-                        Some(Cow::Owned(code))
+                        Some(wgt::GlslPassthroughDescriptor {
+                            code: Cow::Owned(code),
+                        })
                     } else {
                         None
                     }
                 });
-                let wgsl = data.iter().find_map(|a| {
+                let wgsl = data.iter().zip(&entry_points).find_map(|(a, entry_point)| {
                     if a.ends_with(".wgsl") {
                         let code = fs::read_to_string(dir.join(a)).unwrap();
-                        Some(Cow::Owned(code))
+                        Some(wgt::WgslPassthroughDescriptor {
+                            code: Cow::Owned(code),
+                            entry_point: entry_point.to_owned(),
+                        })
                     } else {
                         None
                     }
                 });
                 let desc = wgt::CreateShaderModuleDescriptorPassthrough {
-                    entry_point,
                     label,
                     num_workgroups,
                     runtime_checks,

tests/Cargo.toml

@@ -34,7 +34,7 @@ webgl = ["wgpu/webgl"]
 test-build-with-profiling = ["profiling/type-check"]
 
 [dependencies]
-wgpu = { workspace = true, features = ["noop"] }
+wgpu = { workspace = true, features = ["noop", "precompile"] }
 wgpu-hal = { workspace = true, features = ["validation_canary"] }
 wgpu-macros.workspace = true