Initial precompiled shaders implementation

CHANGELOG.md

@@ -53,6 +53,9 @@ We have merged the acceleration structure feature into the `RayQuery` feature. T
 
 By @Vecvec in [#7913](https://github.com/gfx-rs/wgpu/pull/7913).
 
+### General
+- 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)
+
 ### Changes
 
 #### 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/src/lib.rs

@@ -315,6 +315,90 @@ impl GlobalPlay for wgc::global::Global {
                     println!("shader compilation error:\n---{code}\n---\n{e}");
                 }
             }
+            Action::CreateShaderModulePassthrough {
+                id,
+                data,
+                entry_point,
+                label,
+                num_workgroups,
+                reflection,
+                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);
+                        // Mom: we have bytemuck at home
+                        let vec: Vec<u32> = data
+                            .chunks_exact(4)
+                            .map(|chunk| u32::from_ne_bytes(chunk.try_into().unwrap()))
+                            .collect();
+                        Some(Cow::Owned(vec))
+                    } 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,
+                    reflection,
+                    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,28 @@ 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,
+                    reflection: desc.reflection.clone(),
+                    runtime_checks: desc.runtime_checks,
                 });
             };
 
@@ -1138,7 +1130,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))
     }
 

wgpu-core/src/device/resource.rs

@@ -2125,39 +2125,59 @@ impl Device {
         descriptor: &pipeline::ShaderModuleDescriptorPassthrough<'a>,
     ) -> Result<Arc<pipeline::ShaderModule>, pipeline::CreateShaderModuleError> {
         self.check_is_valid()?;
-        let hal_shader = match descriptor {
-            pipeline::ShaderModuleDescriptorPassthrough::SpirV(inner) => {
-                self.require_features(wgt::Features::SPIRV_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::SpirV(&inner.source)
-            }
-            pipeline::ShaderModuleDescriptorPassthrough::Msl(inner) => {
-                self.require_features(wgt::Features::MSL_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::Msl {
-                    shader: inner.source.to_string(),
-                    entry_point: inner.entry_point.to_string(),
-                    num_workgroups: inner.num_workgroups,
-                }
-            }
-            pipeline::ShaderModuleDescriptorPassthrough::Dxil(inner) => {
-                self.require_features(wgt::Features::HLSL_DXIL_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::Dxil {
-                    shader: inner.source,
-                    entry_point: inner.entry_point.clone(),
-                    num_workgroups: inner.num_workgroups,
+        self.require_features(wgt::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)?;
+
+        // TODO: when we get to use if-let chains, this will be a little nicer!
+
+        log::info!("Backend: {}", self.backend());
+        let hal_shader = match self.backend() {
+            wgt::Backend::Vulkan => hal::ShaderInput::SpirV(
+                descriptor
+                    .spirv
+                    .as_ref()
+                    .ok_or(pipeline::CreateShaderModuleError::NotCompiledForBackend)?,
+            ),
+            wgt::Backend::Dx12 => {
+                if let Some(dxil) = &descriptor.dxil {
+                    hal::ShaderInput::Dxil {
+                        shader: dxil,
+                        entry_point: descriptor.entry_point.clone(),
+                        num_workgroups: descriptor.num_workgroups,
+                    }
+                } else if let Some(hlsl) = &descriptor.hlsl {
+                    hal::ShaderInput::Hlsl {
+                        shader: hlsl,
+                        entry_point: descriptor.entry_point.clone(),
+                        num_workgroups: descriptor.num_workgroups,
+                    }
+                } else {
+                    return Err(pipeline::CreateShaderModuleError::NotCompiledForBackend);
                 }
             }
-            pipeline::ShaderModuleDescriptorPassthrough::Hlsl(inner) => {
-                self.require_features(wgt::Features::HLSL_DXIL_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::Hlsl {
-                    shader: inner.source,
-                    entry_point: inner.entry_point.clone(),
-                    num_workgroups: inner.num_workgroups,
-                }
+            wgt::Backend::Metal => hal::ShaderInput::Msl {
+                shader: descriptor
+                    .msl
+                    .as_ref()
+                    .ok_or(pipeline::CreateShaderModuleError::NotCompiledForBackend)?,
+                entry_point: descriptor.entry_point.clone(),
+                num_workgroups: descriptor.num_workgroups,
+            },
+            wgt::Backend::Gl => hal::ShaderInput::Glsl {
+                shader: descriptor
+                    .glsl
+                    .as_ref()
+                    .ok_or(pipeline::CreateShaderModuleError::NotCompiledForBackend)?,
+                entry_point: descriptor.entry_point.clone(),
+                num_workgroups: descriptor.num_workgroups,
+            },
+            wgt::Backend::Noop => {
+                return Err(pipeline::CreateShaderModuleError::NotCompiledForBackend)
             }
+            wgt::Backend::BrowserWebGpu => unreachable!(),
         };
 
         let hal_desc = hal::ShaderModuleDescriptor {
-            label: descriptor.label().to_hal(self.instance_flags),
+            label: descriptor.label.to_hal(self.instance_flags),
             runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
         };
 
@@ -2180,7 +2200,7 @@ impl Device {
             raw: ManuallyDrop::new(raw),
             device: self.clone(),
             interface: None,
-            label: descriptor.label().to_string(),
+            label: descriptor.label.to_string(),
         };
 
         Ok(Arc::new(module))

wgpu-core/src/device/trace.rs

@@ -93,6 +93,16 @@ pub enum Action<'a> {
         desc: crate::pipeline::ShaderModuleDescriptor<'a>,
         data: FileName,
     },
+    CreateShaderModulePassthrough {
+        id: id::ShaderModuleId,
+        data: Vec<FileName>,
+
+        entry_point: String,
+        label: crate::Label<'a>,
+        num_workgroups: (u32, u32, u32),
+        reflection: Option<wgt::ShaderModuleReflection>,
+        runtime_checks: wgt::ShaderRuntimeChecks,
+    },
     DestroyShaderModule(id::ShaderModuleId),
     CreateComputePipeline {
         id: id::ComputePipelineId,