use isomesh::marching_cubes::table::{self, MAX_TRIANGLES};
use crate::{Composer, Error, FieldBuffer, GridParams, PrefixScan, Result, read_bytes_many};
const CASE_STRIDE: usize = 1 + MAX_TRIANGLES;
const WORKGROUP: u32 = 64;
const MESH_BATCH: u32 = 32;
#[must_use]
pub fn case_table_bytes() -> Vec<u8> {
let mut out = Vec::with_capacity(256 * CASE_STRIDE * 4);
for entry in &table::CASES {
let header = u32::from(entry.count) | (u32::from(entry.centroids) << 8);
out.extend_from_slice(&header.to_le_bytes());
for tri in &entry.triangles {
let word = u32::from(tri[0]) | (u32::from(tri[1]) << 8) | (u32::from(tri[2]) << 16);
out.extend_from_slice(&word.to_le_bytes());
}
}
out
}
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct ExtractTimings {
pub count_ms: f64,
pub scan_ms: f64,
pub emit_ms: f64,
pub geometry_readback_ms: f64,
}
impl ExtractTimings {
#[must_use]
pub fn total_ms(&self) -> f64 {
self.count_ms + self.scan_ms + self.emit_ms + self.geometry_readback_ms
}
#[must_use]
pub fn readback_share(&self) -> f64 {
let total = self.total_ms();
if total > 0.0 {
self.geometry_readback_ms / total
} else {
0.0
}
}
}
struct Prologue {
params: GridParams,
groups: u64,
cell_words: u32,
uniform: wgpu::Buffer,
counts: wgpu::Buffer,
placeholder: wgpu::Buffer,
}
#[derive(Debug)]
pub struct GpuGeometry {
pub positions: wgpu::Buffer,
pub normals: wgpu::Buffer,
pub triangles: u32,
pub timings: ExtractTimings,
}
#[derive(Debug)]
pub struct IndirectGeometry {
pub positions: wgpu::Buffer,
pub normals: wgpu::Buffer,
pub indirect: wgpu::Buffer,
pub draw_params: wgpu::Buffer,
pub total: wgpu::Buffer,
pub budget: u32,
pub timings: ExtractTimings,
}
#[derive(Clone, Debug, Default)]
pub struct GpuMesh {
pub positions: Vec<[f32; 3]>,
pub normals: Vec<[f32; 3]>,
pub timings: ExtractTimings,
}
impl GpuMesh {
#[must_use]
pub fn triangle_count(&self) -> usize {
self.positions.len() / 3
}
}
#[derive(Debug)]
pub struct MarchingCubesGpu {
count: wgpu::ComputePipeline,
emit: wgpu::ComputePipeline,
layout: wgpu::BindGroupLayout,
cases: wgpu::Buffer,
scan: PrefixScan,
}
impl MarchingCubesGpu {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Result<Self> {
let source = Composer::with_builtins().compose("marching_cubes", &[])?;
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("isomesh marching cubes"),
source: wgpu::ShaderSource::Wgsl(source.into()),
});
let entry = |binding: u32, ty: wgpu::BufferBindingType| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
};
let read = wgpu::BufferBindingType::Storage { read_only: true };
let write = wgpu::BufferBindingType::Storage { read_only: false };
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("isomesh marching cubes bindings"),
entries: &[
entry(0, wgpu::BufferBindingType::Uniform),
entry(1, read),
entry(2, read),
entry(3, write),
entry(4, write),
entry(5, write),
],
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("isomesh marching cubes layout"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let compile = |entry_point: &str| {
device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(entry_point),
layout: Some(&pipeline_layout),
module: &module,
entry_point: Some(entry_point),
compilation_options: wgpu::PipelineCompilationOptions::default(),
cache: None,
})
};
let bytes = case_table_bytes();
let cases = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh marching cubes case table"),
size: bytes.len() as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
queue.write_buffer(&cases, 0, &bytes);
Ok(Self {
count: compile("count_cells"),
emit: compile("emit_cells"),
layout,
cases,
scan: PrefixScan::new(device)?,
})
}
fn prologue(
device: &wgpu::Device,
queue: &wgpu::Queue,
field: &FieldBuffer,
) -> Result<Prologue> {
let params = field.params();
let cells = params.cell_count();
let groups = cells.div_ceil(u64::from(WORKGROUP));
if groups > u64::from(device.limits().max_compute_workgroups_per_dimension) {
return Err(Error::GridTooLarge {
samples: params.samples(),
});
}
let cell_words = u32::try_from(cells).map_err(|_| Error::GridTooLarge {
samples: params.samples(),
})?;
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh grid params"),
size: GridParams::UNIFORM_SIZE,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
queue.write_buffer(&uniform, 0, ¶ms.to_std140());
let counts = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh cell triangle counts"),
size: u64::from(cell_words) * 4,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let placeholder = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh unused output"),
size: 4,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
Ok(Prologue {
params,
groups,
cell_words,
uniform,
counts,
placeholder,
})
}
pub fn extract(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
field: &FieldBuffer,
) -> Result<GpuMesh> {
let geometry = self.extract_buffers(device, queue, field)?;
if geometry.triangles == 0 {
return Ok(GpuMesh {
timings: geometry.timings,
..GpuMesh::default()
});
}
let mut timings = geometry.timings;
let bytes = u64::from(geometry.triangles) * 9 * 4;
let started = std::time::Instant::now();
let flat = read_bytes_many(
device,
queue,
&[(&geometry.positions, bytes), (&geometry.normals, bytes)],
)?;
timings.geometry_readback_ms = started.elapsed().as_secs_f64() * 1000.0;
let triple = |raw: &[u8]| -> Vec<[f32; 3]> {
raw.chunks_exact(12)
.map(|c| {
let at = |k: usize| f32::from_le_bytes([c[k], c[k + 1], c[k + 2], c[k + 3]]);
[at(0), at(4), at(8)]
})
.collect()
};
let (Some(positions), Some(normals)) = (flat.first(), flat.get(1)) else {
return Err(Error::DeviceLost);
};
Ok(GpuMesh {
positions: triple(positions),
normals: triple(normals),
timings,
})
}
pub fn extract_indirect(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
field: &FieldBuffer,
budget: u32,
) -> Result<IndirectGeometry> {
let Prologue {
params,
groups,
cell_words,
uniform,
counts,
placeholder,
} = Self::prologue(device, queue, field)?;
let mut timings = ExtractTimings::default();
let started = std::time::Instant::now();
self.dispatch(
device,
queue,
&uniform,
field,
&counts,
&placeholder,
&placeholder,
&self.count,
groups,
);
timings.count_ms = started.elapsed().as_secs_f64() * 1000.0;
let started = std::time::Instant::now();
let scanned = self
.scan
.scan_deferred(device, queue, &counts, cell_words)?;
timings.scan_ms = started.elapsed().as_secs_f64() * 1000.0;
let floats = u64::from(budget) * 9;
if floats * 4 > device.limits().max_storage_buffer_binding_size {
return Err(Error::GridTooLarge {
samples: params.samples(),
});
}
let geometry = |label| {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: (floats * 4).max(4),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
})
};
let positions = geometry("isomesh positions (budgeted)");
let normals = geometry("isomesh normals (budgeted)");
let started = std::time::Instant::now();
self.dispatch(
device,
queue,
&uniform,
field,
&scanned.offsets,
&positions,
&normals,
&self.emit,
groups,
);
timings.emit_ms = started.elapsed().as_secs_f64() * 1000.0;
let indirect = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh mesh draw args"),
size: 12,
usage: wgpu::BufferUsages::INDIRECT
| wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let draw_params = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("isomesh draw params"),
size: 16,
usage: wgpu::BufferUsages::UNIFORM
| wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
self.scan.write_draw_args(
device,
queue,
&scanned.total,
&indirect,
&draw_params,
MESH_BATCH,
budget,
);
Ok(IndirectGeometry {
positions,
normals,
indirect,
draw_params,
total: scanned.total,
budget,
timings,
})
}
pub fn extract_buffers(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
field: &FieldBuffer,
) -> Result<GpuGeometry> {
let Prologue {
params,
groups,
cell_words,
uniform,
counts,
placeholder,
} = Self::prologue(device, queue, field)?;
let mut timings = ExtractTimings::default();
let started = std::time::Instant::now();
self.dispatch(
device,
queue,
&uniform,
field,
&counts,
&placeholder,
&placeholder,
&self.count,
groups,
);
timings.count_ms = started.elapsed().as_secs_f64() * 1000.0;
let started = std::time::Instant::now();
let scanned = self.scan.scan(device, queue, &counts, cell_words)?;
let triangles = scanned.total;
timings.scan_ms = started.elapsed().as_secs_f64() * 1000.0;
if triangles == 0 {
let empty = |label| {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: 4,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
})
};
return Ok(GpuGeometry {
positions: empty("isomesh positions (empty)"),
normals: empty("isomesh normals (empty)"),
triangles: 0,
timings,
});
}
let vertex_floats = u64::from(triangles) * 3 * 3;
if vertex_floats * 4 > device.limits().max_storage_buffer_binding_size {
return Err(Error::GridTooLarge {
samples: params.samples(),
});
}
let geometry = |label| {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size: vertex_floats * 4,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
})
};
let positions = geometry("isomesh positions");
let normals = geometry("isomesh normals");
let started = std::time::Instant::now();
self.dispatch(
device,
queue,
&uniform,
field,
&scanned.offsets,
&positions,
&normals,
&self.emit,
groups,
);
timings.emit_ms = started.elapsed().as_secs_f64() * 1000.0;
Ok(GpuGeometry {
positions,
normals,
triangles,
timings,
})
}
#[allow(clippy::too_many_arguments)]
fn dispatch(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
uniform: &wgpu::Buffer,
field: &FieldBuffer,
counts: &wgpu::Buffer,
positions: &wgpu::Buffer,
normals: &wgpu::Buffer,
pipeline: &wgpu::ComputePipeline,
groups: u64,
) {
fn binding(index: u32, buffer: &wgpu::Buffer) -> wgpu::BindGroupEntry<'_> {
wgpu::BindGroupEntry {
binding: index,
resource: buffer.as_entire_binding(),
}
}
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("isomesh marching cubes"),
layout: &self.layout,
entries: &[
binding(0, uniform),
binding(1, field.buffer()),
binding(2, &self.cases),
binding(3, counts),
binding(4, positions),
binding(5, normals),
],
});
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("isomesh marching cubes"),
});
{
let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("isomesh marching cubes"),
timestamp_writes: None,
});
pass.set_pipeline(pipeline);
pass.set_bind_group(0, &bind_group, &[]);
pass.dispatch_workgroups(groups as u32, 1, 1);
}
queue.submit(Some(encoder.finish()));
}
}
#[cfg(test)]
mod tests;