Initial precompiled shaders implementation

CHANGELOG.md

@@ -53,6 +53,27 @@ We have merged the acceleration structure feature into the `RayQuery` feature. T
 
 By @Vecvec in [#7913](https://github.com/gfx-rs/wgpu/pull/7913).
 
+#### New `EXPERIMENTAL_PRECOMPILED_SHADERS` API
+We have added `Features::EXPERIMENTAL_PRECOMPILED_SHADERS`, replacing existing passthrough types with a unified `CreateShaderModuleDescriptorPassthrough` which allows passing multiple shader codes for different backends. By @SupaMaggie70Incorporated in [#7834](https://github.com/gfx-rs/wgpu/pull/7834)
+
+Difference for SPIR-V passthrough:
+```diff
+- device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough::SpirV(
+-     wgpu::ShaderModuleDescriptorSpirV {
+-         label: None,
+-         source: spirv_code,
+-     },
+- ))
++ device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
++     entry_point: "main".into(),
++     label: None,
++     spirv: Some(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.
+
+
 ### New Features
 
 #### General

deno_webgpu/webidl.rs

@@ -419,10 +419,6 @@ pub enum GPUFeatureName {
     VertexWritableStorage,
     #[webidl(rename = "clear-texture")]
     ClearTexture,
-    #[webidl(rename = "msl-shader-passthrough")]
-    MslShaderPassthrough,
-    #[webidl(rename = "spirv-shader-passthrough")]
-    SpirvShaderPassthrough,
     #[webidl(rename = "multiview")]
     Multiview,
     #[webidl(rename = "vertex-attribute-64-bit")]
@@ -435,6 +431,8 @@ pub enum GPUFeatureName {
     ShaderPrimitiveIndex,
     #[webidl(rename = "shader-early-depth-test")]
     ShaderEarlyDepthTest,
+    #[webidl(rename = "passthrough-shaders")]
+    PassthroughShaders,
 }
 
 pub fn feature_names_to_features(names: Vec<GPUFeatureName>) -> wgpu_types::Features {
@@ -482,14 +480,13 @@ pub fn feature_names_to_features(names: Vec<GPUFeatureName>) -> wgpu_types::Feat
       GPUFeatureName::ConservativeRasterization => Features::CONSERVATIVE_RASTERIZATION,
       GPUFeatureName::VertexWritableStorage => Features::VERTEX_WRITABLE_STORAGE,
       GPUFeatureName::ClearTexture => Features::CLEAR_TEXTURE,
-      GPUFeatureName::MslShaderPassthrough => Features::MSL_SHADER_PASSTHROUGH,
-      GPUFeatureName::SpirvShaderPassthrough => Features::SPIRV_SHADER_PASSTHROUGH,
       GPUFeatureName::Multiview => Features::MULTIVIEW,
       GPUFeatureName::VertexAttribute64Bit => Features::VERTEX_ATTRIBUTE_64BIT,
       GPUFeatureName::ShaderF64 => Features::SHADER_F64,
       GPUFeatureName::ShaderI16 => Features::SHADER_I16,
       GPUFeatureName::ShaderPrimitiveIndex => Features::SHADER_PRIMITIVE_INDEX,
       GPUFeatureName::ShaderEarlyDepthTest => Features::SHADER_EARLY_DEPTH_TEST,
+      GPUFeatureName::PassthroughShaders => Features::EXPERIMENTAL_PASSTHROUGH_SHADERS,
     };
         features.set(feature, true);
     }
@@ -626,9 +623,6 @@ pub fn features_to_feature_names(features: wgpu_types::Features) -> HashSet<GPUF
     if features.contains(wgpu_types::Features::CLEAR_TEXTURE) {
         return_features.insert(ClearTexture);
     }
-    if features.contains(wgpu_types::Features::SPIRV_SHADER_PASSTHROUGH) {
-        return_features.insert(SpirvShaderPassthrough);
-    }
     if features.contains(wgpu_types::Features::MULTIVIEW) {
         return_features.insert(Multiview);
     }
@@ -648,6 +642,9 @@ pub fn features_to_feature_names(features: wgpu_types::Features) -> HashSet<GPUF
     if features.contains(wgpu_types::Features::SHADER_EARLY_DEPTH_TEST) {
         return_features.insert(ShaderEarlyDepthTest);
     }
+    if features.contains(wgpu_types::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS) {
+        return_features.insert(PassthroughShaders);
+    }
 
     return_features
 }

examples/features/src/mesh_shader/mod.rs

@@ -24,12 +24,12 @@ fn compile_glsl(
     let output = cmd.wait_with_output().expect("Error waiting for glslc");
     assert!(output.status.success());
     unsafe {
-        device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough::SpirV(
-            wgpu::ShaderModuleDescriptorSpirV {
-                label: None,
-                source: wgpu::util::make_spirv_raw(&output.stdout),
-            },
-        ))
+        device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
+            entry_point: "main".into(),
+            label: None,
+            spirv: Some(wgpu::util::make_spirv_raw(&output.stdout)),
+            ..Default::default()
+        })
     }
 }
 
@@ -119,7 +119,7 @@ impl crate::framework::Example for Example {
         Default::default()
     }
     fn required_features() -> wgpu::Features {
-        wgpu::Features::EXPERIMENTAL_MESH_SHADER | wgpu::Features::SPIRV_SHADER_PASSTHROUGH
+        wgpu::Features::EXPERIMENTAL_MESH_SHADER | wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS
     }
     fn required_limits() -> wgpu::Limits {
         wgpu::Limits::defaults().using_recommended_minimum_mesh_shader_values()

player/Cargo.toml

@@ -26,6 +26,7 @@ log.workspace = true
 raw-window-handle.workspace = true
 ron.workspace = true
 winit = { workspace = true, optional = true }
+bytemuck.workspace = true
 
 # Non-Webassembly
 #

player/src/lib.rs

@@ -315,6 +315,84 @@ impl GlobalPlay for wgc::global::Global {
                     println!("shader compilation error:\n---{code}\n---\n{e}");
                 }
             }
+            Action::CreateShaderModulePassthrough {
+                id,
+                data,
+                entry_point,
+                label,
+                num_workgroups,
+                runtime_checks,
+            } => {
+                let spirv = data.iter().find_map(|a| {
+                    if a.ends_with(".spv") {
+                        let data = fs::read(dir.join(a)).unwrap();
+                        assert!(data.len() % 4 == 0);
+
+                        Some(Cow::Owned(bytemuck::pod_collect_to_vec(&data)))
+                    } else {
+                        None
+                    }
+                });
+                let dxil = data.iter().find_map(|a| {
+                    if a.ends_with(".dxil") {
+                        let vec = std::fs::read(dir.join(a)).unwrap();
+                        Some(Cow::Owned(vec))
+                    } else {
+                        None
+                    }
+                });
+                let hlsl = data.iter().find_map(|a| {
+                    if a.ends_with(".hlsl") {
+                        let code = fs::read_to_string(dir.join(a)).unwrap();
+                        Some(Cow::Owned(code))
+                    } else {
+                        None
+                    }
+                });
+                let msl = data.iter().find_map(|a| {
+                    if a.ends_with(".msl") {
+                        let code = fs::read_to_string(dir.join(a)).unwrap();
+                        Some(Cow::Owned(code))
+                    } 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))
+                    } else {
+                        None
+                    }
+                });
+                let wgsl = data.iter().find_map(|a| {
+                    if a.ends_with(".wgsl") {
+                        let code = fs::read_to_string(dir.join(a)).unwrap();
+                        Some(Cow::Owned(code))
+                    } else {
+                        None
+                    }
+                });
+                let desc = wgt::CreateShaderModuleDescriptorPassthrough {
+                    entry_point,
+                    label,
+                    num_workgroups,
+                    runtime_checks,
+
+                    spirv,
+                    dxil,
+                    hlsl,
+                    msl,
+                    glsl,
+                    wgsl,
+                };
+                let (_, error) = unsafe {
+                    self.device_create_shader_module_passthrough(device, &desc, Some(id))
+                };
+                if let Some(e) = error {
+                    println!("shader compilation error: {e}");
+                }
+            }
             Action::DestroyShaderModule(id) => {
                 self.shader_module_drop(id);
             }

tests/tests/wgpu-gpu/mesh_shader/mod.rs

@@ -41,12 +41,12 @@ fn compile_glsl(
     let output = cmd.wait_with_output().expect("Error waiting for glslc");
     assert!(output.status.success());
     unsafe {
-        device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough::SpirV(
-            wgpu::ShaderModuleDescriptorSpirV {
-                label: None,
-                source: wgpu::util::make_spirv_raw(&output.stdout),
-            },
-        ))
+        device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
+            entry_point: "main".into(),
+            label: None,
+            spirv: Some(wgpu::util::make_spirv_raw(&output.stdout)),
+            ..Default::default()
+        })
     }
 }
 
@@ -267,7 +267,7 @@ fn default_gpu_test_config(draw_type: DrawType) -> GpuTestConfiguration {
             .test_features_limits()
             .features(
                 wgpu::Features::EXPERIMENTAL_MESH_SHADER
-                    | wgpu::Features::SPIRV_SHADER_PASSTHROUGH
+                    | wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS
                     | match draw_type {
                         DrawType::Standard | DrawType::Indirect => wgpu::Features::empty(),
                         DrawType::MultiIndirect => wgpu::Features::MULTI_DRAW_INDIRECT,

wgpu-core/src/device/global.rs

@@ -1094,36 +1094,27 @@ impl Global {
 
             #[cfg(feature = "trace")]
             if let Some(ref mut trace) = *device.trace.lock() {
-                let data = trace.make_binary(desc.trace_binary_ext(), desc.trace_data());
-                trace.add(trace::Action::CreateShaderModule {
+                let mut file_names = Vec::new();
+                for (data, ext) in [
+                    (desc.spirv.as_ref().map(|a| bytemuck::cast_slice(a)), "spv"),
+                    (desc.dxil.as_deref(), "dxil"),
+                    (desc.hlsl.as_ref().map(|a| a.as_bytes()), "hlsl"),
+                    (desc.msl.as_ref().map(|a| a.as_bytes()), "msl"),
+                    (desc.glsl.as_ref().map(|a| a.as_bytes()), "glsl"),
+                    (desc.wgsl.as_ref().map(|a| a.as_bytes()), "wgsl"),
+                ] {
+                    if let Some(data) = data {
+                        file_names.push(trace.make_binary(ext, data));
+                    }
+                }
+                trace.add(trace::Action::CreateShaderModulePassthrough {
                     id: fid.id(),
-                    desc: match desc {
-                        pipeline::ShaderModuleDescriptorPassthrough::SpirV(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                        pipeline::ShaderModuleDescriptorPassthrough::Msl(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                        pipeline::ShaderModuleDescriptorPassthrough::Dxil(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                        pipeline::ShaderModuleDescriptorPassthrough::Hlsl(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                    },
-                    data,
+                    data: file_names,
+
+                    entry_point: desc.entry_point.clone(),
+                    label: desc.label.clone(),
+                    num_workgroups: desc.num_workgroups,
+                    runtime_checks: desc.runtime_checks,
                 });
             };
 
@@ -1138,7 +1129,7 @@ impl Global {
             return (id, None);
         };
 
-        let id = fid.assign(Fallible::Invalid(Arc::new(desc.label().to_string())));
+        let id = fid.assign(Fallible::Invalid(Arc::new(desc.label.to_string())));
         (id, Some(error))
     }