Add mesh shading api to wgpu & wgpu-core (#7345)

Author: SupaMaggie70Incorporated

CHANGELOG.md

@@ -157,6 +157,7 @@ By @Vecvec in [#7829](https://github.com/gfx-rs/wgpu/pull/7829).
 - Add acceleration structure limits. By @Vecvec in [#7845](https://github.com/gfx-rs/wgpu/pull/7845).
 - Add support for clip-distances feature for Vulkan and GL backends. By @dzamkov in [#7730](https://github.com/gfx-rs/wgpu/pull/7730)
 - Added `wgpu_types::error::{ErrorType, WebGpuError}` for classification of errors according to WebGPU's [`GPUError`]'s classification scheme, and implement `WebGpuError` for existing errors. This allows users of `wgpu-core` to offload error classification onto the WGPU ecosystem, rather than having to do it themselves without sufficient information. By @ErichDonGubler in [#6547](https://github.com/gfx-rs/wgpu/pull/6547).
+- Added mesh shader support to `wgpu`, with examples. Requires passthrough. By @SupaMaggie70Incorporated in [#7345](https://github.com/gfx-rs/wgpu/pull/7345).
 
 [`GPUError`]: https://www.w3.org/TR/webgpu/#gpuerror
 

cts_runner/tests/integration.rs

@@ -34,7 +34,7 @@ impl Display for JsError {
 
 impl Debug for JsError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self)
+        write!(f, "{self}")
     }
 }
 

examples/README.md

@@ -43,6 +43,7 @@ These examples use a common framework to handle wgpu init, window creation, and
 - `ray_cube_fragment` - Demonstrates using ray queries with a fragment shader.
 - `ray_scene` - Demonstrates using ray queries and model loading
 - `ray_shadows` - Demonstrates a simple use of ray queries - high quality shadows - uses a light set with push constants to raytrace through an untransformed scene and detect whether there is something obstructing the light.
+- `mesh_shader` - Rrenders a triangle to a window with mesh shaders, while showcasing most mesh shader related features(task shaders, payloads, per primitive data).
 
 #### Compute
 

examples/features/src/lib.rs

@@ -13,6 +13,7 @@ pub mod hello_synchronization;
 pub mod hello_triangle;
 pub mod hello_windows;
 pub mod hello_workgroups;
+pub mod mesh_shader;
 pub mod mipmap;
 pub mod msaa_line;
 pub mod multiple_render_targets;

examples/features/src/main.rs

@@ -182,6 +182,12 @@ const EXAMPLES: &[ExampleDesc] = &[
         webgl: false,  // No Ray-tracing extensions
         webgpu: false, // No Ray-tracing extensions (yet)
     },
+    ExampleDesc {
+        name: "mesh_shader",
+        function: wgpu_examples::mesh_shader::main,
+        webgl: false,
+        webgpu: false,
+    },
 ];
 
 fn get_example_name() -> Option<String> {

examples/features/src/mesh_shader/README.md

@@ -0,0 +1,9 @@
+# mesh_shader
+
+This example renders a triangle to a window with mesh shaders, while showcasing most mesh shader related features(task shaders, payloads, per primitive data).
+
+## To Run
+
+```
+cargo run --bin wgpu-examples mesh_shader
+```

examples/features/src/mesh_shader/mod.rs

@@ -0,0 +1,142 @@
+use std::{io::Write, process::Stdio};
+
+// Same as in mesh shader tests
+fn compile_glsl(
+    device: &wgpu::Device,
+    data: &[u8],
+    shader_stage: &'static str,
+) -> wgpu::ShaderModule {
+    let cmd = std::process::Command::new("glslc")
+        .args([
+            &format!("-fshader-stage={shader_stage}"),
+            "-",
+            "-o",
+            "-",
+            "--target-env=vulkan1.2",
+            "--target-spv=spv1.4",
+        ])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()
+        .expect("Failed to call glslc");
+    cmd.stdin.as_ref().unwrap().write_all(data).unwrap();
+    println!("{shader_stage}");
+    let output = cmd.wait_with_output().expect("Error waiting for glslc");
+    assert!(output.status.success());
+    unsafe {
+        device.create_shader_module_passthrough(wgpu::ShaderModuleDescriptorPassthrough::SpirV(
+            wgpu::ShaderModuleDescriptorSpirV {
+                label: None,
+                source: wgpu::util::make_spirv_raw(&output.stdout),
+            },
+        ))
+    }
+}
+
+pub struct Example {
+    pipeline: wgpu::RenderPipeline,
+}
+impl crate::framework::Example for Example {
+    fn init(
+        config: &wgpu::SurfaceConfiguration,
+        _adapter: &wgpu::Adapter,
+        device: &wgpu::Device,
+        _queue: &wgpu::Queue,
+    ) -> Self {
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: None,
+            bind_group_layouts: &[],
+            push_constant_ranges: &[],
+        });
+        let (ts, ms, fs) = (
+            compile_glsl(device, include_bytes!("shader.task"), "task"),
+            compile_glsl(device, include_bytes!("shader.mesh"), "mesh"),
+            compile_glsl(device, include_bytes!("shader.frag"), "frag"),
+        );
+        let pipeline = device.create_mesh_pipeline(&wgpu::MeshPipelineDescriptor {
+            label: None,
+            layout: Some(&pipeline_layout),
+            task: Some(wgpu::TaskState {
+                module: &ts,
+                entry_point: Some("main"),
+                compilation_options: Default::default(),
+            }),
+            mesh: wgpu::MeshState {
+                module: &ms,
+                entry_point: Some("main"),
+                compilation_options: Default::default(),
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &fs,
+                entry_point: Some("main"),
+                compilation_options: Default::default(),
+                targets: &[Some(config.view_formats[0].into())],
+            }),
+            primitive: wgpu::PrimitiveState {
+                cull_mode: Some(wgpu::Face::Back),
+                ..Default::default()
+            },
+            depth_stencil: None,
+            multisample: Default::default(),
+            multiview: None,
+            cache: None,
+        });
+        Self { pipeline }
+    }
+    fn render(&mut self, view: &wgpu::TextureView, device: &wgpu::Device, queue: &wgpu::Queue) {
+        let mut encoder =
+            device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+        {
+            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color {
+                            r: 0.1,
+                            g: 0.2,
+                            b: 0.3,
+                            a: 1.0,
+                        }),
+                        store: wgpu::StoreOp::Store,
+                    },
+                    depth_slice: None,
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            });
+            rpass.push_debug_group("Prepare data for draw.");
+            rpass.set_pipeline(&self.pipeline);
+            rpass.pop_debug_group();
+            rpass.insert_debug_marker("Draw!");
+            rpass.draw_mesh_tasks(1, 1, 1);
+        }
+        queue.submit(Some(encoder.finish()));
+    }
+    fn required_downlevel_capabilities() -> wgpu::DownlevelCapabilities {
+        Default::default()
+    }
+    fn required_features() -> wgpu::Features {
+        wgpu::Features::EXPERIMENTAL_MESH_SHADER | wgpu::Features::SPIRV_SHADER_PASSTHROUGH
+    }
+    fn required_limits() -> wgpu::Limits {
+        wgpu::Limits::defaults().using_recommended_minimum_mesh_shader_values()
+    }
+    fn resize(
+        &mut self,
+        _config: &wgpu::SurfaceConfiguration,
+        _device: &wgpu::Device,
+        _queue: &wgpu::Queue,
+    ) {
+        // empty
+    }
+    fn update(&mut self, _event: winit::event::WindowEvent) {
+        // empty
+    }
+}
+
+pub fn main() {
+    crate::framework::run::<Example>("mesh_shader");
+}

