mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-19 05:51:03 +01:00
Add metallib passthrough (#8886)
This commit is contained in:
1 parent
1af73121f4
commit
fab57513ec
26 files changed
+891
-154
No files matched your search
@@ -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
|
||||
|
||||
|
||||
Generated
+4
@@ -1178,6 +1178,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec"
|
||||
dependencies = [
|
||||
"bitflags 2.10.0",
|
||||
"block2 0.6.2",
|
||||
"libc",
|
||||
"objc2 0.6.3",
|
||||
]
|
||||
|
||||
@@ -2843,6 +2845,7 @@ checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794"
|
||||
dependencies = [
|
||||
"bitflags 2.10.0",
|
||||
"block2 0.6.2",
|
||||
"dispatch2",
|
||||
"objc2 0.6.3",
|
||||
"objc2-foundation 0.3.2",
|
||||
]
|
||||
@@ -4875,6 +4878,7 @@ dependencies = [
|
||||
"bytemuck",
|
||||
"cfg-if",
|
||||
"cfg_aliases 0.2.1",
|
||||
"dispatch2",
|
||||
"env_logger",
|
||||
"glam",
|
||||
"glow",
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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: &[],
|
||||
|
||||
+4
-4
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -29,6 +29,7 @@ fn compile_wgsl(device: &wgpu::Device) -> wgpu::ShaderModule {
|
||||
source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()),
|
||||
})
|
||||
}
|
||||
|
||||
fn compile_hlsl(
|
||||
device: &wgpu::Device,
|
||||
entry: &str,
|
||||
@@ -62,7 +63,6 @@ fn compile_hlsl(
|
||||
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)),
|
||||
@@ -71,10 +71,9 @@ fn compile_hlsl(
|
||||
}
|
||||
}
|
||||
|
||||
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),
|
||||
@@ -82,70 +81,75 @@ fn compile_msl(device: &wgpu::Device, entry: &str) -> wgpu::ShaderModule {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
struct Shaders {
|
||||
ts: Option<wgpu::ShaderModule>,
|
||||
ms: wgpu::ShaderModule,
|
||||
fs: Option<wgpu::ShaderModule>,
|
||||
ts_name: &'static str,
|
||||
ms_name: &'static str,
|
||||
fs_name: &'static str,
|
||||
}
|
||||
fn get_shaders(
|
||||
device: &wgpu::Device,
|
||||
backend: wgpu::Backend,
|
||||
test_name: &str,
|
||||
info: &MeshPipelineTestInfo,
|
||||
) -> (
|
||||
Option<wgpu::ShaderModule>,
|
||||
wgpu::ShaderModule,
|
||||
Option<wgpu::ShaderModule>,
|
||||
&'static str,
|
||||
&'static str,
|
||||
&'static str,
|
||||
) {
|
||||
) -> Shaders {
|
||||
if info.divergent && info.use_task {
|
||||
unreachable!();
|
||||
}
|
||||
// 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 => (
|
||||
info.use_task.then(|| compile_wgsl(device)),
|
||||
compile_wgsl(device),
|
||||
info.use_frag.then(|| compile_wgsl(device)),
|
||||
"ts_main",
|
||||
if info.divergent {
|
||||
"ms_divergent"
|
||||
} else if info.use_task {
|
||||
"ms_main"
|
||||
} else {
|
||||
"ms_no_ts"
|
||||
},
|
||||
"fs_main",
|
||||
),
|
||||
wgpu::Backend::Dx12 => (
|
||||
info.use_task
|
||||
wgpu::Backend::Vulkan => {
|
||||
let compiled = compile_wgsl(device);
|
||||
Shaders {
|
||||
ts: info.use_task.then_some(compiled.clone()),
|
||||
ms: compiled.clone(),
|
||||
fs: info.use_frag.then_some(compiled),
|
||||
ts_name: "ts_main",
|
||||
ms_name: if info.divergent {
|
||||
"ms_divergent"
|
||||
} else if info.use_task {
|
||||
"ms_main"
|
||||
} else {
|
||||
"ms_no_ts"
|
||||
},
|
||||
fs_name: "fs_main",
|
||||
}
|
||||
}
|
||||
wgpu::Backend::Dx12 => Shaders {
|
||||
ts: info
|
||||
.use_task
|
||||
.then(|| compile_hlsl(device, "Task", "as", test_name)),
|
||||
compile_hlsl(
|
||||
ms: compile_hlsl(
|
||||
device,
|
||||
if info.use_task { "Mesh" } else { "MeshNoTask" },
|
||||
"ms",
|
||||
test_name,
|
||||
),
|
||||
info.use_frag
|
||||
fs: info
|
||||
.use_frag
|
||||
.then(|| compile_hlsl(device, "Frag", "ps", test_name)),
|
||||
"main",
|
||||
"main",
|
||||
"main",
|
||||
),
|
||||
wgpu::Backend::Metal => (
|
||||
info.use_task.then(|| compile_msl(device, "taskShader")),
|
||||
compile_msl(
|
||||
device,
|
||||
if info.use_task {
|
||||
ts_name: "main",
|
||||
ms_name: "main",
|
||||
fs_name: "main",
|
||||
},
|
||||
wgpu::Backend::Metal => {
|
||||
let compiled = compile_msl(device);
|
||||
Shaders {
|
||||
ts: info.use_task.then_some(compiled.clone()),
|
||||
ms: compiled.clone(),
|
||||
fs: info.use_frag.then_some(compiled),
|
||||
ts_name: "taskShader",
|
||||
ms_name: if info.use_task {
|
||||
"meshShader"
|
||||
} else {
|
||||
"meshNoTaskShader"
|
||||
},
|
||||
),
|
||||
info.use_frag.then(|| compile_msl(device, "fragShader")),
|
||||
"main",
|
||||
"main",
|
||||
"main",
|
||||
),
|
||||
fs_name: "fragShader",
|
||||
}
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
@@ -198,8 +202,14 @@ fn mesh_pipeline_build(ctx: &TestingContext, info: MeshPipelineTestInfo) {
|
||||
let (_depth_image, depth_view, depth_state) = create_depth(device);
|
||||
|
||||
let test_hash = hash_testing_context(ctx).to_string();
|
||||
let (task, mesh, frag, ts_name, ms_name, fs_name) =
|
||||
get_shaders(device, backend, &test_hash, &info);
|
||||
let Shaders {
|
||||
ts,
|
||||
ms,
|
||||
fs,
|
||||
ts_name,
|
||||
ms_name,
|
||||
fs_name,
|
||||
} = get_shaders(device, backend, &test_hash, &info);
|
||||
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[],
|
||||
@@ -208,17 +218,17 @@ fn mesh_pipeline_build(ctx: &TestingContext, info: MeshPipelineTestInfo) {
|
||||
let pipeline = device.create_mesh_pipeline(&wgpu::MeshPipelineDescriptor {
|
||||
label: None,
|
||||
layout: Some(&layout),
|
||||
task: task.as_ref().map(|task| wgpu::TaskState {
|
||||
task: ts.as_ref().map(|task| wgpu::TaskState {
|
||||
module: task,
|
||||
entry_point: Some(ts_name),
|
||||
compilation_options: Default::default(),
|
||||
}),
|
||||
mesh: wgpu::MeshState {
|
||||
module: &mesh,
|
||||
module: &ms,
|
||||
entry_point: Some(ms_name),
|
||||
compilation_options: Default::default(),
|
||||
},
|
||||
fragment: frag.as_ref().map(|frag| wgpu::FragmentState {
|
||||
fragment: fs.as_ref().map(|frag| wgpu::FragmentState {
|
||||
module: frag,
|
||||
entry_point: Some(fs_name),
|
||||
targets: &[],
|
||||
@@ -277,9 +287,15 @@ fn mesh_draw(ctx: &TestingContext, draw_type: DrawType, info: MeshPipelineTestIn
|
||||
let (_depth_image, depth_view, depth_state) = create_depth(device);
|
||||
let test_hash = hash_testing_context(ctx).to_string();
|
||||
|
||||
let (task, mesh, frag, ts_name, ms_name, fs_name) =
|
||||
get_shaders(device, backend, &test_hash, &info);
|
||||
let frag = frag.unwrap();
|
||||
let Shaders {
|
||||
ts,
|
||||
ms,
|
||||
fs,
|
||||
ts_name,
|
||||
ms_name,
|
||||
fs_name,
|
||||
} = get_shaders(device, backend, &test_hash, &info);
|
||||
let frag = fs.unwrap();
|
||||
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[],
|
||||
@@ -288,13 +304,13 @@ fn mesh_draw(ctx: &TestingContext, draw_type: DrawType, info: MeshPipelineTestIn
|
||||
let pipeline = device.create_mesh_pipeline(&wgpu::MeshPipelineDescriptor {
|
||||
label: None,
|
||||
layout: Some(&layout),
|
||||
task: task.as_ref().map(|task| wgpu::TaskState {
|
||||
task: ts.as_ref().map(|task| wgpu::TaskState {
|
||||
module: task,
|
||||
entry_point: Some(ts_name),
|
||||
compilation_options: Default::default(),
|
||||
}),
|
||||
mesh: wgpu::MeshState {
|
||||
module: &mesh,
|
||||
module: &ms,
|
||||
entry_point: Some(ms_name),
|
||||
compilation_options: Default::default(),
|
||||
},
|
||||
|
||||
@@ -0,0 +1,545 @@
|
||||
use std::{
|
||||
borrow::Cow,
|
||||
hash::{DefaultHasher, Hash, Hasher},
|
||||
};
|
||||
|
||||
use wgpu::{
|
||||
Backends, ColorTargetState, ColorWrites, Features, FragmentState, MultisampleState,
|
||||
PipelineLayoutDescriptor, RenderPipelineDescriptor, VertexState,
|
||||
};
|
||||
use wgpu_test::{
|
||||
gpu_test, FailureCase, GpuTestConfiguration, GpuTestInitializer, TestParameters, TestingContext,
|
||||
};
|
||||
use wgpu_types::CreateShaderModuleDescriptorPassthrough;
|
||||
|
||||
pub fn all_tests(tests: &mut Vec<GpuTestInitializer>) {
|
||||
tests.push(METAL_PASSTHROUGH_SHADER);
|
||||
tests.push(METALLIB_PASSTHROUGH_SHADER);
|
||||
tests.push(HLSL_PASSTHROUGH_SHADER);
|
||||
tests.push(DXIL_PASSTHROUGH_SHADER);
|
||||
tests.push(SPIRV_PASSTHROUGH_SHADER);
|
||||
tests.push(GLSL_PASSTHROUGH_SHADER);
|
||||
tests.push(WGSL_PASSTHROUGH_SHADER);
|
||||
tests.push(ALL_PASSTHROUGH_SHADERS_BINARY);
|
||||
tests.push(ALL_PASSTHROUGH_SHADERS_SOURCE);
|
||||
tests.push(PASSTHROUGH_SHADERS_EXPLICIT_LAYOUT_VALIDATION);
|
||||
}
|
||||
|
||||
fn test_hash(ctx: &TestingContext, name: &str) -> u64 {
|
||||
let mut hasher = DefaultHasher::new();
|
||||
ctx.hash(&mut hasher);
|
||||
name.hash(&mut hasher);
|
||||
hasher.finish()
|
||||
}
|
||||
|
||||
fn test_with_module(ctx: TestingContext, vertex: wgpu::ShaderModule, fragment: wgpu::ShaderModule) {
|
||||
let layout = ctx
|
||||
.device
|
||||
.create_pipeline_layout(&PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[],
|
||||
immediate_size: 0,
|
||||
});
|
||||
let _pipeline = ctx
|
||||
.device
|
||||
.create_render_pipeline(&RenderPipelineDescriptor {
|
||||
label: None,
|
||||
layout: Some(&layout),
|
||||
vertex: VertexState {
|
||||
module: &vertex,
|
||||
entry_point: Some("vertex_main"),
|
||||
compilation_options: Default::default(),
|
||||
buffers: &[],
|
||||
},
|
||||
primitive: Default::default(),
|
||||
depth_stencil: None,
|
||||
multisample: MultisampleState::default(),
|
||||
fragment: Some(FragmentState {
|
||||
module: &fragment,
|
||||
entry_point: Some("fragment_main"),
|
||||
compilation_options: Default::default(),
|
||||
targets: &[Some(ColorTargetState {
|
||||
format: wgpu::TextureFormat::Rgba8Unorm,
|
||||
blend: None,
|
||||
write_mask: ColorWrites::all(),
|
||||
})],
|
||||
}),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
}
|
||||
|
||||
fn metal_source() -> Cow<'static, str> {
|
||||
Cow::Borrowed(include_str!("shader.metal"))
|
||||
}
|
||||
|
||||
fn metal_test(ctx: TestingContext) {
|
||||
let module = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
msl: Some(metal_source()),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, module.clone(), module);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static METAL_PASSTHROUGH_SHADER: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.skip(FailureCase::backend(!Backends::METAL)),
|
||||
)
|
||||
.run_sync(metal_test);
|
||||
|
||||
fn metallib_source(test_hash: u64) -> Cow<'static, [u8]> {
|
||||
if cfg!(not(target_vendor = "apple")) {
|
||||
return Cow::Borrowed(&[]);
|
||||
}
|
||||
let metal_compiler = std::process::Command::new("xcrun")
|
||||
.args(["--find", "metal"])
|
||||
.status()
|
||||
.is_ok_and(|a| a.success());
|
||||
let metallib_linker = std::process::Command::new("xcrun")
|
||||
.args(["--find", "metallib"])
|
||||
.status()
|
||||
.is_ok_and(|a| a.success());
|
||||
if !metal_compiler || !metallib_linker {
|
||||
panic!("Metal compiler or metallib linker not present. Most users can safely ignore this.");
|
||||
}
|
||||
let air_name = format!(
|
||||
"{}/tests/wgpu-gpu/passthrough/shader{test_hash}.air",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
);
|
||||
let output_name = format!(
|
||||
"{}/tests/wgpu-gpu/passthrough/shader{test_hash}.metallib",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
);
|
||||
|
||||
{
|
||||
let output = std::process::Command::new("xcrun")
|
||||
.args([
|
||||
"metal",
|
||||
"-c",
|
||||
&format!(
|
||||
"{}/tests/wgpu-gpu/passthrough/shader.metal",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
),
|
||||
"-o",
|
||||
&air_name,
|
||||
])
|
||||
.output()
|
||||
.unwrap();
|
||||
if !output.status.success() {
|
||||
panic!(
|
||||
"Failed to compile .metal into .air: {}",
|
||||
String::from_utf8(output.stderr).unwrap()
|
||||
);
|
||||
}
|
||||
}
|
||||
{
|
||||
let output = std::process::Command::new("xcrun")
|
||||
.args(["metallib", &air_name, "-o", &output_name])
|
||||
.output()
|
||||
.unwrap();
|
||||
if !output.status.success() {
|
||||
panic!(
|
||||
"Failed to compile .air into .metallib: {}",
|
||||
String::from_utf8(output.stderr).unwrap()
|
||||
);
|
||||
}
|
||||
}
|
||||
let source = std::fs::read(&output_name).unwrap();
|
||||
Cow::Owned(source)
|
||||
}
|
||||
|
||||
fn metallib_test(ctx: TestingContext) {
|
||||
let test_hash = test_hash(&ctx, "metallib_test");
|
||||
let source = metallib_source(test_hash);
|
||||
let module = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
metallib: Some(std::borrow::Cow::Borrowed(&source)),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, module.clone(), module);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static METALLIB_PASSTHROUGH_SHADER: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.skip(FailureCase::backend(!Backends::METAL)),
|
||||
)
|
||||
.run_sync(metallib_test);
|
||||
|
||||
fn hlsl_source() -> Cow<'static, str> {
|
||||
std::borrow::Cow::Borrowed(include_str!("shader.hlsl"))
|
||||
}
|
||||
|
||||
fn hlsl_test(ctx: TestingContext) {
|
||||
let module = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
hlsl: Some(hlsl_source()),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, module.clone(), module);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static HLSL_PASSTHROUGH_SHADER: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.skip(FailureCase::backend(!Backends::DX12)),
|
||||
)
|
||||
.run_sync(hlsl_test);
|
||||
|
||||
fn compile_dxil(entry: &str, stage_str: &str, test_hash: u64) -> Cow<'static, [u8]> {
|
||||
let out_path = format!(
|
||||
"{}/tests/wgpu-gpu/passthrough/shader{test_hash}.{stage_str}.cso",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
);
|
||||
let cmd = std::process::Command::new("dxc")
|
||||
.args([
|
||||
"-T",
|
||||
&format!("{stage_str}_6_3"),
|
||||
"-E",
|
||||
entry,
|
||||
&format!(
|
||||
"{}/tests/wgpu-gpu/passthrough/shader.hlsl",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
),
|
||||
"-Fo",
|
||||
&out_path,
|
||||
])
|
||||
.output()
|
||||
.unwrap();
|
||||
let file = std::fs::read(&out_path);
|
||||
let _ = std::fs::remove_file(out_path);
|
||||
// Remove the file before checking for status
|
||||
if !cmd.status.success() {
|
||||
panic!("DXC failed:\n{}", String::from_utf8(cmd.stderr).unwrap());
|
||||
}
|
||||
let file = file.unwrap();
|
||||
Cow::Owned(file)
|
||||
}
|
||||
|
||||
fn dxil_vertex_source(test_hash: u64) -> Cow<'static, [u8]> {
|
||||
if cfg!(target_os = "windows") {
|
||||
compile_dxil("vertex_main", "vs", test_hash)
|
||||
} else {
|
||||
Cow::Borrowed(&[])
|
||||
}
|
||||
}
|
||||
|
||||
fn dxil_fragment_source(test_hash: u64) -> Cow<'static, [u8]> {
|
||||
if cfg!(target_os = "windows") {
|
||||
compile_dxil("fragment_main", "ps", test_hash)
|
||||
} else {
|
||||
Cow::Borrowed(&[])
|
||||
}
|
||||
}
|
||||
|
||||
fn dxil_test(ctx: TestingContext) {
|
||||
let test_hash = test_hash(&ctx, "dxil_test");
|
||||
let vertex_source = dxil_vertex_source(test_hash);
|
||||
let vertex = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (1, 1, 1),
|
||||
dxil: Some(vertex_source),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
let fragment_source = dxil_fragment_source(test_hash);
|
||||
let fragment = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (1, 1, 1),
|
||||
dxil: Some(fragment_source),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, vertex, fragment);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static DXIL_PASSTHROUGH_SHADER: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.skip(FailureCase::backend(!Backends::DX12)),
|
||||
)
|
||||
.run_sync(dxil_test);
|
||||
|
||||
fn spirv_source(test_hash: u64) -> Cow<'static, [u32]> {
|
||||
let out_path = format!(
|
||||
"{}/tests/wgpu-gpu/passthrough/shade{test_hash}.spv",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
);
|
||||
let cmd = std::process::Command::new("dxc")
|
||||
.args([
|
||||
"-spirv",
|
||||
"-T",
|
||||
"lib_6_3",
|
||||
"-fspv-target-env=vulkan1.0",
|
||||
// We need to tell it to compile for SPIRV which requires different info
|
||||
"-D",
|
||||
"SPIRV",
|
||||
&format!(
|
||||
"{}/tests/wgpu-gpu/passthrough/shader.hlsl",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
),
|
||||
"-Fo",
|
||||
&out_path,
|
||||
])
|
||||
.output()
|
||||
.unwrap();
|
||||
let file = std::fs::read(&out_path);
|
||||
let _ = std::fs::remove_file(out_path);
|
||||
// Remove the file before checking for status
|
||||
if !cmd.status.success() {
|
||||
panic!("DXC failed:\n{}", String::from_utf8(cmd.stderr).unwrap());
|
||||
}
|
||||
let file = file.unwrap();
|
||||
let spirv = bytemuck::pod_collect_to_vec::<u8, u32>(&file);
|
||||
Cow::Owned(spirv)
|
||||
}
|
||||
|
||||
fn spirv_test(ctx: TestingContext) {
|
||||
let test_hash = test_hash(&ctx, "spirv_test");
|
||||
let module = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
spirv: Some(spirv_source(test_hash)),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, module.clone(), module);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static SPIRV_PASSTHROUGH_SHADER: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.skip(FailureCase::backend(!Backends::VULKAN)),
|
||||
)
|
||||
.run_sync(spirv_test);
|
||||
|
||||
fn glsl_vertex_source() -> Cow<'static, str> {
|
||||
std::borrow::Cow::Borrowed(include_str!("shader.vert"))
|
||||
}
|
||||
|
||||
fn glsl_fragment_source() -> Cow<'static, str> {
|
||||
std::borrow::Cow::Borrowed(include_str!("shader.frag"))
|
||||
}
|
||||
|
||||
fn glsl_test(ctx: TestingContext) {
|
||||
let vertex = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
glsl: Some(glsl_vertex_source()),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
let fragment = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
glsl: Some(glsl_fragment_source()),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, vertex, fragment);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static GLSL_PASSTHROUGH_SHADER: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.skip(FailureCase::backend(!Backends::GL)),
|
||||
)
|
||||
.run_sync(glsl_test);
|
||||
|
||||
fn wgsl_source() -> Cow<'static, str> {
|
||||
std::borrow::Cow::Borrowed(include_str!("shader.wgsl"))
|
||||
}
|
||||
|
||||
fn wgsl_test(ctx: TestingContext) {
|
||||
let module = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
wgsl: Some(wgsl_source()),
|
||||
..Default::default()
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, module.clone(), module);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static WGSL_PASSTHROUGH_SHADER: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.skip(FailureCase::backend(!Backends::BROWSER_WEBGPU)),
|
||||
)
|
||||
.run_sync(wgsl_test);
|
||||
|
||||
fn all_passthrough_shaders_binary(ctx: TestingContext) {
|
||||
let test_hash = test_hash(&ctx, "all_passthrough_binary");
|
||||
let vertex = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
spirv: Some(spirv_source(test_hash)),
|
||||
dxil: Some(dxil_vertex_source(test_hash)),
|
||||
hlsl: None,
|
||||
metallib: Some(metallib_source(test_hash)),
|
||||
msl: None,
|
||||
glsl: Some(glsl_vertex_source()),
|
||||
wgsl: Some(wgsl_source()),
|
||||
})
|
||||
};
|
||||
let fragment = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
spirv: Some(spirv_source(test_hash)),
|
||||
dxil: Some(dxil_fragment_source(test_hash)),
|
||||
hlsl: None,
|
||||
metallib: Some(metallib_source(test_hash)),
|
||||
msl: None,
|
||||
glsl: Some(glsl_fragment_source()),
|
||||
wgsl: Some(wgsl_source()),
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, vertex, fragment);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static ALL_PASSTHROUGH_SHADERS_BINARY: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(TestParameters::default().features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS))
|
||||
.run_sync(all_passthrough_shaders_binary);
|
||||
|
||||
fn all_passthrough_shader_source(ctx: TestingContext) {
|
||||
let test_hash = test_hash(&ctx, "all_passthrough_source");
|
||||
let vertex = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
spirv: Some(spirv_source(test_hash)),
|
||||
dxil: None,
|
||||
hlsl: Some(hlsl_source()),
|
||||
metallib: None,
|
||||
msl: Some(metal_source()),
|
||||
glsl: Some(glsl_vertex_source()),
|
||||
wgsl: Some(wgsl_source()),
|
||||
})
|
||||
};
|
||||
let fragment = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
spirv: Some(spirv_source(test_hash)),
|
||||
dxil: None,
|
||||
hlsl: Some(hlsl_source()),
|
||||
metallib: None,
|
||||
msl: Some(metal_source()),
|
||||
glsl: Some(glsl_fragment_source()),
|
||||
wgsl: Some(wgsl_source()),
|
||||
})
|
||||
};
|
||||
test_with_module(ctx, vertex, fragment);
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static ALL_PASSTHROUGH_SHADERS_SOURCE: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(TestParameters::default().features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS))
|
||||
.run_sync(all_passthrough_shader_source);
|
||||
|
||||
fn explicit_layout_validation(ctx: TestingContext) {
|
||||
let test_hash = test_hash(&ctx, "explicit_layout_validation");
|
||||
let vertex = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
spirv: Some(spirv_source(test_hash)),
|
||||
dxil: None,
|
||||
hlsl: Some(hlsl_source()),
|
||||
metallib: None,
|
||||
msl: Some(metal_source()),
|
||||
glsl: Some(glsl_vertex_source()),
|
||||
wgsl: Some(wgsl_source()),
|
||||
})
|
||||
};
|
||||
let fragment = unsafe {
|
||||
ctx.device
|
||||
.create_shader_module_passthrough(CreateShaderModuleDescriptorPassthrough {
|
||||
label: None,
|
||||
num_workgroups: (0, 0, 0),
|
||||
spirv: Some(spirv_source(test_hash)),
|
||||
dxil: None,
|
||||
hlsl: Some(hlsl_source()),
|
||||
metallib: None,
|
||||
msl: Some(metal_source()),
|
||||
glsl: Some(glsl_fragment_source()),
|
||||
wgsl: Some(wgsl_source()),
|
||||
})
|
||||
};
|
||||
|
||||
let _pipeline = ctx
|
||||
.device
|
||||
.create_render_pipeline(&RenderPipelineDescriptor {
|
||||
label: None,
|
||||
layout: None,
|
||||
vertex: VertexState {
|
||||
module: &vertex,
|
||||
entry_point: Some("vertex_main"),
|
||||
compilation_options: Default::default(),
|
||||
buffers: &[],
|
||||
},
|
||||
primitive: Default::default(),
|
||||
depth_stencil: None,
|
||||
multisample: MultisampleState::default(),
|
||||
fragment: Some(FragmentState {
|
||||
module: &fragment,
|
||||
entry_point: Some("fragment_main"),
|
||||
compilation_options: Default::default(),
|
||||
targets: &[Some(ColorTargetState {
|
||||
format: wgpu::TextureFormat::Rgba8Unorm,
|
||||
blend: None,
|
||||
write_mask: ColorWrites::all(),
|
||||
})],
|
||||
}),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
}
|
||||
|
||||
#[gpu_test]
|
||||
static PASSTHROUGH_SHADERS_EXPLICIT_LAYOUT_VALIDATION: GpuTestConfiguration =
|
||||
GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.features(Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)
|
||||
.expect_fail(FailureCase::always()),
|
||||
)
|
||||
.run_sync(explicit_layout_validation);
|
||||
@@ -0,0 +1,8 @@
|
||||
#version 300 es
|
||||
precision mediump float;
|
||||
|
||||
out vec4 fragColor;
|
||||
|
||||
void main() {
|
||||
fragColor = vec4(1.0, 1.0, 1.0, 1.0);
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
// Used for HLSL, DXIL, and SPIRV passthrough
|
||||
|
||||
struct VSOut
|
||||
{
|
||||
float4 position : SV_POSITION;
|
||||
};
|
||||
|
||||
#ifdef SPIRV
|
||||
[shader("vertex")]
|
||||
#endif
|
||||
VSOut vertex_main(uint vid: SV_VertexID)
|
||||
{
|
||||
VSOut output;
|
||||
|
||||
float2 positions[3] = {
|
||||
float2(0.0, 0.5),
|
||||
float2(-0.5, -0.5),
|
||||
float2(0.5, -0.5),
|
||||
};
|
||||
|
||||
output.position = float4(positions[vid], 0.0, 1.0);
|
||||
return output;
|
||||
}
|
||||
|
||||
#ifdef SPIRV
|
||||
[shader("pixel")]
|
||||
#endif
|
||||
float4 fragment_main(VSOut input) : SV_TARGET
|
||||
{
|
||||
return float4(1.0, 1.0, 1.0, 1.0);
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
// Used for metal and metallib passthrough
|
||||
|
||||
#include <metal_stdlib>
|
||||
using namespace metal;
|
||||
|
||||
struct VSOut {
|
||||
float4 position [[position]];
|
||||
};
|
||||
|
||||
vertex VSOut vertex_main(uint vid [[vertex_id]]) {
|
||||
VSOut out;
|
||||
|
||||
float2 positions[3] = {
|
||||
float2( 0.0, 0.5),
|
||||
float2(-0.5, -0.5),
|
||||
float2( 0.5, -0.5),
|
||||
};
|
||||
|
||||
out.position = float4(positions[vid], 0.0, 1.0);
|
||||
return out;
|
||||
}
|
||||
|
||||
fragment float4 fragment_main(VSOut in [[stage_in]]) {
|
||||
return float4(1.0, 1.0, 1.0, 1.0);
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
#version 300 es
|
||||
|
||||
out vec4 v_position;
|
||||
|
||||
void main() {
|
||||
vec2 positions[3] = vec2[3](
|
||||
vec2( 0.0, 0.5),
|
||||
vec2(-0.5, -0.5),
|
||||
vec2( 0.5, -0.5)
|
||||
);
|
||||
|
||||
gl_Position = vec4(positions[gl_VertexID], 0.0, 1.0);
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
struct VSOut {
|
||||
@builtin(position) position: vec4<f32>,
|
||||
};
|
||||
|
||||
@vertex
|
||||
fn vertex_main(@builtin(vertex_index) vid: u32) -> VSOut {
|
||||
var out: VSOut;
|
||||
|
||||
// Hardcoded triangle in clip space
|
||||
var positions = array<vec2<f32>, 3>(
|
||||
vec2<f32>( 0.0, 0.5),
|
||||
vec2<f32>(-0.5, -0.5),
|
||||
vec2<f32>( 0.5, -0.5),
|
||||
);
|
||||
|
||||
out.position = vec4<f32>(positions[vid], 0.0, 1.0);
|
||||
return out;
|
||||
}
|
||||
|
||||
@fragment
|
||||
fn fragment_main(in: VSOut) -> @location(0) vec4<f32> {
|
||||
return vec4<f32>(1.0, 1.0, 1.0, 1.0);
|
||||
}
|
||||
@@ -1099,6 +1099,7 @@ impl Global {
|
||||
),
|
||||
(desc.dxil.as_deref(), DataKind::Dxil),
|
||||
(desc.hlsl.as_ref().map(|a| a.as_bytes()), DataKind::Hlsl),
|
||||
(desc.metallib.as_deref(), DataKind::MetalLib),
|
||||
(desc.msl.as_ref().map(|a| a.as_bytes()), DataKind::Msl),
|
||||
(desc.glsl.as_ref().map(|a| a.as_bytes()), DataKind::Glsl),
|
||||
(desc.wgsl.as_ref().map(|a| a.as_bytes()), DataKind::Wgsl),
|
||||
@@ -1110,11 +1111,8 @@ impl Global {
|
||||
trace.add(trace::Action::CreateShaderModulePassthrough {
|
||||
id: shader.to_trace(),
|
||||
data: file_names,
|
||||
|
||||
entry_point: desc.entry_point.clone(),
|
||||
label: desc.label.clone(),
|
||||
num_workgroups: desc.num_workgroups,
|
||||
runtime_checks: desc.runtime_checks,
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
@@ -2368,33 +2368,37 @@ impl Device {
|
||||
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);
|
||||
}
|
||||
}
|
||||
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::Metal => {
|
||||
if let Some(metallib) = &descriptor.metallib {
|
||||
hal::ShaderInput::MetalLib {
|
||||
file: metallib,
|
||||
num_workgroups: descriptor.num_workgroups,
|
||||
}
|
||||
} else if let Some(msl) = &descriptor.msl {
|
||||
hal::ShaderInput::Msl {
|
||||
shader: msl,
|
||||
num_workgroups: descriptor.num_workgroups,
|
||||
}
|
||||
} else {
|
||||
return Err(pipeline::CreateShaderModuleError::NotCompiledForBackend);
|
||||
}
|
||||
}
|
||||
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 => {
|
||||
|
||||
@@ -46,6 +46,7 @@ pub enum DataKind {
|
||||
Spv,
|
||||
Dxil,
|
||||
Hlsl,
|
||||
MetalLib,
|
||||
Msl,
|
||||
Glsl,
|
||||
}
|
||||
@@ -59,6 +60,7 @@ impl core::fmt::Display for DataKind {
|
||||
DataKind::Spv => "spv",
|
||||
DataKind::Dxil => "dxil",
|
||||
DataKind::Hlsl => "hlsl",
|
||||
DataKind::MetalLib => "metallib",
|
||||
DataKind::Msl => "metal",
|
||||
DataKind::Glsl => "glsl",
|
||||
};
|
||||
@@ -73,7 +75,7 @@ impl DataKind {
|
||||
DataKind::Wgsl | DataKind::Ron | DataKind::Hlsl | DataKind::Msl | DataKind::Glsl => {
|
||||
true
|
||||
}
|
||||
DataKind::Bin | DataKind::Spv | DataKind::Dxil => false,
|
||||
DataKind::Bin | DataKind::Spv | DataKind::Dxil | DataKind::MetalLib => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -94,6 +96,8 @@ impl Data {
|
||||
DataKind::Dxil
|
||||
} else if file.ends_with(".hlsl") {
|
||||
DataKind::Hlsl
|
||||
} else if file.ends_with(".metallib") {
|
||||
DataKind::MetalLib
|
||||
} else if file.ends_with(".metal") {
|
||||
DataKind::Msl
|
||||
} else if file.ends_with(".glsl") {
|
||||
@@ -184,10 +188,8 @@ pub enum Action<'a, R: ReferenceType> {
|
||||
id: PointerId<markers::ShaderModule>,
|
||||
data: Vec<Data>,
|
||||
|
||||
entry_point: String,
|
||||
label: crate::Label<'a>,
|
||||
num_workgroups: (u32, u32, u32),
|
||||
runtime_checks: wgt::ShaderRuntimeChecks,
|
||||
},
|
||||
DestroyShaderModule(PointerId<markers::ShaderModule>),
|
||||
CreateComputePipeline {
|
||||
|
||||
@@ -75,6 +75,7 @@ metal = [
|
||||
"naga/msl-out",
|
||||
"dep:arrayvec",
|
||||
"dep:block2",
|
||||
"dep:dispatch2",
|
||||
"dep:hashbrown",
|
||||
"dep:libc",
|
||||
"dep:log",
|
||||
@@ -283,6 +284,7 @@ mach-dxcompiler-rs = { workspace = true, optional = true }
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies]
|
||||
# Backend: Metal
|
||||
block2 = { workspace = true, optional = true }
|
||||
dispatch2 = { workspace = true, optional = true }
|
||||
objc2 = { workspace = true, optional = true }
|
||||
objc2-core-foundation = { workspace = true, optional = true }
|
||||
objc2-foundation = { workspace = true, optional = true }
|
||||
|
||||
@@ -383,11 +383,10 @@ impl super::Device {
|
||||
}
|
||||
super::ShaderModuleSource::HlslPassthrough(passthrough) => ShaderCacheKey {
|
||||
source: passthrough.shader.clone(),
|
||||
entry_point: passthrough.entry_point.clone(),
|
||||
entry_point: stage.entry_point.to_string(),
|
||||
stage: naga_stage,
|
||||
shader_model: naga_options.shader_model,
|
||||
},
|
||||
|
||||
super::ShaderModuleSource::DxilPassthrough(passthrough) => {
|
||||
return Ok(super::CompiledShader::Precompiled(
|
||||
passthrough.shader.clone(),
|
||||
@@ -1831,12 +1830,10 @@ impl crate::Device for super::Device {
|
||||
}),
|
||||
crate::ShaderInput::Dxil {
|
||||
shader,
|
||||
entry_point,
|
||||
num_workgroups,
|
||||
} => Ok(super::ShaderModule {
|
||||
source: super::ShaderModuleSource::DxilPassthrough(super::DxilPassthroughShader {
|
||||
shader: shader.to_vec(),
|
||||
entry_point,
|
||||
num_workgroups,
|
||||
}),
|
||||
raw_name,
|
||||
@@ -1844,18 +1841,17 @@ impl crate::Device for super::Device {
|
||||
}),
|
||||
crate::ShaderInput::Hlsl {
|
||||
shader,
|
||||
entry_point,
|
||||
num_workgroups,
|
||||
} => Ok(super::ShaderModule {
|
||||
source: super::ShaderModuleSource::HlslPassthrough(super::HlslPassthroughShader {
|
||||
shader: shader.to_owned(),
|
||||
entry_point,
|
||||
num_workgroups,
|
||||
}),
|
||||
raw_name,
|
||||
runtime_checks: desc.runtime_checks,
|
||||
}),
|
||||
crate::ShaderInput::SpirV(_)
|
||||
| crate::ShaderInput::MetalLib { .. }
|
||||
| crate::ShaderInput::Msl { .. }
|
||||
| crate::ShaderInput::Glsl { .. } => {
|
||||
unreachable!()
|
||||
|
||||
@@ -1601,14 +1601,12 @@ impl crate::Queue for Queue {
|
||||
#[derive(Debug)]
|
||||
pub struct DxilPassthroughShader {
|
||||
pub shader: Vec<u8>,
|
||||
pub entry_point: String,
|
||||
pub num_workgroups: (u32, u32, u32),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct HlslPassthroughShader {
|
||||
pub shader: String,
|
||||
pub entry_point: String,
|
||||
pub num_workgroups: (u32, u32, u32),
|
||||
}
|
||||
|
||||
|
||||
@@ -1352,6 +1352,7 @@ impl crate::Device for super::Device {
|
||||
// The backend doesn't yet expose this feature so it should be fine
|
||||
crate::ShaderInput::Glsl { .. } => unimplemented!(),
|
||||
crate::ShaderInput::SpirV(_)
|
||||
| crate::ShaderInput::MetalLib { .. }
|
||||
| crate::ShaderInput::Msl { .. }
|
||||
| crate::ShaderInput::Dxil { .. }
|
||||
| crate::ShaderInput::Hlsl { .. } => {
|
||||
|
||||
+4
-4
@@ -2338,25 +2338,25 @@ impl fmt::Debug for NagaShader {
|
||||
/// Shader input.
|
||||
pub enum ShaderInput<'a> {
|
||||
Naga(NagaShader),
|
||||
MetalLib {
|
||||
file: &'a [u8],
|
||||
num_workgroups: (u32, u32, u32),
|
||||
},
|
||||
Msl {
|
||||
shader: &'a str,
|
||||
entry_point: String,
|
||||
num_workgroups: (u32, u32, u32),
|
||||
},
|
||||
SpirV(&'a [u32]),
|
||||
Dxil {
|
||||
shader: &'a [u8],
|
||||
entry_point: String,
|
||||
num_workgroups: (u32, u32, u32),
|
||||
},
|
||||
Hlsl {
|
||||
shader: &'a str,
|
||||
entry_point: String,
|
||||
num_workgroups: (u32, u32, u32),
|
||||
},
|
||||
Glsl {
|
||||
shader: &'a str,
|
||||
entry_point: String,
|
||||
num_workgroups: (u32, u32, u32),
|
||||
},
|
||||
}
|
||||
|
||||
@@ -1,5 +1,10 @@
|
||||
use alloc::{borrow::ToOwned as _, sync::Arc, vec::Vec};
|
||||
use core::{ptr::NonNull, sync::atomic};
|
||||
use core::{
|
||||
ffi::c_void,
|
||||
ptr::{self, NonNull},
|
||||
sync::atomic,
|
||||
};
|
||||
use dispatch2::DispatchData;
|
||||
use std::{thread, time};
|
||||
|
||||
use objc2::{
|
||||
@@ -320,7 +325,10 @@ impl super::Device {
|
||||
}
|
||||
ShaderModuleSource::Passthrough(ref shader) => Ok(CompiledShader {
|
||||
library: shader.library.clone(),
|
||||
function: shader.function.clone(),
|
||||
function: shader
|
||||
.library
|
||||
.newFunctionWithName(&NSString::from_str(stage.entry_point))
|
||||
.ok_or(crate::PipelineError::EntryPoint(naga_stage))?,
|
||||
wg_size: MTLSize {
|
||||
width: shader.num_workgroups.0 as usize,
|
||||
height: shader.num_workgroups.1 as usize,
|
||||
@@ -1089,9 +1097,36 @@ impl crate::Device for super::Device {
|
||||
source: ShaderModuleSource::Naga(naga),
|
||||
bounds_checks: desc.runtime_checks,
|
||||
}),
|
||||
crate::ShaderInput::MetalLib {
|
||||
file,
|
||||
num_workgroups,
|
||||
} => {
|
||||
// SAFETY: this creates a reference to `file` that is dropped before `file` is dropped.
|
||||
let data = unsafe {
|
||||
DispatchData::new(
|
||||
NonNull::new(file.as_ptr() as *mut c_void).unwrap(),
|
||||
file.len(),
|
||||
None,
|
||||
ptr::null_mut(),
|
||||
)
|
||||
};
|
||||
let library = self
|
||||
.shared
|
||||
.device
|
||||
.newLibraryWithData_error(&data)
|
||||
.map_err(|e| crate::ShaderError::Compilation(format!("Metallib: {e:?}")))?;
|
||||
drop(data);
|
||||
Ok(super::ShaderModule {
|
||||
source: ShaderModuleSource::Passthrough(PassthroughShader {
|
||||
library,
|
||||
num_workgroups,
|
||||
}),
|
||||
// This goes unused for passthrough shaders
|
||||
bounds_checks: wgt::ShaderRuntimeChecks::unchecked(),
|
||||
})
|
||||
}
|
||||
crate::ShaderInput::Msl {
|
||||
shader: source,
|
||||
entry_point,
|
||||
num_workgroups,
|
||||
} => {
|
||||
let options = MTLCompileOptions::new();
|
||||
@@ -1100,22 +1135,14 @@ impl crate::Device for super::Device {
|
||||
let library = device
|
||||
.newLibraryWithSource_options_error(&NSString::from_str(source), Some(&options))
|
||||
.map_err(|e| crate::ShaderError::Compilation(format!("MSL: {e:?}")))?;
|
||||
let function = library
|
||||
.newFunctionWithName(&NSString::from_str(&entry_point))
|
||||
.ok_or_else(|| {
|
||||
crate::ShaderError::Compilation(format!(
|
||||
"Entry point '{entry_point}' not found"
|
||||
))
|
||||
})?;
|
||||
|
||||
Ok(super::ShaderModule {
|
||||
source: ShaderModuleSource::Passthrough(PassthroughShader {
|
||||
library,
|
||||
function,
|
||||
entry_point,
|
||||
num_workgroups,
|
||||
}),
|
||||
bounds_checks: desc.runtime_checks,
|
||||
// This goes unused for passthrough shaders
|
||||
bounds_checks: wgt::ShaderRuntimeChecks::unchecked(),
|
||||
})
|
||||
}
|
||||
crate::ShaderInput::SpirV(_)
|
||||
@@ -1603,14 +1630,17 @@ impl crate::Device for super::Device {
|
||||
let descriptor = MTLComputePipelineDescriptor::new();
|
||||
|
||||
let module = desc.stage.module;
|
||||
let cs = if let ShaderModuleSource::Passthrough(desc) = &module.source {
|
||||
let cs = if let ShaderModuleSource::Passthrough(passthrough_desc) = &module.source {
|
||||
CompiledShader {
|
||||
library: desc.library.clone(),
|
||||
function: desc.function.clone(),
|
||||
library: passthrough_desc.library.clone(),
|
||||
function: passthrough_desc
|
||||
.library
|
||||
.newFunctionWithName(&NSString::from_str(desc.stage.entry_point))
|
||||
.ok_or(crate::PipelineError::EntryPoint(naga::ShaderStage::Compute))?,
|
||||
wg_size: MTLSize {
|
||||
width: desc.num_workgroups.0 as usize,
|
||||
height: desc.num_workgroups.1 as usize,
|
||||
depth: desc.num_workgroups.2 as usize,
|
||||
width: passthrough_desc.num_workgroups.0 as usize,
|
||||
height: passthrough_desc.num_workgroups.1 as usize,
|
||||
depth: passthrough_desc.num_workgroups.2 as usize,
|
||||
},
|
||||
wg_memory_sizes: vec![],
|
||||
sized_bindings: vec![],
|
||||
|
||||
@@ -45,7 +45,7 @@ use objc2_metal::{
|
||||
MTLArgumentBuffersTier, MTLBlitCommandEncoder, MTLBuffer, MTLCommandBuffer,
|
||||
MTLCommandBufferStatus, MTLCommandQueue, MTLComputeCommandEncoder, MTLComputePipelineState,
|
||||
MTLCounterSampleBuffer, MTLCullMode, MTLDepthClipMode, MTLDepthStencilState, MTLDevice,
|
||||
MTLDrawable, MTLFunction, MTLIndexType, MTLLanguageVersion, MTLLibrary, MTLPrimitiveType,
|
||||
MTLDrawable, MTLIndexType, MTLLanguageVersion, MTLLibrary, MTLPrimitiveType,
|
||||
MTLReadWriteTextureTier, MTLRenderCommandEncoder, MTLRenderPipelineState, MTLRenderStages,
|
||||
MTLResource, MTLResourceUsage, MTLSamplerState, MTLSharedEvent, MTLSize, MTLTexture,
|
||||
MTLTextureType, MTLTriangleFillMode, MTLWinding,
|
||||
@@ -792,8 +792,6 @@ pub enum ShaderModuleSource {
|
||||
#[derive(Debug)]
|
||||
pub struct PassthroughShader {
|
||||
pub library: Retained<ProtocolObject<dyn MTLLibrary>>,
|
||||
pub function: Retained<ProtocolObject<dyn MTLFunction>>,
|
||||
pub entry_point: String,
|
||||
pub num_workgroups: (u32, u32, u32),
|
||||
}
|
||||
|
||||
|
||||
@@ -1747,7 +1747,8 @@ impl crate::Device for super::Device {
|
||||
crate::ShaderInput::SpirV(data) => {
|
||||
super::ShaderModule::Raw(self.create_shader_module_impl(data, &desc.label)?)
|
||||
}
|
||||
crate::ShaderInput::Msl { .. }
|
||||
crate::ShaderInput::MetalLib { .. }
|
||||
| crate::ShaderInput::Msl { .. }
|
||||
| crate::ShaderInput::Dxil { .. }
|
||||
| crate::ShaderInput::Hlsl { .. }
|
||||
| crate::ShaderInput::Glsl { .. } => unreachable!(),
|
||||
|
||||
+23
-11
@@ -1,4 +1,4 @@
|
||||
use alloc::{borrow::Cow, string::String};
|
||||
use alloc::borrow::Cow;
|
||||
|
||||
/// Describes how shader bound checks should be performed.
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
@@ -92,23 +92,21 @@ impl Default for ShaderRuntimeChecks {
|
||||
#[derive(Debug, Clone)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
pub struct CreateShaderModuleDescriptorPassthrough<'a, L> {
|
||||
/// Entrypoint. Unused for Spir-V.
|
||||
pub entry_point: String,
|
||||
/// Debug label of the shader module. This will show up in graphics debuggers for easy identification.
|
||||
pub label: L,
|
||||
/// Number of workgroups in each dimension x, y and z. Unused for Spir-V.
|
||||
pub num_workgroups: (u32, u32, u32),
|
||||
/// Runtime checks that should be enabled.
|
||||
pub runtime_checks: ShaderRuntimeChecks,
|
||||
|
||||
/// Binary SPIR-V data, in 4-byte words.
|
||||
pub spirv: Option<Cow<'a, [u32]>>,
|
||||
/// Shader DXIL source.
|
||||
pub dxil: Option<Cow<'a, [u8]>>,
|
||||
/// Shader MSL source.
|
||||
pub msl: Option<Cow<'a, str>>,
|
||||
/// Shader HLSL source.
|
||||
pub hlsl: Option<Cow<'a, str>>,
|
||||
/// Shader MetalLib source.
|
||||
pub metallib: Option<Cow<'a, [u8]>>,
|
||||
/// Shader MSL source.
|
||||
pub msl: Option<Cow<'a, str>>,
|
||||
/// Shader GLSL source (currently unused).
|
||||
pub glsl: Option<Cow<'a, str>>,
|
||||
/// Shader WGSL source.
|
||||
@@ -120,12 +118,11 @@ pub struct CreateShaderModuleDescriptorPassthrough<'a, L> {
|
||||
impl<'a, L: Default> Default for CreateShaderModuleDescriptorPassthrough<'a, L> {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
entry_point: "".into(),
|
||||
label: Default::default(),
|
||||
num_workgroups: (0, 0, 0),
|
||||
runtime_checks: ShaderRuntimeChecks::unchecked(),
|
||||
spirv: None,
|
||||
dxil: None,
|
||||
metallib: None,
|
||||
msl: None,
|
||||
hlsl: None,
|
||||
glsl: None,
|
||||
@@ -141,11 +138,10 @@ impl<'a, L> CreateShaderModuleDescriptorPassthrough<'a, L> {
|
||||
fun: impl FnOnce(&L) -> K,
|
||||
) -> CreateShaderModuleDescriptorPassthrough<'a, K> {
|
||||
CreateShaderModuleDescriptorPassthrough {
|
||||
entry_point: self.entry_point.clone(),
|
||||
label: fun(&self.label),
|
||||
num_workgroups: self.num_workgroups,
|
||||
runtime_checks: self.runtime_checks,
|
||||
spirv: self.spirv.clone(),
|
||||
metallib: self.metallib.clone(),
|
||||
dxil: self.dxil.clone(),
|
||||
msl: self.msl.clone(),
|
||||
hlsl: self.hlsl.clone(),
|
||||
@@ -159,10 +155,18 @@ impl<'a, L> CreateShaderModuleDescriptorPassthrough<'a, L> {
|
||||
pub fn trace_data(&self) -> &[u8] {
|
||||
if let Some(spirv) = &self.spirv {
|
||||
bytemuck::cast_slice(spirv)
|
||||
} else if let Some(metallib) = &self.metallib {
|
||||
metallib
|
||||
} else if let Some(msl) = &self.msl {
|
||||
msl.as_bytes()
|
||||
} else if let Some(dxil) = &self.dxil {
|
||||
dxil
|
||||
} else if let Some(hlsl) = &self.hlsl {
|
||||
hlsl.as_bytes()
|
||||
} else if let Some(glsl) = &self.glsl {
|
||||
glsl.as_bytes()
|
||||
} else if let Some(wgsl) = &self.wgsl {
|
||||
wgsl.as_bytes()
|
||||
} else {
|
||||
panic!("No binary data provided to `ShaderModuleDescriptorGeneric`")
|
||||
}
|
||||
@@ -173,10 +177,18 @@ impl<'a, L> CreateShaderModuleDescriptorPassthrough<'a, L> {
|
||||
pub fn trace_binary_ext(&self) -> &'static str {
|
||||
if self.spirv.is_some() {
|
||||
"spv"
|
||||
} else if self.metallib.is_some() {
|
||||
"metallib"
|
||||
} else if self.msl.is_some() {
|
||||
"metal"
|
||||
} else if self.dxil.is_some() {
|
||||
"dxil"
|
||||
} else if self.hlsl.is_some() {
|
||||
"hlsl"
|
||||
} else if self.glsl.is_some() {
|
||||
"glsl"
|
||||
} else if self.wgsl.is_some() {
|
||||
"wgsl"
|
||||
} else {
|
||||
panic!("No binary data provided to `ShaderModuleDescriptorGeneric`")
|
||||
}
|
||||
|
||||
@@ -141,11 +141,10 @@ macro_rules! include_spirv_raw {
|
||||
$crate::ShaderModuleDescriptorPassthrough {
|
||||
label: $crate::__macro_helpers::Some($($token)*),
|
||||
spirv: Some($crate::__macro_helpers::Cow::Borrowed($crate::include_spirv_source!($($token)*))),
|
||||
entry_point: $crate::__macro_helpers::String::new(),
|
||||
// This is unused for SPIR-V
|
||||
num_workgroups: (0, 0, 0),
|
||||
runtime_checks: $crate::ShaderRuntimeChecks::unchecked(),
|
||||
dxil: None,
|
||||
metallib: None,
|
||||
msl: None,
|
||||
hlsl: None,
|
||||
glsl: None,
|
||||
|
||||
Reference in new issue
Block a user