#![allow(clippy::float_cmp)]
use isomesh::fields::{BoxExact, Sphere, Torus};
use isomesh::marching_cubes::{MarchingCubes, table};
use isomesh::{MeshBuffer, RuntimeShape3, Sdf};
use super::{MarchingCubesGpu, case_table_bytes};
use crate::headless::Gpu;
use crate::{FieldBuffer, GridParams, read_buffer, read_buffer_u32};
fn gpu() -> &'static Gpu {
crate::headless::shared()
}
fn cpu_mesh<F: Sdf<Scalar = f32>>(field: &F, grid: GridParams) -> MeshBuffer<f32> {
let mut out = MeshBuffer::new();
let shape = RuntimeShape3::new(grid.samples()).expect("valid shape");
MarchingCubes::<f32>::new()
.extract(field, &shape, grid.origin(), grid.cell_size(), &mut out)
.expect("cpu extraction");
out
}
#[test]
fn the_uploaded_table_is_isomeshs_own() {
let bytes = case_table_bytes();
assert_eq!(bytes.len(), 256 * (1 + table::MAX_TRIANGLES) * 4);
let word = |i: usize| {
u32::from_le_bytes([
bytes[i * 4],
bytes[i * 4 + 1],
bytes[i * 4 + 2],
bytes[i * 4 + 3],
])
};
let stride = 1 + table::MAX_TRIANGLES;
for (case, entry) in table::CASES.iter().enumerate() {
let header = word(case * stride);
assert_eq!(header & 0xff, u32::from(entry.count), "case {case} count");
assert_eq!(
(header >> 8) & 0xff,
u32::from(entry.centroids),
"case {case} centroids"
);
for (t, tri) in entry.triangles.iter().enumerate() {
let packed = word(case * stride + 1 + t);
assert_eq!(packed & 0xff, u32::from(tri[0]), "case {case} tri {t}.0");
assert_eq!(
(packed >> 8) & 0xff,
u32::from(tri[1]),
"case {case} tri {t}.1"
);
assert_eq!(
(packed >> 16) & 0xff,
u32::from(tri[2]),
"case {case} tri {t}.2"
);
}
}
}
#[test]
fn the_triangle_count_matches_the_cpu_on_every_field() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([33; 3], [-2.0; 3], 0.125).expect("valid grid");
let fields: [(&str, &dyn Sdf<Scalar = f32>); 3] = [
("sphere", &Sphere::<f32>::canonical()),
("torus", &Torus::<f32>::canonical()),
(
"box_exact",
&BoxExact::<f32> {
center: [0.0; 3],
half_extents: [1.1, 0.9, 0.7],
},
),
];
for (name, field) in fields {
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let mesh = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
let cpu = cpu_mesh(&field, grid);
assert_eq!(
mesh.triangle_count(),
cpu.indices.len() / 3,
"{name}: gpu and cpu disagree on triangle count"
);
assert!(mesh.triangle_count() > 0, "{name}: nothing was extracted");
assert_eq!(mesh.positions.len(), mesh.normals.len());
}
}
#[test]
fn every_gpu_vertex_is_a_cpu_vertex_to_within_one_ulp() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([33; 3], [-2.0; 3], 0.125).expect("valid grid");
let field = Sphere::<f32>::canonical();
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let mesh = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
let cpu = cpu_mesh(&field, grid);
let key = |p: &[f32; 3]| [p[0].to_bits(), p[1].to_bits(), p[2].to_bits()];
let cpu_points: std::collections::HashSet<[u32; 3]> = cpu.positions.iter().map(key).collect();
let step = |bits: u32, delta: i32| -> u32 { bits.wrapping_add(delta as u32) };
let mut exact = 0usize;
let mut within = 0usize;
let mut strangers = 0usize;
for p in &mesh.positions {
let k = key(p);
if cpu_points.contains(&k) {
exact += 1;
continue;
}
let mut found = false;
for dx in [-1i32, 0, 1] {
for dy in [-1i32, 0, 1] {
for dz in [-1i32, 0, 1] {
let probe = [step(k[0], dx), step(k[1], dy), step(k[2], dz)];
if cpu_points.contains(&probe) {
found = true;
}
}
}
}
if found {
within += 1;
} else {
strangers += 1;
}
}
println!(
"gpu vertices: {exact} bit-exact, {within} within 1 ULP, {strangers} further ({} total)",
mesh.positions.len()
);
assert_eq!(
strangers, 0,
"{strangers} gpu vertices are more than one ULP from any cpu vertex"
);
assert!(
!mesh.positions.is_empty(),
"no gpu vertices at all -- the bound above would be vacuous"
);
assert!(
!cpu_points.is_empty(),
"no cpu vertices at all -- every gpu vertex would be a stranger"
);
assert_eq!(
exact + within + strangers,
mesh.positions.len(),
"every emitted vertex must be classified exactly once"
);
}
#[test]
fn extraction_is_deterministic() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([25; 3], [-2.0; 3], 0.16).expect("valid grid");
let field = Torus::<f32>::canonical();
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let first = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
let second = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
assert_eq!(first.positions, second.positions, "positions differ");
assert_eq!(first.normals, second.normals, "normals differ");
}
#[test]
fn normals_face_away_from_the_solid() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([33; 3], [-2.0; 3], 0.125).expect("valid grid");
let field = Sphere::<f32>::canonical();
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let mesh = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
let mut worst = 1.0f32;
for (p, n) in mesh.positions.iter().zip(&mesh.normals) {
let g = field.gradient(*p);
let len = (g[0] * g[0] + g[1] * g[1] + g[2] * g[2]).sqrt();
assert!(len > 0.0, "the test field has no gradient at {p:?}");
let dot = (n[0] * g[0] + n[1] * g[1] + n[2] * g[2]) / len;
worst = worst.min(dot);
}
assert!(
worst > 0.99,
"worst normal agreement with the analytic gradient was {worst}, i.e. {:.2} deg",
worst.acos().to_degrees()
);
}
#[test]
fn a_field_with_no_surface_extracts_nothing() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([9; 3], [10.0; 3], 0.1).expect("valid grid");
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &Sphere::<f32>::canonical())
.expect("upload");
let mesh = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
assert_eq!(mesh.triangle_count(), 0);
assert!(mesh.positions.is_empty());
}
#[test]
fn the_agreement_is_a_distance_and_holds_at_a_non_power_of_two_spacing() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let field = Sphere::<f32>::canonical();
for (samples, cell) in [(33u32, 0.125f32), (41, 0.1)] {
let grid = GridParams::new([samples; 3], [-2.0; 3], cell).expect("valid grid");
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let mesh = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
let cpu = cpu_mesh(&field, grid);
assert_eq!(
mesh.triangle_count(),
cpu.indices.len() / 3,
"h = {cell}: triangle counts differ"
);
let bucket = cell * 0.01;
let cell_of = |p: &[f32; 3]| {
[
(p[0] / bucket).floor() as i64,
(p[1] / bucket).floor() as i64,
(p[2] / bucket).floor() as i64,
]
};
let mut index: std::collections::HashMap<[i64; 3], Vec<[f32; 3]>> =
std::collections::HashMap::new();
for p in &cpu.positions {
index.entry(cell_of(p)).or_default().push(*p);
}
let mut exact = 0usize;
let mut worst = 0.0f32;
for p in &mesh.positions {
let mut best = f32::INFINITY;
let home = cell_of(p);
for dx in -1..=1 {
for dy in -1..=1 {
for dz in -1..=1 {
let at = [home[0] + dx, home[1] + dy, home[2] + dz];
for q in index.get(&at).into_iter().flatten() {
let d = ((p[0] - q[0]).powi(2)
+ (p[1] - q[1]).powi(2)
+ (p[2] - q[2]).powi(2))
.sqrt();
best = best.min(d);
}
}
}
}
if best == 0.0 {
exact += 1;
}
worst = worst.max(best / cell);
}
assert!(
worst < 1e-4,
"h = {cell}: worst offset {worst:e} cells is too large to be rounding"
);
println!(
"h = {cell}: {exact} of {} bit-identical, worst offset {worst:e} cells",
mesh.positions.len()
);
}
}
#[test]
fn extract_buffers_matches_extract_and_skips_the_geometry_readback() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([33; 3], [-2.0; 3], 0.125).expect("valid grid");
let field = Sphere::<f32>::canonical();
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let read_back = mc
.extract(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
let on_gpu = mc
.extract_buffers(gpu.device(), gpu.queue(), &buffer)
.expect("extract_buffers");
assert_eq!(
on_gpu.triangles as usize,
read_back.triangle_count(),
"the two entry points disagree about how many triangles there are"
);
assert_eq!(
on_gpu.timings.geometry_readback_ms, 0.0,
"extract_buffers read the geometry back after all"
);
assert!(
read_back.timings.geometry_readback_ms > 0.0,
"extract did not time its geometry read-back"
);
assert!(
on_gpu
.positions
.usage()
.contains(wgpu::BufferUsages::STORAGE),
"positions cannot be bound to a shader"
);
assert!(
on_gpu.normals.usage().contains(wgpu::BufferUsages::STORAGE),
"normals cannot be bound to a shader"
);
}
#[test]
fn empty_extraction_still_yields_bindable_buffers() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([9; 3], [10.0; 3], 0.1).expect("valid grid");
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &Sphere::<f32>::canonical())
.expect("upload");
let on_gpu = mc
.extract_buffers(gpu.device(), gpu.queue(), &buffer)
.expect("extract_buffers");
assert_eq!(on_gpu.triangles, 0);
assert!(
on_gpu.positions.size() > 0,
"a zero-sized binding is invalid"
);
assert!(on_gpu.normals.size() > 0);
}
#[test]
fn the_indirect_path_produces_the_same_geometry() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([33; 3], [-2.0; 3], 0.125).expect("grid");
let field = Sphere::<f32>::canonical();
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let sync = mc
.extract_buffers(gpu.device(), gpu.queue(), &buffer)
.expect("extract_buffers");
let indirect = mc
.extract_indirect(gpu.device(), gpu.queue(), &buffer, sync.triangles * 2)
.expect("extract_indirect");
let total = read_buffer_u32(gpu.device(), gpu.queue(), &indirect.total, 4).expect("total")[0];
assert_eq!(
total, sync.triangles,
"the indirect path counted differently"
);
let args = read_buffer_u32(gpu.device(), gpu.queue(), &indirect.indirect, 12).expect("args");
assert_eq!(args[0], total.div_ceil(32), "workgroup count");
assert_eq!([args[1], args[2]], [1, 1], "y and z must be 1");
let params =
read_buffer_u32(gpu.device(), gpu.queue(), &indirect.draw_params, 4).expect("params");
assert_eq!(params[0], total, "the draw uniform must carry the total");
let floats = u64::from(total) * 9 * 4;
let a = read_buffer(gpu.device(), gpu.queue(), &sync.positions, floats).expect("sync");
let b = read_buffer(gpu.device(), gpu.queue(), &indirect.positions, floats).expect("indirect");
assert_eq!(
a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),
b.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),
"the two paths wrote different positions"
);
}
#[test]
fn a_budget_smaller_than_the_surface_truncates_detectably() {
let gpu = gpu();
let mc = MarchingCubesGpu::new(gpu.device(), gpu.queue()).expect("pipeline");
let grid = GridParams::new([33; 3], [-2.0; 3], 0.125).expect("grid");
let field = Sphere::<f32>::canonical();
let buffer = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &field).expect("upload");
let full = mc
.extract_buffers(gpu.device(), gpu.queue(), &buffer)
.expect("extract");
let budget = full.triangles / 4;
let tight = mc
.extract_indirect(gpu.device(), gpu.queue(), &buffer, budget)
.expect("extract_indirect");
let total = read_buffer_u32(gpu.device(), gpu.queue(), &tight.total, 4).expect("total")[0];
assert_eq!(
total, full.triangles,
"the total must report the real surface, not the budget"
);
assert!(
total > tight.budget,
"the fixture did not actually overflow: {total} against a budget of {}",
tight.budget
);
let args = read_buffer_u32(gpu.device(), gpu.queue(), &tight.indirect, 12).expect("args");
assert_eq!(
args[0],
tight.budget.div_ceil(32),
"workgroups must cover the budget only"
);
let dp = read_buffer_u32(gpu.device(), gpu.queue(), &tight.draw_params, 4).expect("params");
assert_eq!(
dp[0], tight.budget,
"the draw uniform must stop at the budget"
);
}
#[test]
fn the_wgsl_edge_corners_are_isomeshs_own() {
let src = crate::MARCHING_CUBES_WGSL;
let start = src
.find("const EDGE_CORNERS")
.expect("marching_cubes.wgsl lost `const EDGE_CORNERS`");
let body = &src[start..];
let end = body.find(");").expect("`const EDGE_CORNERS` never closes");
let mut rest = &body[..end];
let mut pairs: Vec<[u8; 2]> = Vec::new();
while let Some(open) = rest.find("vec2<u32>(") {
let args = &rest[open + "vec2<u32>(".len()..];
let close = args.find(')').expect("unclosed vec2 in EDGE_CORNERS");
let mut nums = args[..close].split(',').map(|n| {
n.trim()
.strip_suffix('u')
.and_then(|digits| digits.parse::<u8>().ok())
.expect("EDGE_CORNERS entries are `<digits>u`")
});
pairs.push([
nums.next().expect("vec2 lost its low corner"),
nums.next().expect("vec2 lost its high corner"),
]);
rest = &args[close..];
}
assert_eq!(
pairs,
table::EDGE_CORNERS,
"the WGSL EDGE_CORNERS transcription drifted from cube::EDGE_CORNERS"
);
}
#[test]
fn the_wgsl_corner_offset_is_the_documented_bit_layout() {
assert!(
crate::MARCHING_CUBES_WGSL.contains("vec3<u32>(c & 1u, (c >> 1u) & 1u, (c >> 2u) & 1u)"),
"marching_cubes.wgsl's corner_offset no longer matches the corner bit layout"
);
}
#[test]
fn the_timestamp_instrument_reports_a_positive_span_for_each_compute_pass() {
let Ok(gpu) = Gpu::with_timestamps() else {
std::println!("TIMESTAMP_QUERY unavailable on this adapter; span check skipped");
return;
};
let mc =
MarchingCubesGpu::with_timestamps(gpu.device(), gpu.queue()).expect("timestamped pipeline");
let before = mc
.take_timestamps(gpu.device(), gpu.queue())
.expect("resolve")
.expect("this extractor has a query set");
assert!(before.spans.is_empty(), "nothing has dispatched yet");
assert!(before.period_ns > 0.0, "a zero period cannot time anything");
let grid = GridParams::new([17; 3], [-2.0; 3], 0.25).expect("grid");
let field = FieldBuffer::sampled(gpu.device(), gpu.queue(), grid, &Sphere::<f32>::canonical())
.expect("field");
let mesh = mc
.extract(gpu.device(), gpu.queue(), &field)
.expect("extraction");
assert!(
!mesh.positions.is_empty(),
"the fixture must produce geometry"
);
let spans = mc
.take_timestamps(gpu.device(), gpu.queue())
.expect("resolve")
.expect("this extractor has a query set");
assert!(spans.complete, "the query set overflowed");
assert_eq!(
spans.spans.len(),
2,
"one span per compute pass: count and emit — got {:?}",
spans.spans
);
for span in &spans.spans {
assert!(
span.ms > 0.0,
"{} measured {} ms: a zero span is a driver that advertises the \
feature and does not implement it",
span.label,
span.ms
);
}
let after = mc
.take_timestamps(gpu.device(), gpu.queue())
.expect("resolve")
.expect("query set")
.spans;
assert!(after.is_empty(), "resolve must clear: got {after:?}");
std::println!(
"timestamp period {:.4} ns; spans {:?}",
spans.period_ns,
spans.spans
);
}