examples/features/src/mesh_shader/shader.frag

@@ -0,0 +1,11 @@
+#version 450
+#extension GL_EXT_mesh_shader : require
+
+in VertexInput { layout(location = 0) vec4 color; }
+vertexInput;
+layout(location = 1) perprimitiveEXT in PrimitiveInput { vec4 colorMask; }
+primitiveInput;
+
+layout(location = 0) out vec4 fragColor;
+
+void main() { fragColor = vertexInput.color * primitiveInput.colorMask; }

examples/features/src/mesh_shader/shader.mesh

@@ -0,0 +1,38 @@
+#version 450
+#extension GL_EXT_mesh_shader : require
+
+const vec4[3] positions = {vec4(0., 1.0, 0., 1.0), vec4(-1.0, -1.0, 0., 1.0),
+                           vec4(1.0, -1.0, 0., 1.0)};
+const vec4[3] colors = {vec4(0., 1., 0., 1.), vec4(0., 0., 1., 1.),
+                        vec4(1., 0., 0., 1.)};
+
+// This is an inefficient workgroup size.Ideally the total thread count would be
+// a multiple of 64
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+struct PayloadData {
+  vec4 colorMask;
+  bool visible;
+};
+taskPayloadSharedEXT PayloadData payloadData;
+
+out VertexOutput { layout(location = 0) vec4 color; }
+vertexOutput[];
+layout(location = 1) perprimitiveEXT out PrimitiveOutput { vec4 colorMask; }
+primitiveOutput[];
+
+shared uint sharedData;
+
+layout(triangles, max_vertices = 3, max_primitives = 1) out;
+void main() {
+  sharedData = 5;
+  SetMeshOutputsEXT(3, 1);
+  gl_MeshVerticesEXT[0].gl_Position = positions[0];
+  gl_MeshVerticesEXT[1].gl_Position = positions[1];
+  gl_MeshVerticesEXT[2].gl_Position = positions[2];
+  vertexOutput[0].color = colors[0] * payloadData.colorMask;
+  vertexOutput[1].color = colors[1] * payloadData.colorMask;
+  vertexOutput[2].color = colors[2] * payloadData.colorMask;
+  gl_PrimitiveTriangleIndicesEXT[gl_LocalInvocationIndex] = uvec3(0, 1, 2);
+  primitiveOutput[0].colorMask = vec4(1.0, 0.0, 1.0, 1.0);
+  gl_MeshPrimitivesEXT[0].gl_CullPrimitiveEXT = !payloadData.visible;
+}

examples/features/src/mesh_shader/shader.task

@@ -0,0 +1,16 @@
+#version 450
+#extension GL_EXT_mesh_shader : require
+
+layout(local_size_x = 4, local_size_y = 1, local_size_z = 1) in;
+
+struct TaskPayload {
+  vec4 colorMask;
+  bool visible;
+};
+taskPayloadSharedEXT TaskPayload taskPayload;
+
+void main() {
+  taskPayload.colorMask = vec4(1.0, 1.0, 0.0, 1.0);
+  taskPayload.visible = true;
+  EmitMeshTasksEXT(3, 1, 1);
+}