Mesh shaders MSL writer (#8739)

* Single squashed commit

* Updated changelog

* Fixed stupid changelog thing

* If I have to do this one more fucking time I'm gonna lose it

* Removed some pub(super)'s

* Thing

---------

Co-authored-by: Andreas Reich <r_andreas2@web.de>
This commit is contained in:
Inner DaemonsandAndreas Reich authored and GitHub committed 2026-04-07 17:26:22 +00:00
1 parent 63727cf3e8
commit b5bd5aed7d
46 files changed
+1788 -554

No files matched your search

+2
View File
@@ -54,6 +54,7 @@ Bottom level categories:
#### Metal
- Unconditionally enable `Features::CLIP_DISTANCES`. By @ErichDonGubler in [#9270](https://github.com/gfx-rs/wgpu/pull/9270).
- Added full support for mesh shaders, including in WGSL shaders. By @inner-daemons in [#8739](https://github.com/gfx-rs/wgpu/pull/8739).
#### DX12
@@ -68,6 +69,7 @@ Bottom level categories:
#### General
- `Features::CLIP_DISTANCE`, `naga::Capabilities::CLIP_DISTANCE`, and `naga::BuiltIn::ClipDistance` have been renamed to `CLIP_DISTANCES` and `ClipDistances` (viz., pluralized) as appropriate, to match the WebGPU spec. By @ErichDonGubler in [#9267](https://github.com/gfx-rs/wgpu/pull/9267).
- Added more granular limits for mesh shaders. By @inner-daemons in [#8739](https://github.com/gfx-rs/wgpu/pull/8739).
- Added new `InvalidWorkgroupSizeError`, which is now used by `DrawError::InvalidGroupSize` and `StageError::InvalidWorkgroupSize`. By @andyleiserson in [#9357](https://github.com/gfx-rs/wgpu/pull/9357).
#### Validation
+11 -40
View File
@@ -12,17 +12,6 @@ fn compile_wgsl(device: &wgpu::Device) -> wgpu::ShaderModule {
}
}
fn compile_msl(device: &wgpu::Device) -> wgpu::ShaderModule {
unsafe {
device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
label: None,
msl: Some(std::borrow::Cow::Borrowed(include_str!("shader.metal"))),
num_workgroups: (1, 1, 1),
..Default::default()
})
}
}
struct Shaders {
ts: wgpu::ShaderModule,
ms: wgpu::ShaderModule,
@@ -32,33 +21,15 @@ struct Shaders {
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 PASSTHROUGH_SHADERS.
match backend {
wgpu::Backend::Vulkan | wgpu::Backend::Dx12 => {
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::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!(),
fn get_shaders(device: &wgpu::Device) -> Shaders {
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",
}
}
@@ -68,7 +39,7 @@ pub struct Example {
impl crate::framework::Example for Example {
fn init(
config: &wgpu::SurfaceConfiguration,
adapter: &wgpu::Adapter,
_adapter: &wgpu::Adapter,
device: &wgpu::Device,
_queue: &wgpu::Queue,
) -> Self {
@@ -79,7 +50,7 @@ impl crate::framework::Example for Example {
ts_name,
ms_name,
fs_name,
} = get_shaders(device, adapter.get_info().backend);
} = get_shaders(device);
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[],
@@ -1,77 +0,0 @@
using namespace metal;
struct OutVertex {
float4 Position [[position]];
float4 Color [[user(locn0)]];
};
struct OutPrimitive {
float4 ColorMask [[flat]] [[user(locn1)]];
bool CullPrimitive [[primitive_culled]];
};
struct InVertex {
};
struct InPrimitive {
float4 ColorMask [[flat]] [[user(locn1)]];
};
struct FragmentIn {
float4 Color [[user(locn0)]];
float4 ColorMask [[flat]] [[user(locn1)]];
};
struct PayloadData {
float4 ColorMask;
bool Visible;
};
using Meshlet = metal::mesh<OutVertex, OutPrimitive, 3, 1, topology::triangle>;
constant float4 positions[3] = {
float4(0.0, 1.0, 0.0, 1.0),
float4(-1.0, -1.0, 0.0, 1.0),
float4(1.0, -1.0, 0.0, 1.0)
};
constant float4 colors[3] = {
float4(0.0, 1.0, 0.0, 1.0),
float4(0.0, 0.0, 1.0, 1.0),
float4(1.0, 0.0, 0.0, 1.0)
};
[[object]]
void taskShader(uint3 tid [[thread_position_in_grid]], object_data PayloadData &outPayload [[payload]], mesh_grid_properties grid) {
outPayload.ColorMask = float4(1.0, 1.0, 0.0, 1.0);
outPayload.Visible = true;
grid.set_threadgroups_per_grid(uint3(3, 1, 1));
}
[[mesh]]
void meshShader(
object_data PayloadData const& payload [[payload]],
Meshlet out
)
{
out.set_primitive_count(1);
for(int i = 0;i < 3;i++) {
OutVertex vert;
vert.Position = positions[i];
vert.Color = colors[i] * payload.ColorMask;
out.set_vertex(i, vert);
out.set_index(i, i);
}
OutPrimitive prim;
prim.ColorMask = float4(1.0, 0.0, 0.0, 1.0);
prim.CullPrimitive = !payload.Visible;
out.set_primitive(0, prim);
}
fragment float4 fragShader(FragmentIn data [[stage_in]]) {
return data.Color * data.ColorMask;
}
+2
View File
@@ -575,6 +575,8 @@ fn run() -> anyhow::Result<()> {
params.spv_out.mesh_shader_primitive_indices_clamp = args.validate_mesh_output;
params.spv_out.task_dispatch_limits = args.task_limits.0;
params.msl.mesh_shader_primitive_indices_clamp = args.validate_mesh_output;
params.msl.task_dispatch_limits = args.task_limits.0;
params.hlsl.mesh_shader_primitive_indices_clamp = args.validate_mesh_output;
params.hlsl.task_dispatch_limits = args.task_limits.0;
+1 -1
View File
@@ -344,7 +344,7 @@ const RESERVED: &[&str] = &[
// Naga utilities
"DefaultConstructible",
// Naga builtin names
"__local_invocation_id",
"__local_invocation_index",
super::writer::FREXP_FUNCTION,
super::writer::MODF_FUNCTION,
super::writer::ABS_FUNCTION,
+442
View File
@@ -0,0 +1,442 @@
use alloc::{
format,
string::{String, ToString},
vec::Vec,
};
use crate::{
back::{
self,
msl::{
writer::{TypeContext, TypedGlobalVariable},
BackendResult, EntryPointArgument, Error, NAMESPACE, WRAPPED_ARRAY_FIELD,
},
},
proc::NameKey,
};
pub(super) struct MeshOutputInfo {
out_vertex_ty_name: String,
out_primitive_ty_name: String,
out_vertex_member_names: Vec<Option<String>>,
out_primitive_member_names: Vec<Option<String>>,
}
pub(super) struct NestedFunctionInfo<'a> {
pub(super) options: &'a super::Options,
pub(super) ep: &'a crate::EntryPoint,
pub(super) module: &'a crate::Module,
pub(super) mod_info: &'a crate::valid::ModuleInfo,
pub(super) fun_info: &'a crate::valid::FunctionInfo,
pub(super) args: Vec<EntryPointArgument>,
pub(super) local_invocation_index: Option<&'a NameKey>,
pub(super) nested_name: &'a str,
pub(super) outer_name: &'a str,
pub(super) out_mesh_info: Option<MeshOutputInfo>,
}
impl<W: core::fmt::Write> super::Writer<W> {
/// This writes the output vertex and primitive structs given the reflection information about them.
pub(super) fn write_mesh_output_types(
&mut self,
mesh_info: &crate::MeshStageInfo,
fun_name: &str,
module: &crate::Module,
// See `PipelineOptions::allow_and_force_point_size`
allow_and_force_point_size: bool,
options: &super::Options,
) -> Result<MeshOutputInfo, Error> {
let mut vertex_member_names = Vec::new();
let mut primitive_member_names = Vec::new();
let vertex_out_name = self.namer.call(&format!("{fun_name}VertexOutput"));
let primitive_out_name = self.namer.call(&format!("{fun_name}PrimitiveOutput"));
let mut existing_names = Vec::new();
for (out_name, struct_ty, is_primitive, member_names) in [
(
&vertex_out_name,
mesh_info.vertex_output_type,
false,
&mut vertex_member_names,
),
(
&primitive_out_name,
mesh_info.primitive_output_type,
true,
&mut primitive_member_names,
),
] {
writeln!(self.out, "struct {out_name} {{")?;
// Mesh output types are guaranteed to be user defined structs. This is validated by naga.
let crate::TypeInner::Struct { ref members, .. } = module.types[struct_ty].inner else {
unreachable!()
};
let mut has_point_size = false;
for (index, member) in members.iter().enumerate() {
member_names.push(None);
let ty_name = TypeContext {
handle: member.ty,
gctx: module.to_ctx(),
names: &self.names,
access: crate::StorageAccess::empty(),
first_time: true,
};
let binding = member
.binding
.clone()
.ok_or_else(|| Error::GenericValidation("Expected binding, got None".into()))?;
if let crate::Binding::BuiltIn(crate::BuiltIn::PointSize) = binding {
has_point_size = true;
if !allow_and_force_point_size {
continue;
}
}
if let crate::Binding::BuiltIn(
crate::BuiltIn::PointIndex
| crate::BuiltIn::LineIndices
| crate::BuiltIn::TriangleIndices,
) = binding
{
continue;
}
// Names of struct members must be unique across vertex and primitive output.
// Therefore, when writing the primitive output struct, we might need to rename some fields.
let mut name = self.names[&NameKey::StructMember(struct_ty, index as u32)].clone();
if existing_names.contains(&name) {
name = self.namer.call(&name);
} else {
// Let the namer know this is illegal to use again
let _ = self.namer.call(&name);
}
let array_len = match module.types[member.ty].inner {
crate::TypeInner::Array {
size: crate::ArraySize::Constant(size),
..
} => Some(size),
_ => None,
};
let resolved =
options.resolve_local_binding(&binding, back::msl::LocationMode::MeshOutput)?;
write!(self.out, "{}{} {}", back::INDENT, ty_name, name)?;
if let Some(array_len) = array_len {
write!(self.out, " [{array_len}]")?;
}
resolved.try_fmt(&mut self.out)?;
writeln!(self.out, ";")?;
*member_names.last_mut().unwrap() = Some(name.clone());
existing_names.push(name);
}
if allow_and_force_point_size && !has_point_size && !is_primitive {
// inject the point size output last
writeln!(
self.out,
"{}float _point_size [[point_size]];",
back::INDENT
)?;
}
writeln!(self.out, "}};")?;
}
Ok(MeshOutputInfo {
out_vertex_ty_name: vertex_out_name,
out_primitive_ty_name: primitive_out_name,
out_vertex_member_names: vertex_member_names,
out_primitive_member_names: primitive_member_names,
})
}
pub(super) fn write_wrapper_function(&mut self, info: NestedFunctionInfo<'_>) -> BackendResult {
let NestedFunctionInfo {
options,
ep,
module,
mod_info,
fun_info,
args,
local_invocation_index: local_invocation_index_key,
nested_name,
outer_name,
out_mesh_info,
} = info;
let indent = back::INDENT;
let em_str = match ep.stage {
crate::ShaderStage::Mesh => "[[mesh]]",
crate::ShaderStage::Task => "[[object]]",
_ => unreachable!(),
};
writeln!(self.out, "{em_str} void {outer_name}(")?;
// Arguments
let mut mesh_out_name: Option<String> = None;
let mut mesh_variable_name = None;
let mut task_grid_name = None;
if let Some(ref info) = ep.mesh_info {
let mesh_out = out_mesh_info.as_ref().unwrap();
let mesh_name = self.namer.call("meshOutput");
let topology_name = match info.topology {
crate::MeshOutputTopology::Points => "point",
crate::MeshOutputTopology::Lines => "line",
crate::MeshOutputTopology::Triangles => "triangle",
};
let num_verts = info.max_vertices;
let num_prims = info.max_primitives;
writeln!(self.out,
" {NAMESPACE}::mesh<{}, {}, {num_verts}, {num_prims}, metal::topology::{topology_name}> {mesh_name}",
mesh_out.out_vertex_ty_name,
mesh_out.out_primitive_ty_name,
)?;
mesh_out_name = Some(mesh_name);
mesh_variable_name = Some(
self.names
[&NameKey::GlobalVariable(ep.mesh_info.as_ref().unwrap().output_variable)]
.clone(),
);
} else if ep.stage == crate::ShaderStage::Task {
let grid_name = self.namer.call("nagaMeshGrid");
writeln!(self.out, " {NAMESPACE}::mesh_grid_properties {grid_name}")?;
task_grid_name = Some(grid_name);
}
let local_invocation_index = if let Some(key) = local_invocation_index_key {
self.names[key].clone()
} else {
"__local_invocation_index".to_string()
};
for arg in &args {
write!(self.out, ", {} {}{}", arg.ty_name, arg.name, arg.binding)?;
if let Some(init) = arg.init {
write!(self.out, " = ")?;
self.put_const_expression(init, module, mod_info, &module.global_expressions)?;
}
writeln!(self.out)?;
}
writeln!(self.out, ") {{")?;
// Function body
if ep.stage == crate::ShaderStage::Mesh {
for (handle, var) in module.global_variables.iter() {
if var.space != crate::AddressSpace::WorkGroup || fun_info[handle].is_empty() {
continue;
}
let tyvar = TypedGlobalVariable {
module,
names: &self.names,
handle,
usage: crate::valid::GlobalUse::WRITE | crate::valid::GlobalUse::READ,
reference: false,
};
write!(self.out, "{}", back::INDENT)?;
tyvar.try_fmt(&mut self.out)?;
writeln!(self.out, ";")?;
}
}
write!(self.out, "{indent}")?;
let result_name = if ep.stage == crate::ShaderStage::Task {
let name = self.namer.call("nagaGridSize");
write!(self.out, "uint3 {} = ", name)?;
Some(name)
} else {
None
};
write!(self.out, "{nested_name}(")?;
{
let mut is_first = true;
for arg in &args {
if !is_first {
write!(self.out, ", ")?;
}
is_first = false;
write!(self.out, "{}", arg.name)?;
}
if ep.stage == crate::ShaderStage::Mesh {
for (handle, var) in module.global_variables.iter() {
if var.space != crate::AddressSpace::WorkGroup || fun_info[handle].is_empty() {
continue;
}
if !is_first {
write!(self.out, ", ")?;
}
let name = &self.names[&NameKey::GlobalVariable(handle)];
write!(self.out, "{name}")?;
}
}
}
writeln!(self.out, ");")?;
self.write_barrier(
crate::Barrier::WORK_GROUP,
back::Level(1),
info.options.lang_version,
)?;
if let Some(grid_name) = task_grid_name {
let result_name = result_name.unwrap();
writeln!(self.out, "{indent}if ({local_invocation_index} == 0u) {{")?;
{
let level2 = back::Level(2);
if let Some(limits) = options.task_dispatch_limits {
let level3 = back::Level(3);
let max_per_dim = limits.max_mesh_workgroups_per_dim;
let max_total = limits.max_mesh_workgroups_total;
writeln!(self.out, "{level2}if (")?;
writeln!(self.out, "{level3}{result_name}.x > {max_per_dim}u ||")?;
writeln!(self.out, "{level3}{result_name}.y > {max_per_dim}u ||")?;
writeln!(self.out, "{level3}{result_name}.z > {max_per_dim}u ||")?;
writeln!(
self.out,
"{level3}{NAMESPACE}::mulhi({result_name}.x, {result_name}.y) != 0u ||"
)?;
writeln!(
self.out,
"{level3}{NAMESPACE}::mulhi({result_name}.x * {result_name}.y, {result_name}.z) != 0u ||"
)?;
writeln!(self.out, "{level3}({result_name}.x * {result_name}.y * {result_name}.z) > {max_total}u")?;
writeln!(self.out, "{level2}) {{")?;
writeln!(self.out, "{level3}{result_name} = {NAMESPACE}::uint3(0u);")?;
writeln!(self.out, "{level2}}}")?;
}
writeln!(
self.out,
"{level2}{grid_name}.set_threadgroups_per_grid({result_name});"
)?;
}
writeln!(self.out, "{indent}}}")?;
writeln!(self.out, "{indent}return;")?;
} else if let Some(ref info) = ep.mesh_info {
let mesh_out = out_mesh_info.as_ref().unwrap();
let out_ty = module.global_variables[info.output_variable].ty;
let mesh_out_name = mesh_out_name.unwrap();
let mesh_variable_name = mesh_variable_name.unwrap();
// The output type is guaranteed to be a struct with exactly 4 members
let crate::TypeInner::Struct { ref members, .. } = module.types[out_ty].inner else {
unreachable!();
};
let get_out_value = |bi| {
let member_idx = members
.iter()
.position(|a| a.binding == Some(crate::Binding::BuiltIn(bi)))
.unwrap() as u32;
format!(
"{}.{}",
mesh_variable_name,
self.names[&NameKey::StructMember(out_ty, member_idx)]
)
};
let vert_count = format!(
"{NAMESPACE}::min({}, {}u)",
get_out_value(crate::BuiltIn::VertexCount),
info.max_vertices
);
let prim_count = format!(
"{NAMESPACE}::min({}, {}u)",
get_out_value(crate::BuiltIn::PrimitiveCount),
info.max_primitives
);
let workgroup_size: u32 = ep.workgroup_size.iter().product();
{
let vert_index = self.namer.call("vertexIndex");
let in_array = get_out_value(crate::BuiltIn::Vertices);
writeln!(
self.out,
"{indent}for(uint {vert_index} = {local_invocation_index}; {vert_index} < {vert_count}; {vert_index} += {workgroup_size}) {{"
)?;
let out_vert = self.namer.call("vertex");
writeln!(
self.out,
"{indent}{indent}{} {out_vert};",
mesh_out.out_vertex_ty_name,
)?;
for (member_idx, new_name) in mesh_out.out_vertex_member_names.iter().enumerate() {
let in_value = format!(
"{in_array}.{WRAPPED_ARRAY_FIELD}[{vert_index}].{}",
self.names
[&NameKey::StructMember(info.vertex_output_type, member_idx as u32)]
);
let out_value = format!("{out_vert}.{}", new_name.as_ref().unwrap());
writeln!(self.out, "{indent}{indent}{out_value} = {in_value};")?;
}
writeln!(
self.out,
"{indent}{indent}{}.set_vertex({vert_index}, {out_vert});",
mesh_out_name
)?;
writeln!(self.out, "{indent}}}")?;
}
{
let prim_index = self.namer.call("primitiveIndex");
let in_array = get_out_value(crate::BuiltIn::Primitives);
writeln!(
self.out,
"{indent}for(uint {prim_index} = {local_invocation_index}; {prim_index} < {prim_count}; {prim_index} += {workgroup_size}) {{"
)?;
let out_prim = self.namer.call("primitive");
writeln!(
self.out,
"{indent}{indent}{} {out_prim};",
mesh_out.out_primitive_ty_name
)?;
for (member_idx, new_name) in mesh_out.out_primitive_member_names.iter().enumerate()
{
let in_value = format!(
"{in_array}.{WRAPPED_ARRAY_FIELD}[{prim_index}].{}",
self.names
[&NameKey::StructMember(info.primitive_output_type, member_idx as u32)]
);
if let Some(new_name) = new_name.as_ref() {
let out_value = format!("{out_prim}.{new_name}");
writeln!(
self.out,
"{indent}{}{out_value} = {in_value};",
back::INDENT
)?;
} else {
let num_indices = match info.topology {
crate::MeshOutputTopology::Points => 1,
crate::MeshOutputTopology::Lines => 2,
crate::MeshOutputTopology::Triangles => 3,
};
for i in 0..num_indices {
let component = if num_indices == 1 {
"".to_string()
} else {
format!(".{}", back::COMPONENTS[i])
};
writeln!(
self.out,
"{indent}{}{}.set_index({prim_index} * {num_indices} + {i}, {in_value}{component});",
back::INDENT,
mesh_out_name,
)?;
}
}
}
writeln!(
self.out,
"{indent}{}{}.set_primitive({prim_index}, {out_prim});",
back::INDENT,
mesh_out_name
)?;
writeln!(self.out, "{indent}}}")?;
}
writeln!(self.out, "{indent}if ({local_invocation_index} == 0u) {{")?;
writeln!(
self.out,
"{indent}{indent}{}.set_primitive_count({prim_count});",
mesh_out_name,
)?;
writeln!(self.out, "{indent}}}")?;
} else {
// Must either have task output grid (task shader) or mesh output info (mesh shader)
unreachable!()
}
writeln!(self.out, "}}")?;
Ok(())
}
}
+56 -8
View File
@@ -75,9 +75,10 @@ use alloc::{
};
use core::fmt::{Error as FmtError, Write};
use crate::{arena::Handle, ir, proc::index, valid::ModuleInfo};
use crate::{arena::Handle, back::TaskDispatchLimits, ir, proc::index, valid::ModuleInfo};
mod keywords;
mod mesh_shader;
pub mod sampler;
mod writer;
@@ -178,6 +179,7 @@ enum ResolvedBinding {
interpolation: Option<ResolvedInterpolation>,
},
Resource(BindTarget),
Payload,
}
#[derive(Copy, Clone)]
@@ -240,6 +242,8 @@ pub enum Error {
ResolveArraySizeError(#[from] crate::proc::ResolveArraySizeError),
#[error("entry point with stage {0:?} and name '{1}' not found")]
EntryPointNotFound(ir::ShaderStage, String),
#[error("Cannot use mesh shader syntax prior to MSL 3.0")]
UnsupportedMeshShader,
#[error("Per vertex fragment inputs are not supported prior to MSL 4.0")]
PerVertexNotSupported,
}
@@ -280,6 +284,9 @@ enum LocationMode {
/// Output from the fragment shader.
FragmentOutput,
/// Output from the mesh shader.
MeshOutput,
/// Compute shader input or output.
Uniform,
}
@@ -306,6 +313,11 @@ pub struct Options {
/// If set, loops will have code injected into them, forcing the compiler
/// to think the number of iterations is bounded.
pub force_loop_bounding: bool,
/// Whether and how checks in the task shader should verify the dispatched
/// mesh grid size.
pub task_dispatch_limits: Option<TaskDispatchLimits>,
/// Whether to validate the output of a mesh shader workgroup.
pub mesh_shader_primitive_indices_clamp: bool,
}
impl Default for Options {
@@ -319,6 +331,8 @@ impl Default for Options {
bounds_check_policies: index::BoundsCheckPolicies::default(),
zero_initialize_workgroup_memory: true,
force_loop_bounding: true,
task_dispatch_limits: None,
mesh_shader_primitive_indices_clamp: true,
}
}
}
@@ -487,7 +501,7 @@ pub struct PipelineOptions {
/// Metal doesn't like this for non-point primitive topologies and requires it for
/// point primitive topologies.
///
/// Enable this for vertex shaders with point primitive topologies.
/// Enable this for vertex/mesh shaders with point primitive topologies.
pub allow_and_force_point_size: bool,
/// If set, when generating the Metal vertex shader, transform it
@@ -556,7 +570,7 @@ impl Options {
interpolation,
sampling,
blend_src,
per_primitive: _,
per_primitive,
} => match mode {
LocationMode::VertexInput => Ok(ResolvedBinding::Attribute(location)),
LocationMode::FragmentOutput => {
@@ -568,7 +582,9 @@ impl Options {
blend_src,
})
}
LocationMode::VertexOutput | LocationMode::FragmentInput => {
LocationMode::VertexOutput
| LocationMode::FragmentInput
| LocationMode::MeshOutput => {
Ok(ResolvedBinding::User {
prefix: if self.spirv_cross_compatibility {
"locn"
@@ -582,7 +598,11 @@ impl Options {
// sampling is `None` only for Flat interpolation.
let interpolation = interpolation.unwrap();
let sampling = sampling.unwrap_or(crate::Sampling::Center);
Some(ResolvedInterpolation::from_binding(interpolation, sampling))
Some(ResolvedInterpolation::from_binding(
interpolation,
sampling,
per_primitive,
))
},
})
}
@@ -722,6 +742,8 @@ impl ResolvedBinding {
Bi::CullPrimitive => "primitive_culled",
// TODO: figure out how to make this written as a function call
Bi::PointIndex | Bi::LineIndices | Bi::TriangleIndices => unimplemented!(),
// These aren't real builtins passed into MSL. They are extracted by the
// wrapper function which actually sets the outputs.
Bi::MeshTaskSize
| Bi::VertexCount
| Bi::PrimitiveCount
@@ -776,6 +798,7 @@ impl ResolvedBinding {
return Err(Error::UnimplementedBindTarget(target.clone()));
}
}
Self::Payload => write!(out, "payload")?,
}
write!(out, "]]")?;
Ok(())
@@ -783,10 +806,18 @@ impl ResolvedBinding {
}
impl ResolvedInterpolation {
const fn from_binding(interpolation: crate::Interpolation, sampling: crate::Sampling) -> Self {
const fn from_binding(
interpolation: crate::Interpolation,
sampling: crate::Sampling,
per_primitive: bool,
) -> Self {
use crate::Interpolation as I;
use crate::Sampling as S;
if per_primitive {
return Self::Flat;
}
match (interpolation, sampling) {
(I::Perspective, S::Center) => Self::CenterPerspective,
(I::Perspective, S::Centroid) => Self::CentroidPerspective,
@@ -816,6 +847,23 @@ impl ResolvedInterpolation {
}
}
struct EntryPointArgument {
ty_name: String,
name: String,
binding: String,
init: Option<Handle<crate::Expression>>,
}
/// Shorthand result used internally by the backend
type BackendResult = Result<(), Error>;
const NAMESPACE: &str = "metal";
// The name of the array member of the Metal struct types we generate to
// represent Naga `Array` types. See the comments in `Writer::write_type_defs`
// for details.
const WRAPPED_ARRAY_FIELD: &str = "inner";
/// Information about a translated module that is required
/// for the use of the result.
pub struct TranslationInfo {
@@ -869,8 +917,8 @@ pub fn supported_capabilities() -> crate::valid::Capabilities {
| Caps::TEXTURE_EXTERNAL
| Caps::SHADER_FLOAT16_IN_FLOAT32
| Caps::SHADER_BARYCENTRICS
// No MESH_SHADER
// No MESH_SHADER_POINT_TOPOLOGY
| Caps::MESH_SHADER
| Caps::MESH_SHADER_POINT_TOPOLOGY
| Caps::TEXTURE_AND_SAMPLER_BINDING_ARRAY_NON_UNIFORM_INDEXING
// No BUFFER_BINDING_ARRAY_NON_UNIFORM_INDEXING
| Caps::STORAGE_TEXTURE_BINDING_ARRAY_NON_UNIFORM_INDEXING
+340 -159
View File
@@ -13,10 +13,17 @@ use num_traits::real::Real as _;
use half::f16;
use super::{sampler as sm, Error, LocationMode, Options, PipelineOptions, TranslationInfo};
use super::{
sampler as sm, Error, LocationMode, Options, PipelineOptions, TranslationInfo, NAMESPACE,
WRAPPED_ARRAY_FIELD,
};
use crate::{
arena::{Handle, HandleSet},
back::{self, get_entry_points, Baked},
back::{
self, get_entry_points,
msl::{mesh_shader::NestedFunctionInfo, BackendResult, EntryPointArgument},
Baked,
},
common,
proc::{
self, concrete_int_scalars,
@@ -29,14 +36,6 @@ use crate::{
#[cfg(test)]
use core::ptr;
/// Shorthand result used internally by the backend
type BackendResult = Result<(), Error>;
const NAMESPACE: &str = "metal";
// The name of the array member of the Metal struct types we generate to
// represent Naga `Array` types. See the comments in `Writer::write_type_defs`
// for details.
const WRAPPED_ARRAY_FIELD: &str = "inner";
// This is a hack: we need to pass a pointer to an atomic,
// but generally the backend isn't putting "&" in front of every pointer.
// Some more general handling of pointers is needed to be implemented here.
@@ -195,12 +194,12 @@ impl Display for Reinterpreted<'_> {
}
}
struct TypeContext<'a> {
handle: Handle<crate::Type>,
gctx: proc::GlobalCtx<'a>,
names: &'a FastHashMap<NameKey, String>,
access: crate::StorageAccess,
first_time: bool,
pub(super) struct TypeContext<'a> {
pub handle: Handle<crate::Type>,
pub gctx: proc::GlobalCtx<'a>,
pub names: &'a FastHashMap<NameKey, String>,
pub access: crate::StorageAccess,
pub first_time: bool,
}
impl TypeContext<'_> {
@@ -397,16 +396,21 @@ impl Display for TypeContext<'_> {
}
}
struct TypedGlobalVariable<'a> {
module: &'a crate::Module,
names: &'a FastHashMap<NameKey, String>,
handle: Handle<crate::GlobalVariable>,
usage: valid::GlobalUse,
reference: bool,
pub(super) struct TypedGlobalVariable<'a> {
pub module: &'a crate::Module,
pub names: &'a FastHashMap<NameKey, String>,
pub handle: Handle<crate::GlobalVariable>,
pub usage: valid::GlobalUse,
pub reference: bool,
}
struct TypedGlobalVariableParts {
ty_name: String,
var_name: String,
}
impl TypedGlobalVariable<'_> {
fn try_fmt<W: Write>(&self, out: &mut W) -> BackendResult {
fn to_parts(&self) -> Result<TypedGlobalVariableParts, Error> {
let var = &self.module.global_variables[self.handle];
let name = &self.names[&NameKey::GlobalVariable(self.handle)];
@@ -437,8 +441,18 @@ impl TypedGlobalVariable<'_> {
first_time: false,
};
let (coherent, space, access, reference) = match var.space.to_msl_name() {
Some(space) if self.reference => {
let access = if var.space.needs_access_qualifier()
&& !self.usage.intersects(valid::GlobalUse::WRITE)
{
"const"
} else {
""
};
let (coherent, space, access, reference) = match (var.space.to_msl_name(), var.space) {
(Some(space), crate::AddressSpace::WorkGroup) => {
("", space, access, if self.reference { "&" } else { "" })
}
(Some(space), _) if self.reference => {
let coherent = if var
.memory_decorations
.contains(crate::MemoryDecorations::COHERENT)
@@ -447,35 +461,31 @@ impl TypedGlobalVariable<'_> {
} else {
""
};
let access = if var.space.needs_access_qualifier()
&& !self.usage.intersects(valid::GlobalUse::WRITE)
{
"const"
} else {
""
};
(coherent, space, access, "&")
}
_ => ("", "", "", ""),
};
Ok(write!(
out,
"{}{}{}{}{}{}{} {}",
coherent,
space,
let ty = format!(
"{coherent}{space}{}{ty_name}{}{access}{reference}",
if space.is_empty() { "" } else { " " },
ty_name,
if access.is_empty() { "" } else { " " },
access,
reference,
name,
)?)
);
Ok(TypedGlobalVariableParts {
ty_name: ty,
var_name: name.clone(),
})
}
pub(super) fn try_fmt<W: Write>(&self, out: &mut W) -> BackendResult {
let parts = self.to_parts()?;
Ok(write!(out, "{} {}", parts.ty_name, parts.var_name)?)
}
}
#[derive(Eq, PartialEq, Hash)]
enum WrappedFunction {
pub(super) enum WrappedFunction {
UnaryOp {
op: crate::UnaryOperator,
ty: (Option<crate::VectorSize>, crate::Scalar),
@@ -520,20 +530,20 @@ enum WrappedFunction {
}
pub struct Writer<W> {
out: W,
names: FastHashMap<NameKey, String>,
named_expressions: crate::NamedExpressions,
pub(super) out: W,
pub(super) names: FastHashMap<NameKey, String>,
pub(super) named_expressions: crate::NamedExpressions,
/// Set of expressions that need to be baked to avoid unnecessary repetition in output
need_bake_expressions: back::NeedBakeExpressions,
namer: proc::Namer,
wrapped_functions: FastHashSet<WrappedFunction>,
pub(super) need_bake_expressions: back::NeedBakeExpressions,
pub(super) namer: proc::Namer,
pub(super) wrapped_functions: FastHashSet<WrappedFunction>,
#[cfg(test)]
put_expression_stack_pointers: FastHashSet<*const ()>,
pub(super) put_expression_stack_pointers: FastHashSet<*const ()>,
#[cfg(test)]
put_block_stack_pointers: FastHashSet<*const ()>,
pub(super) put_block_stack_pointers: FastHashSet<*const ()>,
/// Set of (struct type, struct field index) denoting which fields require
/// padding inserted **before** them (i.e. between fields at index - 1 and index)
struct_member_pads: FastHashSet<(Handle<crate::Type>, u32)>,
pub(super) struct_member_pads: FastHashSet<(Handle<crate::Type>, u32)>,
}
impl crate::Scalar {
@@ -658,7 +668,8 @@ impl crate::AddressSpace {
// may end up with "const" even if the binding is read-write,
// and that should be OK.
Self::Storage { .. } => true,
Self::TaskPayload | Self::RayPayload | Self::IncomingRayPayload => unimplemented!(),
Self::TaskPayload => true,
Self::RayPayload | Self::IncomingRayPayload => unimplemented!(),
// These should always be read-write.
Self::Private | Self::WorkGroup => false,
// These translate to `constant` address space, no need for qualifiers.
@@ -769,7 +780,7 @@ struct TexelAddress {
level: Option<LevelOfDetail>,
}
struct ExpressionContext<'a> {
pub(super) struct ExpressionContext<'a> {
function: &'a crate::Function,
origin: FunctionOrigin,
info: &'a valid::FunctionInfo,
@@ -1738,7 +1749,7 @@ impl<W: Write> Writer<W> {
Ok(())
}
fn put_const_expression(
pub(super) fn put_const_expression(
&mut self,
expr_handle: Handle<crate::Expression>,
module: &crate::Module,
@@ -1952,7 +1963,7 @@ impl<W: Write> Writer<W> {
///
/// - Pass `false` if it is an operand of a `?:` operator, a `[]`, or really
/// almost anything else.
fn put_expression(
pub(super) fn put_expression(
&mut self,
expr_handle: Handle<crate::Expression>,
context: &ExpressionContext,
@@ -3916,7 +3927,7 @@ impl<W: Write> Writer<W> {
}
crate::Statement::ControlBarrier(flags)
| crate::Statement::MemoryBarrier(flags) => {
self.write_barrier(flags, level)?;
self.write_barrier(flags, level, context.expression.lang_version)?;
}
crate::Statement::Store { pointer, value } => {
self.put_store(pointer, value, level, context)?
@@ -4068,7 +4079,11 @@ impl<W: Write> Writer<W> {
self.put_image_atomic(level, image, &address, fun, value, context)?
}
crate::Statement::WorkGroupUniformLoad { pointer, result } => {
self.write_barrier(crate::Barrier::WORK_GROUP, level)?;
self.write_barrier(
crate::Barrier::WORK_GROUP,
level,
context.expression.lang_version,
)?;
write!(self.out, "{level}")?;
let name = self.namer.call("");
@@ -4077,7 +4092,11 @@ impl<W: Write> Writer<W> {
self.named_expressions.insert(result, name);
writeln!(self.out, ";")?;
self.write_barrier(crate::Barrier::WORK_GROUP, level)?;
self.write_barrier(
crate::Barrier::WORK_GROUP,
level,
context.expression.lang_version,
)?;
}
crate::Statement::RayQuery { query, ref fun } => {
if context.expression.lang_version < (2, 4) {
@@ -4459,6 +4478,10 @@ impl<W: Write> Writer<W> {
// Work around Metal bug where `uint` is not available by default
writeln!(self.out, "using {NAMESPACE}::uint;")?;
if module.uses_mesh_shaders() && options.lang_version < (3, 0) {
return Err(Error::UnsupportedMeshShader);
}
let mut uses_ray_query = false;
for (_, ty) in module.types.iter() {
match ty.inner {
@@ -6943,24 +6966,29 @@ template <typename A>
let (em_str, in_mode, out_mode, can_vertex_pull) = match ep.stage {
crate::ShaderStage::Vertex => (
"vertex",
Some("vertex"),
LocationMode::VertexInput,
LocationMode::VertexOutput,
true,
),
crate::ShaderStage::Fragment => (
"fragment",
Some("fragment"),
LocationMode::FragmentInput,
LocationMode::FragmentOutput,
false,
),
crate::ShaderStage::Compute => (
"kernel",
Some("kernel"),
LocationMode::Uniform,
LocationMode::Uniform,
false,
),
crate::ShaderStage::Task | crate::ShaderStage::Mesh => unimplemented!(),
crate::ShaderStage::Task => {
(None, LocationMode::Uniform, LocationMode::Uniform, false)
}
crate::ShaderStage::Mesh => {
(None, LocationMode::Uniform, LocationMode::MeshOutput, false)
}
crate::ShaderStage::RayGeneration
| crate::ShaderStage::AnyHit
| crate::ShaderStage::ClosestHit
@@ -7031,12 +7059,10 @@ template <typename A>
break;
}
}
crate::AddressSpace::TaskPayload => {
unimplemented!()
}
crate::AddressSpace::Function
| crate::AddressSpace::Private
| crate::AddressSpace::WorkGroup => {}
| crate::AddressSpace::WorkGroup
| crate::AddressSpace::TaskPayload => {}
crate::AddressSpace::RayPayload
| crate::AddressSpace::IncomingRayPayload => unimplemented!(),
}
@@ -7052,7 +7078,7 @@ template <typename A>
info.entry_point_names.push(Err(err));
continue;
}
let fun_name = &self.names[&NameKey::EntryPoint(ep_index as _)];
let fun_name = self.names[&NameKey::EntryPoint(ep_index as _)].clone();
info.entry_point_names.push(Ok(fun_name.clone()));
writeln!(self.out)?;
@@ -7184,7 +7210,7 @@ template <typename A>
let stage_out_name = self.namer.call(&format!("{fun_name}Output"));
let result_member_name = self.namer.call("member");
let result_type_name = match fun.result {
Some(ref result) => {
Some(ref result) if ep.stage != crate::ShaderStage::Task => {
let mut result_members = Vec::new();
if let crate::TypeInner::Struct { ref members, .. } =
module.types[result.ty].inner
@@ -7255,7 +7281,30 @@ template <typename A>
writeln!(self.out, "}};")?;
&stage_out_name
}
None => "void",
Some(ref result) if ep.stage == crate::ShaderStage::Task => {
assert_eq!(
module.types[result.ty].inner,
crate::TypeInner::Vector {
size: crate::VectorSize::Tri,
scalar: crate::Scalar::U32
}
);
"metal::uint3"
}
_ => "void",
};
let out_mesh_info = if let Some(ref mesh_info) = ep.mesh_info {
Some(self.write_mesh_output_types(
mesh_info,
&fun_name,
module,
pipeline_options.allow_and_force_point_size,
options,
)?)
} else {
None
};
// If we're doing a vertex pulling transform, define the buffer
@@ -7275,6 +7324,17 @@ template <typename A>
}
}
let is_wrapped = matches!(
ep.stage,
crate::ShaderStage::Task | crate::ShaderStage::Mesh
);
let fun_name = fun_name.clone();
let nested_fun_name = if is_wrapped {
self.namer.call(&format!("_{fun_name}"))
} else {
fun_name.clone()
};
// https://web.archive.org/web/20181029003926/https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
if ep.stage == crate::ShaderStage::Compute && options.lang_version >= (2, 1) {
let total_threads =
@@ -7284,30 +7344,27 @@ template <typename A>
"[[max_total_threads_per_threadgroup({total_threads})]] "
)?;
}
// Write the entry point function's name, and begin its argument list.
writeln!(self.out, "{em_str} {result_type_name} {fun_name}(")?;
let mut is_first_argument = true;
let mut separator = || {
if is_first_argument {
is_first_argument = false;
' '
} else {
','
}
};
// Write the entry point function's name, and begin its argument list.
if let Some(em_str) = em_str {
write!(self.out, "{em_str} ")?;
}
writeln!(self.out, "{result_type_name} {nested_fun_name}(")?;
let mut args = Vec::new();
// If we have produced a struct holding the `EntryPoint`'s
// `Function`'s arguments' varyings, pass that struct first.
if has_varyings {
writeln!(
self.out,
"{} {stage_in_name} {varyings_member_name} [[stage_in]]",
separator()
)?;
args.push(EntryPointArgument {
ty_name: stage_in_name,
name: varyings_member_name.clone(),
binding: " [[stage_in]]".to_string(),
init: None,
});
}
let mut local_invocation_id = None;
let mut local_invocation_index = None;
// Then pass the remaining arguments not included in the varyings
// struct.
@@ -7322,8 +7379,8 @@ template <typename A>
_ => &self.names[name_key],
};
if binding == &crate::Binding::BuiltIn(crate::BuiltIn::LocalInvocationId) {
local_invocation_id = Some(name_key);
if binding == &crate::Binding::BuiltIn(crate::BuiltIn::LocalInvocationIndex) {
local_invocation_index = Some(name_key);
}
let ty_name = TypeContext {
@@ -7345,19 +7402,31 @@ template <typename A>
};
let resolved = options.resolve_local_binding(binding, in_mode)?;
write!(self.out, "{} {ty_name} {name}", separator())?;
resolved.try_fmt(&mut self.out)?;
writeln!(self.out)?;
let mut binding = String::new();
resolved.try_fmt(&mut binding)?;
args.push(EntryPointArgument {
ty_name: format!("{ty_name}"),
name: name.clone(),
binding,
init: None,
});
}
let need_workgroup_variables_initialization =
self.need_workgroup_variables_initialization(options, ep, module, fun_info);
if need_workgroup_variables_initialization && local_invocation_id.is_none() {
writeln!(
self.out,
"{} {NAMESPACE}::uint3 __local_invocation_id [[thread_position_in_threadgroup]]", separator()
)?;
if local_invocation_index.is_none()
&& (need_workgroup_variables_initialization
|| ep.stage == crate::ShaderStage::Task
|| ep.stage == crate::ShaderStage::Mesh)
{
args.push(EntryPointArgument {
ty_name: "uint".to_string(),
name: "__local_invocation_index".to_string(),
binding: " [[thread_index_in_threadgroup]]".to_string(),
init: None,
});
}
// Those global variables used by this entry point and its callees
@@ -7494,6 +7563,7 @@ template <typename A>
let resolved = match var.space {
crate::AddressSpace::Immediate => options.resolve_immediates(ep).ok(),
crate::AddressSpace::WorkGroup => None,
crate::AddressSpace::TaskPayload => Some(back::msl::ResolvedBinding::Payload),
_ => options
.resolve_resource_binding(ep, var.binding.as_ref().unwrap())
.ok(),
@@ -7521,20 +7591,25 @@ template <typename A>
};
for i in 0..3 {
write!(self.out, "{} ", separator())?;
let plane_name = &self.names[&NameKey::ExternalTextureGlobalVariable(
handle,
ExternalTextureNameKey::Plane(i),
)];
write!(
self.out,
"{NAMESPACE}::texture2d<float, {NAMESPACE}::access::sample> {plane_name}"
)?;
if let Some(ref target) = target {
write!(self.out, " [[texture({})]]", target.planes[i])?;
}
writeln!(self.out)?;
let ty_name = format!(
"{NAMESPACE}::texture2d<float, {NAMESPACE}::access::sample>"
);
let name = plane_name.clone();
let binding = if let Some(ref target) = target {
format!(" [[texture({})]]", target.planes[i])
} else {
String::new()
};
args.push(EntryPointArgument {
ty_name,
name,
binding,
init: None,
});
}
let params_ty_name = &self.names
[&NameKey::Type(module.special_types.external_texture_params.unwrap())];
@@ -7542,13 +7617,25 @@ template <typename A>
handle,
ExternalTextureNameKey::Params,
)];
write!(self.out, "{} ", separator())?;
write!(self.out, "constant {params_ty_name}& {params_name}")?;
if let Some(ref target) = target {
write!(self.out, " [[buffer({})]]", target.params)?;
}
let binding = if let Some(ref target) = target {
format!(" [[buffer({})]]", target.params)
} else {
String::new()
};
args.push(EntryPointArgument {
ty_name: format!("constant {params_ty_name}&"),
name: params_name.clone(),
binding,
init: None,
});
}
_ => {
if var.space == crate::AddressSpace::WorkGroup
&& ep.stage == crate::ShaderStage::Mesh
{
continue;
}
let tyvar = TypedGlobalVariable {
module,
names: &self.names,
@@ -7556,33 +7643,39 @@ template <typename A>
usage,
reference: true,
};
write!(self.out, "{} ", separator())?;
tyvar.try_fmt(&mut self.out)?;
let parts = tyvar.to_parts()?;
let mut binding = String::new();
if let Some(resolved) = resolved {
resolved.try_fmt(&mut self.out)?;
}
if let Some(value) = var.init {
write!(self.out, " = ")?;
self.put_const_expression(
value,
module,
mod_info,
&module.global_expressions,
)?;
resolved.try_fmt(&mut binding)?;
}
args.push(EntryPointArgument {
ty_name: parts.ty_name,
name: parts.var_name,
binding,
init: var.init,
});
}
}
writeln!(self.out)?;
}
if do_vertex_pulling {
if needs_vertex_id && v_existing_id.is_none() {
// Write the [[vertex_id]] argument.
writeln!(self.out, "{} uint {v_id} [[vertex_id]]", separator())?;
args.push(EntryPointArgument {
ty_name: "uint".to_string(),
name: v_id.clone(),
binding: " [[vertex_id]]".to_string(),
init: None,
});
}
if needs_instance_id && i_existing_id.is_none() {
writeln!(self.out, "{} uint {i_id} [[instance_id]]", separator())?;
args.push(EntryPointArgument {
ty_name: "uint".to_string(),
name: i_id.clone(),
binding: " [[instance_id]]".to_string(),
init: None,
});
}
// Iterate vbm_resolved, output one argument for every vertex buffer,
@@ -7591,11 +7684,12 @@ template <typename A>
let id = &vbm.id;
let ty_name = &vbm.ty_name;
let param_name = &vbm.param_name;
writeln!(
self.out,
"{} const device {ty_name}* {param_name} [[buffer({id})]]",
separator()
)?;
args.push(EntryPointArgument {
ty_name: format!("const device {ty_name}*"),
name: param_name.clone(),
binding: format!(" [[buffer({id})]]"),
init: None,
});
}
}
@@ -7604,14 +7698,63 @@ template <typename A>
if needs_buffer_sizes {
// this is checked earlier
let resolved = options.resolve_sizes_buffer(ep).unwrap();
write!(
self.out,
"{} constant _mslBufferSizes& _buffer_sizes",
separator()
)?;
resolved.try_fmt(&mut self.out)?;
let mut binding = String::new();
resolved.try_fmt(&mut binding)?;
args.push(EntryPointArgument {
ty_name: "constant _mslBufferSizes&".to_string(),
name: "_buffer_sizes".to_string(),
binding,
init: None,
});
}
let mut is_first_arg = true;
for arg in &args {
if is_first_arg {
write!(self.out, " ")?;
} else {
write!(self.out, ", ")?;
}
is_first_arg = false;
write!(self.out, "{} {}", arg.ty_name, arg.name)?;
if !is_wrapped {
write!(self.out, "{}", arg.binding)?;
if let Some(init) = arg.init {
write!(self.out, " = ")?;
self.put_const_expression(
init,
module,
mod_info,
&module.global_expressions,
)?;
}
}
writeln!(self.out)?;
}
if ep.stage == crate::ShaderStage::Mesh {
for (handle, var) in module.global_variables.iter() {
if var.space != crate::AddressSpace::WorkGroup || fun_info[handle].is_empty() {
continue;
}
if is_first_arg {
write!(self.out, " ")?;
} else {
write!(self.out, ", ")?;
}
let ty_context = TypeContext {
handle: module.global_variables[handle].ty,
gctx: module.to_ctx(),
names: &self.names,
access: crate::StorageAccess::empty(),
first_time: false,
};
writeln!(
self.out,
"threadgroup {ty_context}& {}",
self.names[&NameKey::GlobalVariable(handle)]
)?;
}
}
// end of the entry point argument list
writeln!(self.out, ") {{")?;
@@ -7782,15 +7925,6 @@ template <typename A>
}
}
if need_workgroup_variables_initialization {
self.write_workgroup_variables_initialization(
module,
mod_info,
fun_info,
local_invocation_id,
)?;
}
// Metal doesn't support private mutable variables outside of functions,
// so we put them here, just like the locals.
for (handle, var) in module.global_variables.iter() {
@@ -7869,6 +8003,17 @@ template <typename A>
}
}
if need_workgroup_variables_initialization {
self.write_workgroup_variables_initialization(
module,
mod_info,
fun_info,
local_invocation_index,
ep.stage,
options.lang_version,
)?;
}
// Now take the arguments that we gathered into structs, and the
// structs that we flattened into arguments, and emit local
// variables with initializers that put everything back the way the
@@ -7984,7 +8129,11 @@ template <typename A>
pipeline_options,
force_loop_bounding: options.force_loop_bounding,
},
result_struct: Some(&stage_out_name),
result_struct: if ep.stage == crate::ShaderStage::Task {
None
} else {
Some(&stage_out_name)
},
};
// Finally, declare all the local variables that we need
@@ -7997,12 +8146,32 @@ template <typename A>
writeln!(self.out)?;
}
self.named_expressions.clear();
if is_wrapped {
self.write_wrapper_function(NestedFunctionInfo {
options,
ep,
module,
mod_info,
fun_info,
args,
local_invocation_index,
nested_name: &nested_fun_name,
outer_name: &fun_name,
out_mesh_info,
})?;
}
}
Ok(info)
}
fn write_barrier(&mut self, flags: crate::Barrier, level: back::Level) -> BackendResult {
pub(super) fn write_barrier(
&mut self,
flags: crate::Barrier,
level: back::Level,
lang_version: (u8, u8),
) -> BackendResult {
// Note: OR-ring bitflags requires `__HAVE_MEMFLAG_OPERATORS__`,
// so we try to avoid it here.
if flags.is_empty() {
@@ -8022,6 +8191,12 @@ template <typename A>
self.out,
"{level}{NAMESPACE}::threadgroup_barrier({NAMESPACE}::mem_flags::mem_threadgroup);",
)?;
if lang_version >= (3, 0) {
writeln!(
self.out,
"{level}{NAMESPACE}::threadgroup_barrier({NAMESPACE}::mem_flags::mem_object_data);",
)?;
}
}
if flags.contains(crate::Barrier::SUB_GROUP) {
writeln!(
@@ -8120,37 +8295,43 @@ mod workgroup_mem_init {
module: &crate::Module,
fun_info: &valid::FunctionInfo,
) -> bool {
let is_task = ep.stage == crate::ShaderStage::Task;
options.zero_initialize_workgroup_memory
&& ep.stage.compute_like()
&& module.global_variables.iter().any(|(handle, var)| {
!fun_info[handle].is_empty() && var.space == crate::AddressSpace::WorkGroup
let is_right_address_space = var.space == crate::AddressSpace::WorkGroup
|| (var.space == crate::AddressSpace::TaskPayload && is_task);
!fun_info[handle].is_empty() && is_right_address_space
})
}
pub(super) fn write_workgroup_variables_initialization(
pub fn write_workgroup_variables_initialization(
&mut self,
module: &crate::Module,
module_info: &valid::ModuleInfo,
fun_info: &valid::FunctionInfo,
local_invocation_id: Option<&NameKey>,
local_invocation_index: Option<&NameKey>,
stage: crate::ShaderStage,
lang_version: (u8, u8),
) -> BackendResult {
let level = back::Level(1);
writeln!(
self.out,
"{}if ({}::all({} == {}::uint3(0u))) {{",
"{}if ({} == 0u) {{",
level,
NAMESPACE,
local_invocation_id
local_invocation_index
.map(|name_key| self.names[name_key].as_str())
.unwrap_or("__local_invocation_id"),
NAMESPACE,
.unwrap_or("__local_invocation_index"),
)?;
let mut access_stack = AccessStack::new();
let is_task = stage == crate::ShaderStage::Task;
let vars = module.global_variables.iter().filter(|&(handle, var)| {
!fun_info[handle].is_empty() && var.space == crate::AddressSpace::WorkGroup
let is_right_address_space = var.space == crate::AddressSpace::WorkGroup
|| (var.space == crate::AddressSpace::TaskPayload && is_task);
!fun_info[handle].is_empty() && is_right_address_space
});
for (handle, var) in vars {
@@ -8166,7 +8347,7 @@ mod workgroup_mem_init {
}
writeln!(self.out, "{level}}}")?;
self.write_barrier(crate::Barrier::WORK_GROUP, level)
self.write_barrier(crate::Barrier::WORK_GROUP, level, lang_version)
}
fn write_workgroup_variable_initialization(
+1 -1
View File
@@ -1579,7 +1579,7 @@ bitflags::bitflags! {
pub struct Barrier: u32 {
/// Barrier affects all [`AddressSpace::Storage`] accesses.
const STORAGE = 1 << 0;
/// Barrier affects all [`AddressSpace::WorkGroup`] accesses.
/// Barrier affects all [`AddressSpace::WorkGroup`] and [`AddressSpace::TaskPayload`] accesses.
const WORK_GROUP = 1 << 1;
/// Barrier synchronizes execution across all invocations within a subgroup that execute this instruction.
const SUB_GROUP = 1 << 2;
+4 -1
View File
@@ -1,9 +1,12 @@
capabilities = "MESH_SHADER"
targets = "WGSL | SPIRV | HLSL"
targets = "WGSL | SPIRV | HLSL | METAL"
[spv]
version = [1, 4]
capabilities = ["MeshShadingEXT"]
[msl]
lang_version = [3, 0]
[hlsl]
shader_model = "V6_5"
+4 -1
View File
@@ -1,9 +1,12 @@
capabilities = "MESH_SHADER"
targets = "WGSL | SPIRV | HLSL"
targets = "WGSL | SPIRV | HLSL | METAL"
[spv]
version = [1, 4]
capabilities = ["MeshShadingEXT"]
[msl]
lang_version = [3, 0]
[hlsl]
shader_model = "V6_5"
+4 -1
View File
@@ -1,6 +1,9 @@
capabilities = "MESH_SHADER | MESH_SHADER_POINT_TOPOLOGY"
targets = "WGSL | SPIRV"
targets = "WGSL | SPIRV | METAL"
[spv]
version = [1, 4]
capabilities = ["MeshShadingEXT"]
[msl]
lang_version = [3, 0]
+4 -1
View File
@@ -1,9 +1,12 @@
capabilities = "MESH_SHADER"
targets = "WGSL | SPIRV | HLSL"
targets = "WGSL | SPIRV | HLSL | METAL"
[spv]
version = [1, 4]
capabilities = ["MeshShadingEXT"]
[msl]
lang_version = [3, 0]
[hlsl]
shader_model = "V6_5"
+5 -3
View File
@@ -131,8 +131,8 @@ Note: this is an issue with snapshot configuration, not code. If you added a new
&info,
&params.msl,
&params.msl_pipeline,
params.bounds_check_policies,
&params.pipeline_constants,
&shared_info,
);
}
@@ -267,8 +267,8 @@ fn write_output_msl(
info: &naga::valid::ModuleInfo,
options: &naga::back::msl::Options,
pipeline_options: &naga::back::msl::PipelineOptions,
bounds_check_policies: naga::proc::BoundsCheckPolicies,
pipeline_constants: &naga::back::PipelineConstants,
shared_options: &WriterSharedOptions,
) {
use naga::back::msl;
@@ -279,7 +279,9 @@ fn write_output_msl(
.expect("override evaluation failed");
let mut options = options.clone();
options.bounds_check_policies = bounds_check_policies;
options.bounds_check_policies = shared_options.bounds_checks_policies;
options.mesh_shader_primitive_indices_clamp = shared_options.mesh_output_validation;
options.task_dispatch_limits = shared_options.task_limits;
let (string, tr_info) = msl::write_string(&module, &info, &options, pipeline_options)
.unwrap_or_else(|err| panic!("Metal write failed: {err}"));
@@ -16,7 +16,7 @@ kernel void compute1_(
, uint local_invocation_index [[thread_index_in_threadgroup]]
, threadgroup uint& wg_var
) {
if (metal::all(local_invocation_id == metal::uint3(0u))) {
if (local_invocation_index == 0u) {
wg_var = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
@@ -107,10 +107,10 @@ void wgpu_4435_(
}
kernel void main_(
metal::uint3 __local_invocation_id [[thread_position_in_threadgroup]]
uint __local_invocation_index [[thread_index_in_threadgroup]]
, threadgroup type_3& a
) {
if (metal::all(__local_invocation_id == metal::uint3(0u))) {
if (__local_invocation_index == 0u) {
a = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
@@ -25,16 +25,19 @@ struct cs_mainInput {
metal::atomic_store_explicit(&storage_struct.atomic_scalar, 1.5, metal::memory_order_relaxed);
metal::atomic_store_explicit(&storage_struct.atomic_arr.inner[1], 1.5, metal::memory_order_relaxed);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
float l0_ = metal::atomic_load_explicit(&storage_atomic_scalar, metal::memory_order_relaxed);
float l1_ = metal::atomic_load_explicit(&storage_atomic_arr.inner[1], metal::memory_order_relaxed);
float l2_ = metal::atomic_load_explicit(&storage_struct.atomic_scalar, metal::memory_order_relaxed);
float l3_ = metal::atomic_load_explicit(&storage_struct.atomic_arr.inner[1], metal::memory_order_relaxed);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
float _e27 = metal::atomic_fetch_add_explicit(&storage_atomic_scalar, 1.5, metal::memory_order_relaxed);
float _e31 = metal::atomic_fetch_add_explicit(&storage_atomic_arr.inner[1], 1.5, metal::memory_order_relaxed);
float _e35 = metal::atomic_fetch_add_explicit(&storage_struct.atomic_scalar, 1.5, metal::memory_order_relaxed);
float _e40 = metal::atomic_fetch_add_explicit(&storage_struct.atomic_arr.inner[1], 1.5, metal::memory_order_relaxed);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
float _e43 = metal::atomic_exchange_explicit(&storage_atomic_scalar, 1.5, metal::memory_order_relaxed);
float _e47 = metal::atomic_exchange_explicit(&storage_atomic_arr.inner[1], 1.5, metal::memory_order_relaxed);
float _e51 = metal::atomic_exchange_explicit(&storage_struct.atomic_scalar, 1.5, metal::memory_order_relaxed);
+2 -1
View File
@@ -76,6 +76,7 @@ struct cs_mainInput {
};
kernel void cs_main(
metal::uint3 id [[thread_position_in_threadgroup]]
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, device metal::atomic_uint& storage_atomic_scalar [[user(fake0)]]
, device type_4& storage_atomic_arr [[user(fake0)]]
, device Struct& storage_struct [[user(fake0)]]
@@ -83,7 +84,7 @@ kernel void cs_main(
, threadgroup type_4& workgroup_atomic_arr
, threadgroup Struct& workgroup_struct
) {
if (metal::all(id == metal::uint3(0u))) {
if (__local_invocation_index == 0u) {
metal::atomic_store_explicit(&workgroup_atomic_scalar, 0, metal::memory_order_relaxed);
for (int __i0 = 0; __i0 < 2; __i0++) {
metal::atomic_store_explicit(&workgroup_atomic_arr.inner[__i0], 0, metal::memory_order_relaxed);
@@ -14,6 +14,7 @@ struct cs_mainInput {
image.atomic_max(metal::uint2(metal::int2(0, 0)), 1uL);
if (metal::int2(0, 0).x == -99999) { image.write(ulong4(0uL), metal::uint2(metal::int2(0, 0))); }
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
image.atomic_min(metal::uint2(metal::int2(0, 0)), 1uL);
if (metal::int2(0, 0).x == -99999) { image.write(ulong4(0uL), metal::uint2(metal::int2(0, 0))); }
return;
+2 -2
View File
@@ -60,7 +60,7 @@ void test_msl_packed_vec3_(
}
kernel void main_(
metal::uint3 __local_invocation_id [[thread_position_in_threadgroup]]
uint __local_invocation_index [[thread_index_in_threadgroup]]
, threadgroup type_2& wg
, threadgroup metal::atomic_uint& at_1
, device FooStruct& alignment [[user(fake0)]]
@@ -72,7 +72,7 @@ kernel void main_(
, constant type_15& global_nested_arrays_of_matrices_4x2_ [[user(fake0)]]
, constant _mslBufferSizes& _buffer_sizes [[user(fake0)]]
) {
if (metal::all(__local_invocation_id == metal::uint3(0u))) {
if (__local_invocation_index == 0u) {
wg = {};
metal::atomic_store_explicit(&at_1, 0, metal::memory_order_relaxed);
}
+1 -1
View File
@@ -77,7 +77,7 @@ struct computeInput {
, metal::uint3 num_wgs [[threadgroups_per_grid]]
, threadgroup type_4& output
) {
if (metal::all(local_id == metal::uint3(0u))) {
if (local_index == 0u) {
output = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
@@ -0,0 +1,107 @@
// language: metal3.0
#include <metal_stdlib>
#include <simd/simd.h>
using metal::uint;
struct TaskPayload {
uint dummy;
};
struct VertexOutput {
metal::float4 position;
};
struct PrimitiveOutput {
metal::uint3 indices;
};
struct type_3 {
VertexOutput inner[3];
};
struct type_4 {
PrimitiveOutput inner[1];
};
struct MeshOutput {
type_3 vertices;
type_4 primitives;
uint vertex_count;
uint primitive_count;
char _pad4[8];
};
metal::uint3 _ts_main(
uint __local_invocation_index
, object_data TaskPayload& taskPayload
) {
if (__local_invocation_index == 0u) {
taskPayload = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
return metal::uint3(1u, 1u, 1u);
}
[[object]] void ts_main(
metal::mesh_grid_properties nagaMeshGrid
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload& taskPayload [[payload]]
) {
uint3 nagaGridSize = _ts_main(__local_invocation_index, taskPayload);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
if (__local_invocation_index == 0u) {
if (
nagaGridSize.x > 256u ||
nagaGridSize.y > 256u ||
nagaGridSize.z > 256u ||
metal::mulhi(nagaGridSize.x, nagaGridSize.y) != 0u ||
metal::mulhi(nagaGridSize.x * nagaGridSize.y, nagaGridSize.z) != 0u ||
(nagaGridSize.x * nagaGridSize.y * nagaGridSize.z) > 1024u
) {
nagaGridSize = metal::uint3(0u);
}
nagaMeshGrid.set_threadgroups_per_grid(nagaGridSize);
}
return;
}
struct ms_mainVertexOutput {
metal::float4 position [[position]];
};
struct ms_mainPrimitiveOutput {
};
void _ms_main(
uint __local_invocation_index
, object_data TaskPayload const& taskPayload
, threadgroup MeshOutput& mesh_output
) {
if (__local_invocation_index == 0u) {
mesh_output = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
return;
}
[[mesh]] void ms_main(
metal::mesh<ms_mainVertexOutput, ms_mainPrimitiveOutput, 3, 1, metal::topology::triangle> meshOutput
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload const& taskPayload [[payload]]
) {
threadgroup MeshOutput mesh_output;
_ms_main(__local_invocation_index, taskPayload, mesh_output);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
for(uint vertexIndex = __local_invocation_index; vertexIndex < metal::min(mesh_output.vertex_count, 3u); vertexIndex += 64) {
ms_mainVertexOutput vertex_;
vertex_.position = mesh_output.vertices.inner[vertexIndex].position;
meshOutput.set_vertex(vertexIndex, vertex_);
}
for(uint primitiveIndex = __local_invocation_index; primitiveIndex < metal::min(mesh_output.primitive_count, 1u); primitiveIndex += 64) {
ms_mainPrimitiveOutput primitive;
meshOutput.set_index(primitiveIndex * 3 + 0, mesh_output.primitives.inner[primitiveIndex].indices.x);
meshOutput.set_index(primitiveIndex * 3 + 1, mesh_output.primitives.inner[primitiveIndex].indices.y);
meshOutput.set_index(primitiveIndex * 3 + 2, mesh_output.primitives.inner[primitiveIndex].indices.z);
meshOutput.set_primitive(primitiveIndex, primitive);
}
if (__local_invocation_index == 0u) {
meshOutput.set_primitive_count(metal::min(mesh_output.primitive_count, 1u));
}
}
@@ -0,0 +1,105 @@
// language: metal3.0
#include <metal_stdlib>
#include <simd/simd.h>
using metal::uint;
struct TaskPayload {
uint dummy;
};
struct VertexOutput {
metal::float4 position;
};
struct PrimitiveOutput {
metal::uint2 indices;
};
struct type_4 {
VertexOutput inner[2];
};
struct type_5 {
PrimitiveOutput inner[1];
};
struct MeshOutput {
type_4 vertices;
type_5 primitives;
uint vertex_count;
uint primitive_count;
};
metal::uint3 _ts_main(
uint __local_invocation_index
, object_data TaskPayload& taskPayload
) {
if (__local_invocation_index == 0u) {
taskPayload = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
return metal::uint3(1u, 1u, 1u);
}
[[object]] void ts_main(
metal::mesh_grid_properties nagaMeshGrid
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload& taskPayload [[payload]]
) {
uint3 nagaGridSize = _ts_main(__local_invocation_index, taskPayload);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
if (__local_invocation_index == 0u) {
if (
nagaGridSize.x > 256u ||
nagaGridSize.y > 256u ||
nagaGridSize.z > 256u ||
metal::mulhi(nagaGridSize.x, nagaGridSize.y) != 0u ||
metal::mulhi(nagaGridSize.x * nagaGridSize.y, nagaGridSize.z) != 0u ||
(nagaGridSize.x * nagaGridSize.y * nagaGridSize.z) > 1024u
) {
nagaGridSize = metal::uint3(0u);
}
nagaMeshGrid.set_threadgroups_per_grid(nagaGridSize);
}
return;
}
struct ms_mainVertexOutput {
metal::float4 position [[position]];
};
struct ms_mainPrimitiveOutput {
};
void _ms_main(
uint __local_invocation_index
, object_data TaskPayload const& taskPayload
, threadgroup MeshOutput& mesh_output
) {
if (__local_invocation_index == 0u) {
mesh_output = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
return;
}
[[mesh]] void ms_main(
metal::mesh<ms_mainVertexOutput, ms_mainPrimitiveOutput, 2, 1, metal::topology::line> meshOutput
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload const& taskPayload [[payload]]
) {
threadgroup MeshOutput mesh_output;
_ms_main(__local_invocation_index, taskPayload, mesh_output);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
for(uint vertexIndex = __local_invocation_index; vertexIndex < metal::min(mesh_output.vertex_count, 2u); vertexIndex += 64) {
ms_mainVertexOutput vertex_;
vertex_.position = mesh_output.vertices.inner[vertexIndex].position;
meshOutput.set_vertex(vertexIndex, vertex_);
}
for(uint primitiveIndex = __local_invocation_index; primitiveIndex < metal::min(mesh_output.primitive_count, 1u); primitiveIndex += 64) {
ms_mainPrimitiveOutput primitive;
meshOutput.set_index(primitiveIndex * 2 + 0, mesh_output.primitives.inner[primitiveIndex].indices.x);
meshOutput.set_index(primitiveIndex * 2 + 1, mesh_output.primitives.inner[primitiveIndex].indices.y);
meshOutput.set_primitive(primitiveIndex, primitive);
}
if (__local_invocation_index == 0u) {
meshOutput.set_primitive_count(metal::min(mesh_output.primitive_count, 1u));
}
}
@@ -0,0 +1,105 @@
// language: metal3.0
#include <metal_stdlib>
#include <simd/simd.h>
using metal::uint;
struct TaskPayload {
uint dummy;
};
struct VertexOutput {
metal::float4 position;
};
struct PrimitiveOutput {
uint indices;
};
struct type_3 {
VertexOutput inner[1];
};
struct type_4 {
PrimitiveOutput inner[1];
};
struct MeshOutput {
type_3 vertices;
type_4 primitives;
uint vertex_count;
uint primitive_count;
char _pad4[4];
};
metal::uint3 _ts_main(
uint __local_invocation_index
, object_data TaskPayload& taskPayload
) {
if (__local_invocation_index == 0u) {
taskPayload = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
return metal::uint3(1u, 1u, 1u);
}
[[object]] void ts_main(
metal::mesh_grid_properties nagaMeshGrid
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload& taskPayload [[payload]]
) {
uint3 nagaGridSize = _ts_main(__local_invocation_index, taskPayload);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
if (__local_invocation_index == 0u) {
if (
nagaGridSize.x > 256u ||
nagaGridSize.y > 256u ||
nagaGridSize.z > 256u ||
metal::mulhi(nagaGridSize.x, nagaGridSize.y) != 0u ||
metal::mulhi(nagaGridSize.x * nagaGridSize.y, nagaGridSize.z) != 0u ||
(nagaGridSize.x * nagaGridSize.y * nagaGridSize.z) > 1024u
) {
nagaGridSize = metal::uint3(0u);
}
nagaMeshGrid.set_threadgroups_per_grid(nagaGridSize);
}
return;
}
struct ms_mainVertexOutput {
metal::float4 position [[position]];
};
struct ms_mainPrimitiveOutput {
};
void _ms_main(
uint __local_invocation_index
, object_data TaskPayload const& taskPayload
, threadgroup MeshOutput& mesh_output
) {
if (__local_invocation_index == 0u) {
mesh_output = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
return;
}
[[mesh]] void ms_main(
metal::mesh<ms_mainVertexOutput, ms_mainPrimitiveOutput, 1, 1, metal::topology::point> meshOutput
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload const& taskPayload [[payload]]
) {
threadgroup MeshOutput mesh_output;
_ms_main(__local_invocation_index, taskPayload, mesh_output);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
for(uint vertexIndex = __local_invocation_index; vertexIndex < metal::min(mesh_output.vertex_count, 1u); vertexIndex += 64) {
ms_mainVertexOutput vertex_;
vertex_.position = mesh_output.vertices.inner[vertexIndex].position;
meshOutput.set_vertex(vertexIndex, vertex_);
}
for(uint primitiveIndex = __local_invocation_index; primitiveIndex < metal::min(mesh_output.primitive_count, 1u); primitiveIndex += 64) {
ms_mainPrimitiveOutput primitive;
meshOutput.set_index(primitiveIndex * 1 + 0, mesh_output.primitives.inner[primitiveIndex].indices);
meshOutput.set_primitive(primitiveIndex, primitive);
}
if (__local_invocation_index == 0u) {
meshOutput.set_primitive_count(metal::min(mesh_output.primitive_count, 1u));
}
}
+360
View File
@@ -0,0 +1,360 @@
// language: metal3.0
#include <metal_stdlib>
#include <simd/simd.h>
using metal::uint;
struct TaskPayload {
metal::float4 colorMask;
bool visible;
char _pad2[15];
};
struct VertexOutput {
metal::float4 position;
metal::float4 color;
};
struct PrimitiveOutput {
metal::packed_uint3 indices;
bool cull;
char _pad2[3];
metal::float4 colorMask;
};
struct PrimitiveInput {
metal::float4 colorMask;
};
struct type_5 {
VertexOutput inner[3];
};
struct type_6 {
PrimitiveOutput inner[1];
};
struct MeshOutput {
type_5 vertices;
type_6 primitives;
uint vertex_count;
uint primitive_count;
char _pad4[8];
};
bool helper_reader(
object_data TaskPayload const& taskPayload
) {
bool _e2 = taskPayload.visible;
return _e2;
}
void helper_writer(
bool value,
object_data TaskPayload& taskPayload
) {
taskPayload.visible = value;
return;
}
metal::uint3 _ts_main(
uint __local_invocation_index
, object_data TaskPayload& taskPayload
, threadgroup float& workgroupData
) {
if (__local_invocation_index == 0u) {
taskPayload = {};
workgroupData = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
workgroupData = 1.0;
taskPayload.colorMask = metal::float4(1.0, 1.0, 0.0, 1.0);
helper_writer(true, taskPayload);
bool _e12 = helper_reader(taskPayload);
taskPayload.visible = _e12;
return metal::uint3(1u, 1u, 1u);
}
[[object]] void ts_main(
metal::mesh_grid_properties nagaMeshGrid
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload& taskPayload [[payload]]
, threadgroup float& workgroupData
) {
uint3 nagaGridSize = _ts_main(__local_invocation_index, taskPayload, workgroupData);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
if (__local_invocation_index == 0u) {
if (
nagaGridSize.x > 256u ||
nagaGridSize.y > 256u ||
nagaGridSize.z > 256u ||
metal::mulhi(nagaGridSize.x, nagaGridSize.y) != 0u ||
metal::mulhi(nagaGridSize.x * nagaGridSize.y, nagaGridSize.z) != 0u ||
(nagaGridSize.x * nagaGridSize.y * nagaGridSize.z) > 1024u
) {
nagaGridSize = metal::uint3(0u);
}
nagaMeshGrid.set_threadgroups_per_grid(nagaGridSize);
}
return;
}
struct ts_divergentInput {
};
metal::uint3 _ts_divergent(
metal::uint3 thread_id
, uint __local_invocation_index
, object_data TaskPayload& taskPayload
) {
if (__local_invocation_index == 0u) {
taskPayload = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
if (thread_id.x == 0u) {
taskPayload.colorMask = metal::float4(1.0, 1.0, 0.0, 1.0);
taskPayload.visible = true;
return metal::uint3(1u, 1u, 1u);
}
return metal::uint3(2u, 2u, 2u);
}
[[object]] void ts_divergent(
metal::mesh_grid_properties nagaMeshGrid_1
, metal::uint3 thread_id [[thread_position_in_threadgroup]]
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload& taskPayload [[payload]]
) {
uint3 nagaGridSize_1 = _ts_divergent(thread_id, __local_invocation_index, taskPayload);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
if (__local_invocation_index == 0u) {
if (
nagaGridSize_1.x > 256u ||
nagaGridSize_1.y > 256u ||
nagaGridSize_1.z > 256u ||
metal::mulhi(nagaGridSize_1.x, nagaGridSize_1.y) != 0u ||
metal::mulhi(nagaGridSize_1.x * nagaGridSize_1.y, nagaGridSize_1.z) != 0u ||
(nagaGridSize_1.x * nagaGridSize_1.y * nagaGridSize_1.z) > 1024u
) {
nagaGridSize_1 = metal::uint3(0u);
}
nagaMeshGrid_1.set_threadgroups_per_grid(nagaGridSize_1);
}
return;
}
struct ms_mainVertexOutput {
metal::float4 position [[position]];
metal::float4 color [[user(loc0), center_perspective]];
};
struct ms_mainPrimitiveOutput {
bool cull [[primitive_culled]];
metal::float4 colorMask [[user(loc1), flat]];
};
void _ms_main(
uint __local_invocation_index
, object_data TaskPayload const& taskPayload
, threadgroup float& workgroupData
, threadgroup MeshOutput& mesh_output
) {
if (__local_invocation_index == 0u) {
workgroupData = {};
mesh_output = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
mesh_output.vertex_count = 3u;
mesh_output.primitive_count = 1u;
workgroupData = 2.0;
mesh_output.vertices.inner[0].position = metal::float4(0.0, 1.0, 0.0, 1.0);
metal::float4 _e23 = taskPayload.colorMask;
mesh_output.vertices.inner[0].color = metal::float4(0.0, 1.0, 0.0, 1.0) * _e23;
mesh_output.vertices.inner[1].position = metal::float4(-1.0, -1.0, 0.0, 1.0);
metal::float4 _e45 = taskPayload.colorMask;
mesh_output.vertices.inner[1].color = metal::float4(0.0, 0.0, 1.0, 1.0) * _e45;
mesh_output.vertices.inner[2].position = metal::float4(1.0, -1.0, 0.0, 1.0);
metal::float4 _e67 = taskPayload.colorMask;
mesh_output.vertices.inner[2].color = metal::float4(1.0, 0.0, 0.0, 1.0) * _e67;
mesh_output.primitives.inner[0].indices = metal::uint3(0u, 1u, 2u);
bool _e86 = helper_reader(taskPayload);
mesh_output.primitives.inner[0].cull = !(_e86);
mesh_output.primitives.inner[0].colorMask = metal::float4(1.0, 0.0, 1.0, 1.0);
return;
}
[[mesh]] void ms_main(
metal::mesh<ms_mainVertexOutput, ms_mainPrimitiveOutput, 3, 1, metal::topology::triangle> meshOutput
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, object_data TaskPayload const& taskPayload [[payload]]
) {
threadgroup float workgroupData;
threadgroup MeshOutput mesh_output;
_ms_main(__local_invocation_index, taskPayload, workgroupData, mesh_output);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
for(uint vertexIndex = __local_invocation_index; vertexIndex < metal::min(mesh_output.vertex_count, 3u); vertexIndex += 1) {
ms_mainVertexOutput vertex_1;
vertex_1.position = mesh_output.vertices.inner[vertexIndex].position;
vertex_1.color = mesh_output.vertices.inner[vertexIndex].color;
meshOutput.set_vertex(vertexIndex, vertex_1);
}
for(uint primitiveIndex = __local_invocation_index; primitiveIndex < metal::min(mesh_output.primitive_count, 1u); primitiveIndex += 1) {
ms_mainPrimitiveOutput primitive_1;
meshOutput.set_index(primitiveIndex * 3 + 0, mesh_output.primitives.inner[primitiveIndex].indices.x);
meshOutput.set_index(primitiveIndex * 3 + 1, mesh_output.primitives.inner[primitiveIndex].indices.y);
meshOutput.set_index(primitiveIndex * 3 + 2, mesh_output.primitives.inner[primitiveIndex].indices.z);
primitive_1.cull = mesh_output.primitives.inner[primitiveIndex].cull;
primitive_1.colorMask = mesh_output.primitives.inner[primitiveIndex].colorMask;
meshOutput.set_primitive(primitiveIndex, primitive_1);
}
if (__local_invocation_index == 0u) {
meshOutput.set_primitive_count(metal::min(mesh_output.primitive_count, 1u));
}
}
struct ms_no_tsVertexOutput {
metal::float4 position [[position]];
metal::float4 color [[user(loc0), center_perspective]];
};
struct ms_no_tsPrimitiveOutput {
bool cull [[primitive_culled]];
metal::float4 colorMask [[user(loc1), flat]];
};
void _ms_no_ts(
uint __local_invocation_index
, threadgroup float& workgroupData
, threadgroup MeshOutput& mesh_output
) {
if (__local_invocation_index == 0u) {
workgroupData = {};
mesh_output = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
mesh_output.vertex_count = 3u;
mesh_output.primitive_count = 1u;
workgroupData = 2.0;
mesh_output.vertices.inner[0].position = metal::float4(0.0, 1.0, 0.0, 1.0);
mesh_output.vertices.inner[0].color = metal::float4(0.0, 1.0, 0.0, 1.0);
mesh_output.vertices.inner[1].position = metal::float4(-1.0, -1.0, 0.0, 1.0);
mesh_output.vertices.inner[1].color = metal::float4(0.0, 0.0, 1.0, 1.0);
mesh_output.vertices.inner[2].position = metal::float4(1.0, -1.0, 0.0, 1.0);
mesh_output.vertices.inner[2].color = metal::float4(1.0, 0.0, 0.0, 1.0);
mesh_output.primitives.inner[0].indices = metal::uint3(0u, 1u, 2u);
mesh_output.primitives.inner[0].cull = false;
mesh_output.primitives.inner[0].colorMask = metal::float4(1.0, 0.0, 1.0, 1.0);
return;
}
[[mesh]] void ms_no_ts(
metal::mesh<ms_no_tsVertexOutput, ms_no_tsPrimitiveOutput, 3, 1, metal::topology::triangle> meshOutput_1
, uint __local_invocation_index [[thread_index_in_threadgroup]]
) {
threadgroup float workgroupData;
threadgroup MeshOutput mesh_output;
_ms_no_ts(__local_invocation_index, workgroupData, mesh_output);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
for(uint vertexIndex_1 = __local_invocation_index; vertexIndex_1 < metal::min(mesh_output.vertex_count, 3u); vertexIndex_1 += 1) {
ms_no_tsVertexOutput vertex_2;
vertex_2.position = mesh_output.vertices.inner[vertexIndex_1].position;
vertex_2.color = mesh_output.vertices.inner[vertexIndex_1].color;
meshOutput_1.set_vertex(vertexIndex_1, vertex_2);
}
for(uint primitiveIndex_1 = __local_invocation_index; primitiveIndex_1 < metal::min(mesh_output.primitive_count, 1u); primitiveIndex_1 += 1) {
ms_no_tsPrimitiveOutput primitive_2;
meshOutput_1.set_index(primitiveIndex_1 * 3 + 0, mesh_output.primitives.inner[primitiveIndex_1].indices.x);
meshOutput_1.set_index(primitiveIndex_1 * 3 + 1, mesh_output.primitives.inner[primitiveIndex_1].indices.y);
meshOutput_1.set_index(primitiveIndex_1 * 3 + 2, mesh_output.primitives.inner[primitiveIndex_1].indices.z);
primitive_2.cull = mesh_output.primitives.inner[primitiveIndex_1].cull;
primitive_2.colorMask = mesh_output.primitives.inner[primitiveIndex_1].colorMask;
meshOutput_1.set_primitive(primitiveIndex_1, primitive_2);
}
if (__local_invocation_index == 0u) {
meshOutput_1.set_primitive_count(metal::min(mesh_output.primitive_count, 1u));
}
}
struct ms_divergentInput {
};
struct ms_divergentVertexOutput {
metal::float4 position [[position]];
metal::float4 color [[user(loc0), center_perspective]];
};
struct ms_divergentPrimitiveOutput {
bool cull [[primitive_culled]];
metal::float4 colorMask [[user(loc1), flat]];
};
void _ms_divergent(
metal::uint3 thread_id_1
, uint __local_invocation_index
, threadgroup float& workgroupData
, threadgroup MeshOutput& mesh_output
) {
if (__local_invocation_index == 0u) {
workgroupData = {};
mesh_output = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
if (thread_id_1.x == 0u) {
mesh_output.vertex_count = 3u;
mesh_output.primitive_count = 1u;
workgroupData = 2.0;
mesh_output.vertices.inner[0].position = metal::float4(0.0, 1.0, 0.0, 1.0);
mesh_output.vertices.inner[0].color = metal::float4(0.0, 1.0, 0.0, 1.0);
mesh_output.vertices.inner[1].position = metal::float4(-1.0, -1.0, 0.0, 1.0);
mesh_output.vertices.inner[1].color = metal::float4(0.0, 0.0, 1.0, 1.0);
mesh_output.vertices.inner[2].position = metal::float4(1.0, -1.0, 0.0, 1.0);
mesh_output.vertices.inner[2].color = metal::float4(1.0, 0.0, 0.0, 1.0);
mesh_output.primitives.inner[0].indices = metal::uint3(0u, 1u, 2u);
mesh_output.primitives.inner[0].cull = false;
mesh_output.primitives.inner[0].colorMask = metal::float4(1.0, 0.0, 1.0, 1.0);
return;
} else {
return;
}
}
[[mesh]] void ms_divergent(
metal::mesh<ms_divergentVertexOutput, ms_divergentPrimitiveOutput, 3, 1, metal::topology::triangle> meshOutput_2
, metal::uint3 thread_id_1 [[thread_position_in_threadgroup]]
, uint __local_invocation_index [[thread_index_in_threadgroup]]
) {
threadgroup float workgroupData;
threadgroup MeshOutput mesh_output;
_ms_divergent(thread_id_1, __local_invocation_index, workgroupData, mesh_output);
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
metal::threadgroup_barrier(metal::mem_flags::mem_object_data);
for(uint vertexIndex_2 = __local_invocation_index; vertexIndex_2 < metal::min(mesh_output.vertex_count, 3u); vertexIndex_2 += 2) {
ms_divergentVertexOutput vertex_3;
vertex_3.position = mesh_output.vertices.inner[vertexIndex_2].position;
vertex_3.color = mesh_output.vertices.inner[vertexIndex_2].color;
meshOutput_2.set_vertex(vertexIndex_2, vertex_3);
}
for(uint primitiveIndex_2 = __local_invocation_index; primitiveIndex_2 < metal::min(mesh_output.primitive_count, 1u); primitiveIndex_2 += 2) {
ms_divergentPrimitiveOutput primitive_3;
meshOutput_2.set_index(primitiveIndex_2 * 3 + 0, mesh_output.primitives.inner[primitiveIndex_2].indices.x);
meshOutput_2.set_index(primitiveIndex_2 * 3 + 1, mesh_output.primitives.inner[primitiveIndex_2].indices.y);
meshOutput_2.set_index(primitiveIndex_2 * 3 + 2, mesh_output.primitives.inner[primitiveIndex_2].indices.z);
primitive_3.cull = mesh_output.primitives.inner[primitiveIndex_2].cull;
primitive_3.colorMask = mesh_output.primitives.inner[primitiveIndex_2].colorMask;
meshOutput_2.set_primitive(primitiveIndex_2, primitive_3);
}
if (__local_invocation_index == 0u) {
meshOutput_2.set_primitive_count(metal::min(mesh_output.primitive_count, 1u));
}
}
struct fs_mainInput {
metal::float4 color [[user(loc0), center_perspective]];
metal::float4 colorMask [[user(loc1), flat]];
};
struct fs_mainOutput {
metal::float4 member_5 [[color(0)]];
};
fragment fs_mainOutput fs_main(
fs_mainInput varyings_5 [[stage_in]]
, metal::float4 position_3 [[position]]
) {
const VertexOutput vertex_ = { position_3, varyings_5.color };
const PrimitiveInput primitive = { varyings_5.colorMask };
return fs_mainOutput { vertex_.color * primitive.colorMask };
}
@@ -37,10 +37,10 @@ _atomic_compare_exchange_result_Uint_4_ naga_atomic_compare_exchange_weak_explic
constant int o = 2;
kernel void f(
metal::uint3 __local_invocation_id [[thread_position_in_threadgroup]]
uint __local_invocation_index [[thread_index_in_threadgroup]]
, threadgroup metal::atomic_uint& a
) {
if (metal::all(__local_invocation_id == metal::uint3(0u))) {
if (__local_invocation_index == 0u) {
metal::atomic_store_explicit(&a, 0, metal::memory_order_relaxed);
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
+3 -3
View File
@@ -53,17 +53,17 @@ metal::float4 mock_function(
}
kernel void main_(
metal::uint3 __local_invocation_id [[thread_position_in_threadgroup]]
uint __local_invocation_index [[thread_index_in_threadgroup]]
, device InStorage const& in_storage [[user(fake0)]]
, constant InUniform& in_uniform [[user(fake0)]]
, metal::texture2d_array<float, metal::access::sample> image_2d_array [[user(fake0)]]
, threadgroup type_5& in_workgroup
) {
if (metal::all(__local_invocation_id == metal::uint3(0u))) {
type_6 in_private = {};
if (__local_invocation_index == 0u) {
in_workgroup = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
type_6 in_private = {};
metal::float4 _e5 = mock_function(metal::int2(1, 2), 3, 4, in_storage, in_uniform, image_2d_array, in_workgroup, in_private);
return;
}
@@ -17,11 +17,12 @@ struct test_atomic_workgroup_uniform_loadInput {
kernel void test_atomic_workgroup_uniform_load(
metal::uint3 workgroup_id [[threadgroup_position_in_grid]]
, metal::uint3 local_id [[thread_position_in_threadgroup]]
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, threadgroup metal::atomic_uint& wg_scalar
, threadgroup metal::atomic_int& wg_signed
, threadgroup AtomicStruct& wg_struct
) {
if (metal::all(local_id == metal::uint3(0u))) {
if (__local_invocation_index == 0u) {
metal::atomic_store_explicit(&wg_scalar, 0, metal::memory_order_relaxed);
metal::atomic_store_explicit(&wg_signed, 0, metal::memory_order_relaxed);
metal::atomic_store_explicit(&wg_struct.atomic_scalar, 0, metal::memory_order_relaxed);
@@ -13,10 +13,10 @@ struct test_workgroupUniformLoadInput {
};
kernel void test_workgroupUniformLoad(
metal::uint3 workgroup_id [[threadgroup_position_in_grid]]
, metal::uint3 __local_invocation_id [[thread_position_in_threadgroup]]
, uint __local_invocation_index [[thread_index_in_threadgroup]]
, threadgroup type_2& arr_i32_
) {
if (metal::all(__local_invocation_id == metal::uint3(0u))) {
if (__local_invocation_index == 0u) {
arr_i32_ = {};
}
metal::threadgroup_barrier(metal::mem_flags::mem_threadgroup);
@@ -20,11 +20,11 @@ struct WStruct {
};
kernel void main_(
metal::uint3 __local_invocation_id [[thread_position_in_threadgroup]]
uint __local_invocation_index [[thread_index_in_threadgroup]]
, threadgroup WStruct& w_mem
, device type_1& output [[buffer(0)]]
) {
if (metal::all(__local_invocation_id == metal::uint3(0u))) {
if (__local_invocation_index == 0u) {
w_mem.arr = {};
metal::atomic_store_explicit(&w_mem.atom, 0, metal::memory_order_relaxed);
for (int __i0 = 0; __i0 < 8; __i0++) {
+17 -55
View File
@@ -28,16 +28,6 @@ fn compile_wgsl(device: &wgpu::Device) -> wgpu::ShaderModule {
})
}
fn compile_msl(device: &wgpu::Device) -> wgpu::ShaderModule {
unsafe {
device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough {
label: None,
msl: Some(std::borrow::Cow::Borrowed(include_str!("shader.metal"))),
num_workgroups: (1, 1, 1),
..Default::default()
})
}
}
struct Shaders {
ts: Option<wgpu::ShaderModule>,
ms: wgpu::ShaderModule,
@@ -46,50 +36,24 @@ struct Shaders {
ms_name: &'static str,
fs_name: &'static str,
}
fn get_shaders(
device: &wgpu::Device,
backend: wgpu::Backend,
info: &MeshPipelineTestInfo,
) -> Shaders {
fn get_shaders(device: &wgpu::Device, info: &MeshPipelineTestInfo) -> 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 PASSTHROUGH_SHADERS.
match backend {
wgpu::Backend::Vulkan | wgpu::Backend::Dx12 => {
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::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"
},
fs_name: "fragShader",
}
}
_ => unreachable!(),
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",
}
}
@@ -130,7 +94,6 @@ struct MeshPipelineTestInfo {
}
fn mesh_pipeline_build(ctx: &TestingContext, info: MeshPipelineTestInfo) {
let backend = ctx.adapter.get_info().backend;
let device = &ctx.device;
let (_depth_image, depth_view, depth_state) = create_depth(device);
@@ -141,7 +104,7 @@ fn mesh_pipeline_build(ctx: &TestingContext, info: MeshPipelineTestInfo) {
ts_name,
ms_name,
fs_name,
} = get_shaders(device, backend, &info);
} = get_shaders(device, &info);
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[],
@@ -214,7 +177,6 @@ pub enum DrawType {
}
fn mesh_draw(ctx: &TestingContext, draw_type: DrawType, info: MeshPipelineTestInfo) {
let backend = ctx.adapter.get_info().backend;
let device = &ctx.device;
let (_depth_image, depth_view, depth_state) = create_depth(device);
@@ -225,7 +187,7 @@ fn mesh_draw(ctx: &TestingContext, draw_type: DrawType, info: MeshPipelineTestIn
ts_name,
ms_name,
fs_name,
} = get_shaders(device, backend, &info);
} = get_shaders(device, &info);
let frag = fs.unwrap();
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
@@ -1,98 +0,0 @@
using namespace metal;
struct OutVertex {
float4 Position [[position]];
float4 Color [[user(locn0)]];
};
struct OutPrimitive {
float4 ColorMask [[flat]] [[user(locn1)]];
bool CullPrimitive [[primitive_culled]];
};
struct InVertex {
};
struct InPrimitive {
float4 ColorMask [[flat]] [[user(locn1)]];
};
struct FragmentIn {
float4 Color [[user(locn0)]];
float4 ColorMask [[flat]] [[user(locn1)]];
};
struct PayloadData {
float4 ColorMask;
bool Visible;
};
using Meshlet = metal::mesh<OutVertex, OutPrimitive, 3, 1, topology::triangle>;
constant float4 positions[3] = {
float4(0.0, 1.0, 0.0, 1.0),
float4(-1.0, -1.0, 0.0, 1.0),
float4(1.0, -1.0, 0.0, 1.0)
};
constant float4 colors[3] = {
float4(0.0, 1.0, 0.0, 1.0),
float4(0.0, 0.0, 1.0, 1.0),
float4(1.0, 0.0, 0.0, 1.0)
};
[[object]]
void taskShader(uint3 tid [[thread_position_in_grid]], object_data PayloadData &outPayload [[payload]], mesh_grid_properties grid) {
outPayload.ColorMask = float4(1.0, 1.0, 0.0, 1.0);
outPayload.Visible = true;
grid.set_threadgroups_per_grid(uint3(3, 1, 1));
}
[[mesh]]
void meshShader(
object_data PayloadData const& payload [[payload]],
Meshlet out
)
{
out.set_primitive_count(1);
for(int i = 0;i < 3;i++) {
OutVertex vert;
vert.Position = positions[i];
vert.Color = colors[i] * payload.ColorMask;
out.set_vertex(i, vert);
out.set_index(i, i);
}
OutPrimitive prim;
prim.ColorMask = float4(1.0, 0.0, 0.0, 1.0);
prim.CullPrimitive = !payload.Visible;
out.set_primitive(0, prim);
}
[[mesh]]
void meshNoTaskShader(
Meshlet out
)
{
out.set_primitive_count(1);
for(int i = 0;i < 3;i++) {
OutVertex vert;
vert.Position = positions[i];
vert.Color = colors[i];
out.set_vertex(i, vert);
out.set_index(i, i);
}
OutPrimitive prim;
prim.ColorMask = float4(1.0, 0.0, 0.0, 1.0);
prim.CullPrimitive = false;
out.set_primitive(0, prim);
}
fragment float4 fragShader(FragmentIn data [[stage_in]]) {
return data.Color * data.ColorMask;
}
+16 -6
View File
@@ -851,15 +851,25 @@ fn draw_mesh_tasks(
) -> Result<(), RenderBundleErrorInner> {
state.is_ready(DrawCommandFamily::DrawMeshTasks)?;
let limits = &state.device.limits;
let (groups_size_limit, max_groups) =
if state.pipeline.as_ref().unwrap().pipeline.has_task_shader {
(
limits.max_task_workgroups_per_dimension,
limits.max_task_workgroup_total_count,
)
} else {
(
limits.max_mesh_workgroups_per_dimension,
limits.max_mesh_workgroup_total_count,
)
};
let total_count = check_workgroup_sizes(
&[group_count_x, group_count_y, group_count_z],
&[
state.device.limits.max_task_mesh_workgroups_per_dimension,
state.device.limits.max_task_mesh_workgroups_per_dimension,
state.device.limits.max_task_mesh_workgroups_per_dimension,
],
&[groups_size_limit, groups_size_limit, groups_size_limit],
"max_task_mesh_workgroups_per_dimension",
state.device.limits.max_task_mesh_workgroup_total_count,
max_groups,
"max_task_mesh_workgroup_total_count",
)
.map_err(|err| RenderBundleErrorInner::Draw(err.into()))?;
+13 -12
View File
@@ -2728,18 +2728,19 @@ fn draw_mesh_tasks(
state.flush_bindings()?;
validate_mesh_draw_multiview(state)?;
let groups_size_limit = state
.pass
.base
.device
.limits
.max_task_mesh_workgroups_per_dimension;
let max_groups = state
.pass
.base
.device
.limits
.max_task_mesh_workgroup_total_count;
let limits = &state.pass.base.device.limits;
let (groups_size_limit, max_groups) = if state.pipeline.as_ref().unwrap().has_task_shader {
(
limits.max_task_workgroups_per_dimension,
limits.max_task_workgroup_total_count,
)
} else {
(
limits.max_mesh_workgroups_per_dimension,
limits.max_mesh_workgroup_total_count,
)
};
let total_count = check_workgroup_sizes(
&[group_count_x, group_count_y, group_count_z],
&[groups_size_limit, groups_size_limit, groups_size_limit],
+2
View File
@@ -4642,6 +4642,7 @@ impl Device {
};
let is_mesh = mesh_stage.is_some();
let has_task_shader = task_stage.is_some();
let raw = {
let pipeline_desc = hal::RenderPipelineDescriptor {
label: desc.label.to_hal(self.instance_flags),
@@ -4748,6 +4749,7 @@ impl Device {
label: desc.label.to_string(),
tracking_data: TrackingData::new(self.tracker_indices.render_pipelines.clone()),
is_mesh,
has_task_shader,
};
let pipeline = Arc::new(pipeline);
+1
View File
@@ -820,6 +820,7 @@ pub struct RenderPipeline {
pub(crate) tracking_data: TrackingData,
/// Whether this is a mesh shader pipeline
pub(crate) is_mesh: bool,
pub(crate) has_task_shader: bool,
}
impl Drop for RenderPipeline {
+18 -12
View File
@@ -852,6 +852,19 @@ impl super::Adapter {
);
}
// Source: https://microsoft.github.io/DirectX-Specs/d3d/MeshShader.html#dispatchmesh-api
let max_task_mesh_workgroup_total_count = if mesh_shader_supported {
2u32.pow(22)
} else {
0
};
// Technically it says "64k" but I highly doubt they want 65536 for compute and exactly 64,000 for task workgroups
let max_task_mesh_workgroups_per_dimension = if mesh_shader_supported {
Direct3D12::D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION
} else {
0
};
Some(crate::ExposedAdapter {
adapter: super::Adapter {
raw: adapter,
@@ -940,23 +953,16 @@ impl super::Adapter {
// NATIVE (Non-WebGPU) LIMITS:
//
max_non_sampler_bindings: 1_000_000,
max_binding_array_elements_per_shader_stage: full_heap_count,
max_binding_array_sampler_elements_per_shader_stage:
Direct3D12::D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE,
max_task_workgroup_total_count: max_task_mesh_workgroup_total_count,
max_task_workgroups_per_dimension: max_task_mesh_workgroups_per_dimension,
max_mesh_workgroup_total_count: max_task_mesh_workgroup_total_count,
max_mesh_workgroups_per_dimension: max_task_mesh_workgroups_per_dimension,
// Source: https://microsoft.github.io/DirectX-Specs/d3d/MeshShader.html#dispatchmesh-api
max_task_mesh_workgroup_total_count: if mesh_shader_supported {
2u32.pow(22)
} else {
0
},
// Technically it says "64k" but I highly doubt they want 65536 for compute and exactly 64,000 for task workgroups
max_task_mesh_workgroups_per_dimension: if mesh_shader_supported {
Direct3D12::D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION
} else {
0
},
// Assume this inherits from compute shaders
max_task_invocations_per_workgroup: if mesh_shader_supported {
Direct3D12::D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP
+2 -2
View File
@@ -1523,8 +1523,8 @@ impl crate::Device for super::Device {
external_texture_binding_map,
force_loop_bounding: true,
task_dispatch_limits: Some(naga::back::TaskDispatchLimits {
max_mesh_workgroups_per_dim: self.limits.max_task_mesh_workgroups_per_dimension,
max_mesh_workgroups_total: self.limits.max_task_mesh_workgroup_total_count,
max_mesh_workgroups_per_dim: self.limits.max_mesh_workgroups_per_dimension,
max_mesh_workgroups_total: self.limits.max_mesh_workgroup_total_count,
}),
mesh_shader_primitive_indices_clamp: true,
ray_query_initialization_tracking: true,
+4 -2
View File
@@ -819,8 +819,10 @@ impl super::Adapter {
max_buffer_size: i32::MAX as u64,
max_non_sampler_bindings: u32::MAX,
max_task_mesh_workgroup_total_count: 0,
max_task_mesh_workgroups_per_dimension: 0,
max_task_workgroup_total_count: 0,
max_task_workgroups_per_dimension: 0,
max_mesh_workgroup_total_count: 0,
max_mesh_workgroups_per_dimension: 0,
max_task_invocations_per_workgroup: 0,
max_task_invocations_per_dimension: 0,
max_mesh_invocations_per_workgroup: 0,
+34 -5
View File
@@ -76,7 +76,7 @@ impl crate::Adapter for super::Adapter {
unsafe fn open(
&self,
features: wgt::Features,
_limits: &wgt::Limits,
limits: &wgt::Limits,
_memory_hints: &wgt::MemoryHints,
) -> Result<crate::OpenDevice<super::Api>, crate::DeviceError> {
let queue = self
@@ -116,6 +116,7 @@ impl crate::Adapter for super::Adapter {
shared: Arc::clone(&self.shared),
features,
counters: Default::default(),
limits: limits.clone(),
},
queue: super::Queue {
shared: Arc::new(QueueShared {
@@ -1067,7 +1068,26 @@ impl super::CapabilitiesQuery {
},
// https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf#page=4
mesh_shaders,
max_mesh_task_workgroup_count: if mesh_shaders { 1024 } else { 0 },
max_task_workgroup_count: if mesh_shaders
&& (metal4 || device.supportsFamily(MTLGPUFamily::Apple2))
{
u32::MAX
} else if mesh_shaders {
1024
} else {
0
},
max_mesh_workgroup_count: if mesh_shaders
&& device.supportsFamily(MTLGPUFamily::Apple10)
{
2u32.pow(22)
} else if mesh_shaders && device.supportsFamily(MTLGPUFamily::Apple9) {
2u32.pow(20)
} else if mesh_shaders {
1024
} else {
0
},
max_task_payload_size: if mesh_shaders { 16384 - 32 } else { 0 },
supports_cooperative_matrix: family_check
&& (device.supportsFamily(MTLGPUFamily::Apple7)
@@ -1201,7 +1221,14 @@ impl super::CapabilitiesQuery {
features.insert(F::SUBGROUP | F::SUBGROUP_BARRIER);
}
features.set(F::EXPERIMENTAL_MESH_SHADER, self.mesh_shaders);
features.set(
F::EXPERIMENTAL_MESH_SHADER | F::EXPERIMENTAL_MESH_SHADER_POINTS,
self.mesh_shaders,
);
features.set(
F::EXPERIMENTAL_MESH_SHADER_MULTIVIEW,
self.supported_vertex_amplification_factor > 1 && self.mesh_shaders,
);
// Cooperative matrix (simdgroup matrix) requires MSL 2.3+
features.set(
@@ -1326,8 +1353,10 @@ impl super::CapabilitiesQuery {
},
// Should be not too large
max_task_mesh_workgroup_total_count: self.max_mesh_task_workgroup_count,
max_task_mesh_workgroups_per_dimension: self.max_mesh_task_workgroup_count,
max_task_workgroup_total_count: self.max_task_workgroup_count,
max_task_workgroups_per_dimension: self.max_task_workgroup_count,
max_mesh_workgroup_total_count: self.max_mesh_workgroup_count,
max_mesh_workgroups_per_dimension: self.max_mesh_workgroup_count,
max_task_invocations_per_workgroup: if self.mesh_shaders { 1024 } else { 0 },
max_task_invocations_per_dimension: if self.mesh_shaders { 1024 } else { 0 },
max_mesh_invocations_per_workgroup: if self.mesh_shaders { 1024 } else { 0 },
+21 -6
View File
@@ -158,7 +158,7 @@ impl super::Device {
let ep_resources = &layout.per_stage_map[naga_stage];
let bounds_check_policy = if stage.module.bounds_checks.bounds_checks {
let bounds_check_policy = if stage.module.runtime_checks.bounds_checks {
naga::proc::BoundsCheckPolicy::Restrict
} else {
naga::proc::BoundsCheckPolicy::Unchecked
@@ -197,7 +197,21 @@ impl super::Device {
binding_array: naga::proc::BoundsCheckPolicy::Unchecked,
},
zero_initialize_workgroup_memory: stage.zero_initialize_workgroup_memory,
force_loop_bounding: stage.module.bounds_checks.force_loop_bounding,
force_loop_bounding: stage.module.runtime_checks.force_loop_bounding,
task_dispatch_limits: stage
.module
.runtime_checks
.task_shader_dispatch_tracking
.then_some(naga::back::TaskDispatchLimits {
max_mesh_workgroups_per_dim: self
.limits
.max_mesh_workgroups_per_dimension,
max_mesh_workgroups_total: self.limits.max_mesh_workgroup_total_count,
}),
mesh_shader_primitive_indices_clamp: stage
.module
.runtime_checks
.mesh_shader_primitive_indices_clamp,
};
let pipeline_options = naga::back::msl::PipelineOptions {
@@ -377,6 +391,7 @@ impl super::Device {
pub unsafe fn device_from_raw(
raw: Retained<ProtocolObject<dyn MTLDevice>>,
features: wgt::Features,
limits: &wgt::Limits,
) -> super::Device {
let capabilities_query = super::CapabilitiesQuery::new(&raw);
let shared = super::AdapterShared::new(raw, &capabilities_query);
@@ -384,6 +399,7 @@ impl super::Device {
shared: Arc::new(shared),
features,
counters: Default::default(),
limits: limits.clone(),
}
}
@@ -1137,7 +1153,7 @@ impl crate::Device for super::Device {
match shader {
crate::ShaderInput::Naga(naga) => Ok(super::ShaderModule {
source: ShaderModuleSource::Naga(naga),
bounds_checks: desc.runtime_checks,
runtime_checks: desc.runtime_checks,
}),
crate::ShaderInput::MetalLib {
file,
@@ -1155,7 +1171,7 @@ impl crate::Device for super::Device {
num_workgroups,
}),
// This goes unused for passthrough shaders
bounds_checks: wgt::ShaderRuntimeChecks::unchecked(),
runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
})
}
crate::ShaderInput::Msl {
@@ -1174,8 +1190,7 @@ impl crate::Device for super::Device {
library,
num_workgroups,
}),
// This goes unused for passthrough shaders
bounds_checks: wgt::ShaderRuntimeChecks::unchecked(),
runtime_checks: desc.runtime_checks,
})
}
crate::ShaderInput::SpirV(_)
+4 -2
View File
@@ -310,7 +310,8 @@ struct CapabilitiesQuery {
int64_atomics: bool,
float_atomics: bool,
mesh_shaders: bool,
max_mesh_task_workgroup_count: u32,
max_task_workgroup_count: u32,
max_mesh_workgroup_count: u32,
max_task_payload_size: u32,
supported_vertex_amplification_factor: u32,
shader_barycentrics: bool,
@@ -478,6 +479,7 @@ pub struct Device {
shared: Arc<AdapterShared>,
features: wgt::Features,
counters: Arc<wgt::HalCounters>,
limits: wgt::Limits,
}
pub struct Surface {
@@ -870,7 +872,7 @@ unsafe impl Sync for PassthroughShader {}
#[derive(Debug)]
pub struct ShaderModule {
source: ShaderModuleSource,
bounds_checks: wgt::ShaderRuntimeChecks,
runtime_checks: wgt::ShaderRuntimeChecks,
}
impl crate::DynShaderModule for ShaderModule {}
+20 -15
View File
@@ -1376,9 +1376,14 @@ impl PhysicalDeviceProperties {
fn to_wgpu_limits(&self) -> wgt::Limits {
let limits = &self.properties.limits;
// Default is only implemented for tuples up to a certain size.
let (
mut max_task_workgroup_total_count,
mut max_task_workgroups_per_dimension,
mut max_mesh_workgroup_total_count,
mut max_mesh_workgroups_per_dimension,
) = Default::default();
let (
mut max_task_mesh_workgroup_total_count,
mut max_task_mesh_workgroups_per_dimension,
mut max_task_invocations_per_workgroup,
mut max_task_invocations_per_dimension,
mut max_mesh_invocations_per_workgroup,
@@ -1390,15 +1395,12 @@ impl PhysicalDeviceProperties {
mut max_mesh_multiview_view_count,
) = Default::default();
if let Some(m) = self.mesh_shader {
max_task_mesh_workgroup_total_count = m
.max_task_work_group_total_count
.min(m.max_mesh_work_group_total_count);
max_task_mesh_workgroups_per_dimension = m
.max_task_work_group_count
.into_iter()
.chain(m.max_mesh_work_group_count)
.min()
.unwrap();
max_task_workgroup_total_count = m.max_task_work_group_total_count;
max_task_workgroups_per_dimension =
m.max_task_work_group_count.into_iter().min().unwrap();
max_mesh_workgroup_total_count = m.max_mesh_work_group_total_count;
max_mesh_workgroups_per_dimension =
m.max_mesh_work_group_count.into_iter().min().unwrap();
max_task_invocations_per_workgroup = m.max_task_work_group_invocations;
max_task_invocations_per_dimension =
m.max_task_work_group_size.into_iter().min().unwrap();
@@ -1666,8 +1668,11 @@ impl PhysicalDeviceProperties {
0
},
max_task_mesh_workgroup_total_count,
max_task_mesh_workgroups_per_dimension,
max_task_workgroup_total_count,
max_task_workgroups_per_dimension,
max_mesh_workgroup_total_count,
max_mesh_workgroups_per_dimension,
max_task_invocations_per_workgroup,
max_task_invocations_per_dimension,
@@ -2690,8 +2695,8 @@ impl super::Adapter {
binding_map: BTreeMap::default(),
debug_info: None,
task_dispatch_limits: Some(naga::back::TaskDispatchLimits {
max_mesh_workgroups_per_dim: limits.max_task_mesh_workgroups_per_dimension,
max_mesh_workgroups_total: limits.max_task_mesh_workgroup_total_count,
max_mesh_workgroups_per_dim: limits.max_mesh_workgroups_per_dimension,
max_mesh_workgroups_total: limits.max_mesh_workgroup_total_count,
}),
mesh_shader_primitive_indices_clamp: true,
}
+8 -4
View File
@@ -182,8 +182,10 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
max_immediate_size,
max_non_sampler_bindings,
max_task_mesh_workgroup_total_count,
max_task_mesh_workgroups_per_dimension,
max_task_workgroup_total_count,
max_task_workgroups_per_dimension,
max_mesh_workgroup_total_count,
max_mesh_workgroups_per_dimension,
max_task_invocations_per_workgroup,
max_task_invocations_per_dimension,
max_mesh_invocations_per_workgroup,
@@ -236,8 +238,10 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
writeln!(output, "\t\t Max Compute Workgroup Size Z: {max_compute_workgroup_size_z}")?;
writeln!(output, "\t\t Max Compute Workgroups Per Dimension: {max_compute_workgroups_per_dimension}")?;
writeln!(output, "\t\t Max Task/Mesh Workgroup Total Count: {max_task_mesh_workgroup_total_count}")?;
writeln!(output, "\t\t Max Task/Mesh Workgroups Per Dimension: {max_task_mesh_workgroups_per_dimension}")?;
writeln!(output, "\t\t Max Task Workgroup Total Count: {max_task_workgroup_total_count}")?;
writeln!(output, "\t\t Max Task Workgroups Per Dimension: {max_task_workgroups_per_dimension}")?;
writeln!(output, "\t\t Max Mesh Workgroup Total Count: {max_mesh_workgroup_total_count}")?;
writeln!(output, "\t\t Max Mesh Workgroups Per Dimension: {max_mesh_workgroups_per_dimension}")?;
writeln!(output, "\t\t Max Task Invocations Per Workgroup: {max_task_invocations_per_workgroup}")?;
writeln!(output, "\t\t Max Task Invocations Per Dimension: {max_task_invocations_per_dimension}")?;
writeln!(output, "\t\t Max Mesh Invocations Per Workgroup: {max_mesh_invocations_per_workgroup}")?;
+48 -21
View File
@@ -67,8 +67,10 @@ macro_rules! with_limits {
$macro_name!(max_immediate_size, Ordering::Less);
$macro_name!(max_non_sampler_bindings, Ordering::Less);
$macro_name!(max_task_mesh_workgroup_total_count, Ordering::Less);
$macro_name!(max_task_mesh_workgroups_per_dimension, Ordering::Less);
$macro_name!(max_task_workgroup_total_count, Ordering::Less);
$macro_name!(max_task_workgroups_per_dimension, Ordering::Less);
$macro_name!(max_mesh_workgroup_total_count, Ordering::Less);
$macro_name!(max_mesh_workgroups_per_dimension, Ordering::Less);
$macro_name!(max_task_invocations_per_workgroup, Ordering::Less);
$macro_name!(max_task_invocations_per_dimension, Ordering::Less);
$macro_name!(max_mesh_invocations_per_workgroup, Ordering::Less);
@@ -254,12 +256,20 @@ pub struct Limits {
/// to create many bind groups at the cost of a large up-front allocation at device creation.
pub max_non_sampler_bindings: u32,
/// The maximum total value for a `RenderPass::draw_mesh_tasks(x, y, z)` operation or the
/// `@builtin(mesh_task_size)` returned from a task shader. Higher is "better".
pub max_task_mesh_workgroup_total_count: u32,
/// The maximum value for each dimension of a `RenderPass::draw_mesh_tasks(x, y, z)` operation.
/// The maximum total value for a `RenderPass::draw_mesh_tasks(x, y, z)` call on a mesh pipeline with a task shader.
/// Higher is "better".
pub max_task_workgroup_total_count: u32,
/// The maximum value for each dimension of a `RenderPass::draw_mesh_tasks(x, y, z)` call on a mesh pipeline with a task shader.
/// Higher is "better".
pub max_task_workgroups_per_dimension: u32,
/// The maximum product of arguments of a `RenderPass::draw_mesh_tasks(x, y, z)` operation on a mesh shader pipeline
/// without task shaders.
/// Also for task shader outputs. Higher is "better".
pub max_task_mesh_workgroups_per_dimension: u32,
pub max_mesh_workgroup_total_count: u32,
/// The maximum value for each dimension of a `RenderPass::draw_mesh_tasks(x, y, z)` operation on a mesh shader pipeline
/// without task shaders.
/// Also for task shader outputs. Higher is "better".
pub max_mesh_workgroups_per_dimension: u32,
// These are fundamentally different. It is very common for limits on mesh shaders to be much lower.
/// Maximum total number of invocations, or threads, per task shader workgroup. Higher is "better".
pub max_task_invocations_per_workgroup: u32,
@@ -353,8 +363,10 @@ impl Limits {
/// max_compute_workgroups_per_dimension: 65535,
/// max_immediate_size: 0,
/// max_non_sampler_bindings: 1_000_000,
/// max_task_mesh_workgroup_total_count: 0,
/// max_task_mesh_workgroups_per_dimension: 0,
/// max_task_workgroup_total_count: 0,
/// max_task_workgroups_per_dimension: 0,
/// max_mesh_workgroup_total_count: 0,
/// max_mesh_workgroups_per_dimension: 0,
/// max_task_invocations_per_workgroup: 0,
/// max_task_invocations_per_dimension: 0,
/// max_mesh_invocations_per_workgroup: 0,
@@ -413,8 +425,10 @@ impl Limits {
max_immediate_size: 0,
max_non_sampler_bindings: 1_000_000,
max_task_mesh_workgroup_total_count: 0,
max_task_mesh_workgroups_per_dimension: 0,
max_task_workgroup_total_count: 0,
max_task_workgroups_per_dimension: 0,
max_mesh_workgroup_total_count: 0,
max_mesh_workgroups_per_dimension: 0,
max_task_invocations_per_workgroup: 0,
max_task_invocations_per_dimension: 0,
max_mesh_invocations_per_workgroup: 0,
@@ -476,8 +490,10 @@ impl Limits {
/// max_buffer_size: 256 << 20, // (256 MiB)
/// max_non_sampler_bindings: 1_000_000,
///
/// max_task_mesh_workgroup_total_count: 0,
/// max_task_mesh_workgroups_per_dimension: 0,
/// max_task_workgroup_total_count: 0,
/// max_task_workgroups_per_dimension: 0,
/// max_mesh_workgroup_total_count: 0,
/// max_mesh_workgroups_per_dimension: 0,
/// max_task_invocations_per_workgroup: 0,
/// max_task_invocations_per_dimension: 0,
/// max_mesh_invocations_per_workgroup: 0,
@@ -555,8 +571,10 @@ impl Limits {
/// max_buffer_size: 256 << 20, // (256 MiB),
/// max_non_sampler_bindings: 1_000_000,
///
/// max_task_mesh_workgroup_total_count: 0,
/// max_task_mesh_workgroups_per_dimension: 0,
/// max_task_workgroup_total_count: 0,
/// max_task_workgroups_per_dimension: 0,
/// max_mesh_workgroup_total_count: 0,
/// max_mesh_workgroups_per_dimension: 0,
/// max_task_invocations_per_workgroup: 0,
/// max_task_invocations_per_dimension: 0,
/// max_mesh_invocations_per_workgroup: 0,
@@ -650,8 +668,10 @@ impl Limits {
max_immediate_size: ALLOC_MAX_U32,
max_non_sampler_bindings: ALLOC_MAX_U32,
max_task_mesh_workgroup_total_count: ALLOC_MAX_U32,
max_task_mesh_workgroups_per_dimension: ALLOC_MAX_U32,
max_task_workgroup_total_count: ALLOC_MAX_U32,
max_task_workgroups_per_dimension: ALLOC_MAX_U32,
max_mesh_workgroup_total_count: ALLOC_MAX_U32,
max_mesh_workgroups_per_dimension: ALLOC_MAX_U32,
max_task_invocations_per_workgroup: ALLOC_MAX_U32,
max_task_invocations_per_dimension: ALLOC_MAX_U32,
max_mesh_invocations_per_workgroup: ALLOC_MAX_U32,
@@ -731,10 +751,17 @@ impl Limits {
#[must_use]
pub const fn using_recommended_minimum_mesh_shader_values(self) -> Self {
Self {
// This limitation comes from metal
max_task_mesh_workgroup_total_count: 1024,
// This is a DirectX limitation
max_task_mesh_workgroups_per_dimension: 256,
// These are DirectX limitations (both nvidia and AMD match these exactly on vulkan)
// Note that Mac2 (newest intel macs) support up to 1024, but this is low enough,
// to make use of mesh shaders nonviable in most cases.
// We therefore, don't expose mesh shading on these devices.
// In contrast, here is no limit for any A-series or M-series chip.
max_task_workgroup_total_count: 2u32.pow(22),
max_task_workgroups_per_dimension: 65535,
// These are metal limitations
// M3 ups both of these to 1M
max_mesh_workgroup_total_count: 1024,
max_mesh_workgroups_per_dimension: 1024,
// Nvidia limit on vulkan
max_task_invocations_per_workgroup: 128,
max_task_invocations_per_dimension: 64,
+4 -4
View File
@@ -829,10 +829,10 @@ fn map_wgt_limits(limits: webgpu_sys::GpuSupportedLimits) -> wgt::Limits {
max_immediate_size: wgt::Limits::default().max_immediate_size,
max_non_sampler_bindings: wgt::Limits::default().max_non_sampler_bindings,
max_task_mesh_workgroup_total_count: wgt::Limits::default()
.max_task_mesh_workgroup_total_count,
max_task_mesh_workgroups_per_dimension: wgt::Limits::default()
.max_task_mesh_workgroups_per_dimension,
max_task_workgroup_total_count: wgt::Limits::default().max_task_workgroup_total_count,
max_task_workgroups_per_dimension: wgt::Limits::default().max_task_workgroups_per_dimension,
max_mesh_workgroup_total_count: wgt::Limits::default().max_mesh_workgroup_total_count,
max_mesh_workgroups_per_dimension: wgt::Limits::default().max_mesh_workgroups_per_dimension,
max_task_invocations_per_workgroup: wgt::Limits::default()
.max_task_invocations_per_workgroup,
max_task_invocations_per_dimension: wgt::Limits::default()