From 0fb4a3e868097d5bd54d8488dd1cb2fbffabfc16 Mon Sep 17 00:00:00 2001 From: raykholo Date: Fri, 23 Oct 2026 13:43:18 +0000 Subject: [PATCH] GPU tessellation: an empty plan no longer fails buffer validation (#5049) (#5104) * claim: #5049 * GPU tessellation: an empty plan no longer fails buffer validation (#5049) Empty tessellation inputs were padded to 16 bytes, smaller than the shader's 32-byte vertex and 48-byte surface records, so wgpu refused the dispatch. Skip the dispatch when there is nothing to evaluate, and pad each empty buffer to one whole element of what the shader reads. --- crates/gpu/src/lib.rs | 50 ++++++++++++++++++++++------------------- crates/gpu/src/tests.rs | 38 +++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+), 23 deletions(-) diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rs index 9a00bf3b7..a99f63015 100644 --- a/crates/gpu/src/lib.rs +++ b/crates/gpu/src/lib.rs @@ -103,7 +103,7 @@ pub type Result = std::result::Result; /// Bytes per evaluated vertex in [`GpuMesh::vertices`]: the position (x, y, z, 1) then the /// normal (x, y, z, 0), each four f32. -pub const VERTEX_STRIDE: u64 = 32; +pub const VERTEX_STRIDE: u64 = std::mem::size_of::<[f32; VERTEX_WORDS]>() as u64; /// Byte offset of the normal within a vertex. pub const NORMAL_OFFSET: u64 = 16; @@ -121,6 +121,7 @@ pub struct GpuMesh { /// Per plan (in the order given), its vertices and indices. pub parts: Vec, bind: wgpu::BindGroup, + workgroups: u32, // The inputs, kept until the evaluation has run. _inputs: [wgpu::Buffer; 4], } @@ -290,17 +291,12 @@ impl TessGpu { } let d = &self.device; let count = word(packed.count)?; - let init = |label: &str, contents: &[u8], usage| { - // wgpu rejects empty bindings: pad to one word. - let contents = if contents.is_empty() { &[0u8; 16][..] } else { contents }; - d.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some(label), contents, usage }) - }; let words = |v: &[u32]| v.iter().flat_map(|x| x.to_le_bytes()).collect::>(); let floats = |v: &[f32]| v.iter().flat_map(|x| x.to_le_bytes()).collect::>(); - let params = init("tess params", &words(&[count, 0, 0, 0]), wgpu::BufferUsages::UNIFORM); - let surfaces = init("tess surfaces", &words(&packed.surfaces), wgpu::BufferUsages::STORAGE); - let data = init("tess data", &floats(&packed.data), wgpu::BufferUsages::STORAGE); - let verts = init("tess vertices", &words(&packed.vertices), wgpu::BufferUsages::STORAGE); + let params = tess_buffer::<[u32; 4]>(d, "tess params", words(&[count, 0, 0, 0]), wgpu::BufferUsages::UNIFORM); + let surfaces = tess_buffer::<[u32; SURFACE_WORDS]>(d, "tess surfaces", words(&packed.surfaces), wgpu::BufferUsages::STORAGE); + let data = tess_buffer::(d, "tess data", floats(&packed.data), wgpu::BufferUsages::STORAGE); + let verts = tess_buffer::<[u32; VERTEX_WORDS]>(d, "tess vertices", words(&packed.vertices), wgpu::BufferUsages::STORAGE); let vertices = d.create_buffer(&wgpu::BufferDescriptor { label: Some("tess mesh vertices"), size: (packed.count.max(1) as u64) * VERTEX_STRIDE, @@ -323,7 +319,7 @@ impl TessGpu { } parts.push(Part { vertices: v0..offset, indices: i0..word(tri.len())? }); } - let indices = init("tess mesh indices", &words(&tri), wgpu::BufferUsages::INDEX); + let indices = tess_buffer::(d, "tess mesh indices", words(&tri), wgpu::BufferUsages::INDEX); let bind = d.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("tess mesh"), layout: &self.layout, @@ -343,6 +339,7 @@ impl TessGpu { vertex_face, parts, bind, + workgroups: if packed.surfaces.is_empty() { 0 } else { count.div_ceil(WORKGROUP) }, _inputs: [params, surfaces, data, verts], }) } @@ -350,28 +347,29 @@ impl TessGpu { /// Add `mesh`'s evaluation to `encoder` (one dispatch, no wait, nothing read back): once the /// encoder is submitted, render passes after it read the evaluated vertices. pub fn record(&self, encoder: &mut wgpu::CommandEncoder, mesh: &GpuMesh) { + if mesh.workgroups == 0 { + return; + } let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: Some("tess mesh"), timestamp_writes: None }); pass.set_pipeline(&self.pipeline); pass.set_bind_group(0, &mesh.bind, &[]); - pass.dispatch_workgroups(mesh.vertex_count.div_ceil(WORKGROUP).max(1), 1, 1); + pass.dispatch_workgroups(mesh.workgroups, 1, 1); } #[cfg(not(target_arch = "wasm32"))] fn run(&self, packed: &Packed, vertices: &[u32], n: usize) -> Result> { + if n == 0 || packed.surfaces.is_empty() { + return Ok(Vec::new()); + } let d = &self.device; let bytes_u32 = |v: &[u32]| v.iter().flat_map(|x| x.to_le_bytes()).collect::>(); let bytes_f32 = |v: &[f32]| v.iter().flat_map(|x| x.to_le_bytes()).collect::>(); let count = u32::try_from(n).map_err(|_| GpuError::Failed("batch too large".into()))?; - let init = |label: &str, contents: &[u8], usage| { - // wgpu rejects empty bindings: pad to one word. - let contents = if contents.is_empty() { &[0u8; 16][..] } else { contents }; - d.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some(label), contents, usage }) - }; - let params = init("tess params", &bytes_u32(&[count, 0, 0, 0]), wgpu::BufferUsages::UNIFORM); - let surfaces = init("tess surfaces", &bytes_u32(&packed.surfaces), wgpu::BufferUsages::STORAGE); - let data = init("tess data", &bytes_f32(&packed.data), wgpu::BufferUsages::STORAGE); - let verts = init("tess vertices", &bytes_u32(vertices), wgpu::BufferUsages::STORAGE); - let size = (n.max(1) * 32) as u64; + let params = tess_buffer::<[u32; 4]>(d, "tess params", bytes_u32(&[count, 0, 0, 0]), wgpu::BufferUsages::UNIFORM); + let surfaces = tess_buffer::<[u32; SURFACE_WORDS]>(d, "tess surfaces", bytes_u32(&packed.surfaces), wgpu::BufferUsages::STORAGE); + let data = tess_buffer::(d, "tess data", bytes_f32(&packed.data), wgpu::BufferUsages::STORAGE); + let verts = tess_buffer::<[u32; VERTEX_WORDS]>(d, "tess vertices", bytes_u32(vertices), wgpu::BufferUsages::STORAGE); + let size = (n as u64) * VERTEX_STRIDE; let out = d.create_buffer(&wgpu::BufferDescriptor { label: Some("tess out"), size, @@ -400,7 +398,7 @@ impl TessGpu { let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor { label: Some("tess"), timestamp_writes: None }); pass.set_pipeline(&self.pipeline); pass.set_bind_group(0, &bind, &[]); - pass.dispatch_workgroups(count.div_ceil(WORKGROUP).max(1), 1, 1); + pass.dispatch_workgroups(count.div_ceil(WORKGROUP), 1, 1); } enc.copy_buffer_to_buffer(&out, 0, &read, 0, size); self.queue.submit([enc.finish()]); @@ -424,6 +422,12 @@ const VERTEX_WORDS: usize = 8; /// Words per surface header (matches `Surface` in the shader). const SURFACE_WORDS: usize = 12; +// Each empty binding still needs a whole element of its packed shader representation. +fn tess_buffer(device: &wgpu::Device, label: &str, mut contents: Vec, usage: wgpu::BufferUsages) -> wgpu::Buffer { + contents.resize(contents.len().max(std::mem::size_of::()), 0); + device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some(label), contents: &contents, usage }) +} + /// A plan as the shader reads it. struct Packed { surfaces: Vec, diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rs index 4d12aa2b1..9492fe908 100644 --- a/crates/gpu/src/tests.rs +++ b/crates/gpu/src/tests.rs @@ -228,6 +228,44 @@ fn a_scene_in_one_dispatch_matches_each_body_on_the_cpu() { } } +fn check_empty_tessellation(gpu: &TessGpu, plan: &TessPlan) { + let scope = gpu.device.push_error_scope(wgpu::ErrorFilter::Validation); + let evaluated = ok(gpu.evaluate(plan)); + assert!(evaluated.positions.is_empty()); + assert!(evaluated.normals.is_empty()); + assert!(evaluated.triangles.is_empty()); + + let mesh = ok(gpu.prepare(plan)); + assert_eq!(mesh.vertex_count, 0); + assert_eq!(mesh.index_count, 0); + assert!(mesh._inputs[1].size() >= std::mem::size_of::<[u32; SURFACE_WORDS]>() as u64); + assert!(mesh._inputs[2].size() >= std::mem::size_of::() as u64); + assert!(mesh._inputs[3].size() >= std::mem::size_of::<[u32; VERTEX_WORDS]>() as u64); + let mut encoder = gpu.device.create_command_encoder(&Default::default()); + gpu.record(&mut encoder, &mesh); + gpu.queue.submit([encoder.finish()]); + ok(gpu.device.poll(wgpu::PollType::wait_indefinitely())); + let error = pollster::block_on(scope.pop()); + assert!(error.is_none(), "{error:?}"); +} + +#[test] +fn tessellation_without_vertices_does_not_dispatch() { + let Some(gpu) = gpu() else { return }; + let plan = TessPlan { + surfaces: vec![EvalSurface::Plane { origin: Vec3::ZERO, du: Vec3::X, dv: Vec3::Y }], + faces: vec![solidcraft_geom::tess::FacePlan { surface: Some(0), ..Default::default() }], + ..Default::default() + }; + check_empty_tessellation(&gpu, &plan); +} + +#[test] +fn tessellation_without_surfaces_does_not_dispatch() { + let Some(gpu) = gpu() else { return }; + check_empty_tessellation(&gpu, &TessPlan::default()); +} + /// Display meshing of a 400-hole plate (#303's benchmark): reference mesher, plan, CPU and GPU /// evaluation. `cargo test --release -p solidcraft-gpu bench_plate -- --ignored --nocapture`. #[test]