Add metallib passthrough (#8886)

Author: inner-daemons

CHANGELOG.md

@@ -60,6 +60,7 @@ Bottom level categories:
         - `front::wgsl::Frontend::set_options`
         - `ir::Block::is_empty`
         - `ir::Block::len`
+- Changed passthrough shaders to not require an entry point parameter, so that the same shader module may be used in multiple entry points. Also added support for metallib passthrough. By @inner-daemons in #8886.
 
 #### naga
 

Cargo.lock

@@ -203,6 +203,7 @@ xshell = "0.2.2"
 
 # Metal dependencies
 block2 = "0.6.2"
+dispatch2 = "0.3.0"
 objc2 = "0.6.3"
 objc2-core-foundation = { version = "0.3.2", default-features = false, features = [
     "std",
@@ -218,6 +219,7 @@ objc2-foundation = { version = "0.3.2", default-features = false, features = [
 objc2-metal = { version = "0.3.2", default-features = false, features = [
     "std",
     "block2",
+    "dispatch2",
     "MTLAllocation",
     "MTLBlitCommandEncoder",
     "MTLBlitPass",

Cargo.toml

@@ -29,7 +29,6 @@ fn compile_hlsl(device: &wgpu::Device, entry: &str, stage_str: &str) -> wgpu::Sh
     std::fs::remove_file(out_path).unwrap();
     unsafe {
         device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
-            entry_point: entry.to_owned(),
             label: None,
             num_workgroups: (1, 1, 1),
             dxil: Some(std::borrow::Cow::Owned(file)),
@@ -38,10 +37,9 @@ fn compile_hlsl(device: &wgpu::Device, entry: &str, stage_str: &str) -> wgpu::Sh
     }
 }
 
-fn compile_msl(device: &wgpu::Device, entry: &str) -> wgpu::ShaderModule {
+fn compile_msl(device: &wgpu::Device) -> wgpu::ShaderModule {
     unsafe {
         device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
-            entry_point: entry.to_owned(),
             label: None,
             msl: Some(std::borrow::Cow::Borrowed(include_str!("shader.metal"))),
             num_workgroups: (1, 1, 1),
@@ -50,6 +48,53 @@ fn compile_msl(device: &wgpu::Device, entry: &str) -> wgpu::ShaderModule {
     }
 }
 
+struct Shaders {
+    ts: wgpu::ShaderModule,
+    ms: wgpu::ShaderModule,
+    fs: wgpu::ShaderModule,
+    ts_name: &'static str,
+    ms_name: &'static str,
+    fs_name: &'static str,
+}
+
+fn get_shaders(device: &wgpu::Device, backend: wgpu::Backend) -> Shaders {
+    // In the case that the platform does support mesh shaders, the dummy
+    // shader is used to avoid requiring EXPERIMENTAL_PASSTHROUGH_SHADERS.
+    match backend {
+        wgpu::Backend::Vulkan => {
+            let compiled = compile_wgsl(device);
+            Shaders {
+                ts: compiled.clone(),
+                ms: compiled.clone(),
+                fs: compiled.clone(),
+                ts_name: "ts_main",
+                ms_name: "ms_main",
+                fs_name: "fs_main",
+            }
+        }
+        wgpu::Backend::Dx12 => Shaders {
+            ts: compile_hlsl(device, "Task", "as"),
+            ms: compile_hlsl(device, "Mesh", "ms"),
+            fs: compile_hlsl(device, "Frag", "ps"),
+            ts_name: "main",
+            ms_name: "main",
+            fs_name: "main",
+        },
+        wgpu::Backend::Metal => {
+            let compiled = compile_msl(device);
+            Shaders {
+                ts: compiled.clone(),
+                ms: compiled.clone(),
+                fs: compiled.clone(),
+                ts_name: "taskShader",
+                ms_name: "meshShader",
+                fs_name: "fragShader",
+            }
+        }
+        _ => unreachable!(),
+    }
+}
+
 pub struct Example {
     pipeline: wgpu::RenderPipeline,
 }
@@ -60,33 +105,14 @@ impl crate::framework::Example for Example {
         device: &wgpu::Device,
         _queue: &wgpu::Queue,
     ) -> Self {
-        let (ts, ms, fs, ts_name, ms_name, fs_name) = match adapter.get_info().backend {
-            wgpu::Backend::Vulkan => (
-                compile_wgsl(device),
-                compile_wgsl(device),
-                compile_wgsl(device),
-                "ts_main",
-                "ms_main",
-                "fs_main",
-            ),
-            wgpu::Backend::Dx12 => (
-                compile_hlsl(device, "Task", "as"),
-                compile_hlsl(device, "Mesh", "ms"),
-                compile_hlsl(device, "Frag", "ps"),
-                "main",
-                "main",
-                "main",
-            ),
-            wgpu::Backend::Metal => (
-                compile_msl(device, "taskShader"),
-                compile_msl(device, "meshShader"),
-                compile_msl(device, "fragShader"),
-                "main",
-                "main",
-                "main",
-            ),
-            _ => panic!("Example can currently only run on vulkan, dx12 or metal"),
-        };
+        let Shaders {
+            ts,
+            ms,
+            fs,
+            ts_name,
+            ms_name,
+            fs_name,
+        } = get_shaders(device, adapter.get_info().backend);
         let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
             label: None,
             bind_group_layouts: &[],

examples/features/src/mesh_shader/mod.rs

@@ -268,10 +268,8 @@ impl Player {
             Action::CreateShaderModulePassthrough {
                 id,
                 data,
-                entry_point,
                 label,
                 num_workgroups,
-                runtime_checks,
             } => {
                 let spirv = data.iter().find_map(|a| {
                     if a.kind() == DataKind::Spv {
@@ -289,6 +287,9 @@ impl Player {
                 let hlsl = data
                     .iter()
                     .find_map(|a| (a.kind() == DataKind::Hlsl).then(|| loader.load_utf8(a)));
+                let metallib = data
+                    .iter()
+                    .find_map(|a| (a.kind() == DataKind::MetalLib).then(|| loader.load(a)));
                 let msl = data
                     .iter()
                     .find_map(|a| (a.kind() == DataKind::Msl).then(|| loader.load_utf8(a)));
@@ -299,14 +300,13 @@ impl Player {
                     .iter()
                     .find_map(|a| (a.kind() == DataKind::Wgsl).then(|| loader.load_utf8(a)));
                 let desc = wgt::CreateShaderModuleDescriptorPassthrough {
-                    entry_point,
                     label,
                     num_workgroups,
-                    runtime_checks,
 
                     spirv,
                     dxil,
                     hlsl,
+                    metallib,
                     msl,
                     glsl,
                     wgsl,

player/src/lib.rs

@@ -42,6 +42,7 @@ mod occlusion_query;
 mod oob_indexing;
 mod oom;
 mod pass_ops;
+mod passthrough;
 mod per_vertex;
 mod pipeline;
 mod pipeline_cache;
@@ -107,6 +108,7 @@ fn all_tests() -> Vec<wgpu_test::GpuTestInitializer> {
     oob_indexing::all_tests(&mut tests);
     oom::all_tests(&mut tests);
     pass_ops::all_tests(&mut tests);
+    passthrough::all_tests(&mut tests);
     per_vertex::all_tests(&mut tests);
     pipeline_cache::all_tests(&mut tests);
     pipeline::all_tests(&mut tests);