use crate::core::{BufferAttribute, BufferGeometry};
use crate::math::Vector3;
pub struct MarchingCubes {
pub resolution: usize,
pub size: Vector3,
}
impl MarchingCubes {
pub fn new(resolution: usize, size: Vector3) -> Self {
Self { resolution, size }
}
pub fn extract<F>(&self, iso: f32, field: F) -> BufferGeometry
where
F: Fn(f32, f32, f32) -> f32,
{
let res = self.resolution.max(2);
let step_x = self.size.x / res as f32;
let step_y = self.size.y / res as f32;
let step_z = self.size.z / res as f32;
let dim = res + 1;
let mut grid = vec![0.0f32; dim * dim * dim];
let idx = |i: usize, j: usize, k: usize| i + dim * (j + dim * k);
for k in 0..dim {
for j in 0..dim {
for i in 0..dim {
let x = (i as f32 - res as f32 * 0.5) * step_x;
let y = (j as f32 - res as f32 * 0.5) * step_y;
let z = (k as f32 - res as f32 * 0.5) * step_z;
grid[idx(i, j, k)] = field(x, y, z);
}
}
}
let mut positions: Vec<f32> = Vec::new();
for k in 0..res {
for j in 0..res {
for i in 0..res {
let corners = [
grid[idx(i, j, k)],
grid[idx(i + 1, j, k)],
grid[idx(i, j + 1, k)],
grid[idx(i + 1, j + 1, k)],
grid[idx(i, j, k + 1)],
grid[idx(i + 1, j, k + 1)],
grid[idx(i, j + 1, k + 1)],
grid[idx(i + 1, j + 1, k + 1)],
];
let mut crossings = Vec::new();
let edges = [
(0, 1, [step_x, 0.0, 0.0]),
(2, 3, [step_x, 0.0, 0.0]),
(4, 5, [step_x, 0.0, 0.0]),
(6, 7, [step_x, 0.0, 0.0]),
(0, 2, [0.0, step_y, 0.0]),
(1, 3, [0.0, step_y, 0.0]),
(4, 6, [0.0, step_y, 0.0]),
(5, 7, [0.0, step_y, 0.0]),
(0, 4, [0.0, 0.0, step_z]),
(1, 5, [0.0, 0.0, step_z]),
(2, 6, [0.0, 0.0, step_z]),
(3, 7, [0.0, 0.0, step_z]),
];
for &(a, b, axis) in &edges {
let va = corners[a];
let vb = corners[b];
if (va - iso) * (vb - iso) < 0.0 {
let t = (iso - va) / (vb - va);
let base = corner_pos(a, i, j, k, step_x, step_y, step_z, res);
crossings.push([
base[0] + axis[0] * t,
base[1] + axis[1] * t,
base[2] + axis[2] * t,
]);
}
}
if crossings.len() < 3 {
continue;
}
let center = [
crossings.iter().map(|p| p[0]).sum::<f32>() / crossings.len() as f32,
crossings.iter().map(|p| p[1]).sum::<f32>() / crossings.len() as f32,
crossings.iter().map(|p| p[2]).sum::<f32>() / crossings.len() as f32,
];
let n = crossings.len();
for x in 0..n {
let p1 = crossings[x];
let p2 = crossings[(x + 1) % n];
positions.extend_from_slice(¢er);
positions.extend_from_slice(&p1);
positions.extend_from_slice(&p2);
}
}
}
}
let mut g = BufferGeometry::new();
if !positions.is_empty() {
g.set_attribute("position", BufferAttribute::new(positions, 3));
}
g
}
}
fn corner_pos(
c: usize,
i: usize,
j: usize,
k: usize,
sx: f32,
sy: f32,
sz: f32,
res: usize,
) -> [f32; 3] {
let dx = if c & 1 != 0 { 1 } else { 0 };
let dy = if c & 2 != 0 { 1 } else { 0 };
let dz = if c & 4 != 0 { 1 } else { 0 };
[
((i + dx) as f32 - res as f32 * 0.5) * sx,
((j + dy) as f32 - res as f32 * 0.5) * sy,
((k + dz) as f32 - res as f32 * 0.5) * sz,
]
}