use std::collections::BTreeSet;
use ::rlx::{DType, Device, Graph, GraphExt, Shape};
use crate::core::{BufferAttribute, BufferGeometry};
use crate::utils::compute_vertex_normals;
use super::session::GraphRunner;
use super::tensor::{Tensor, TensorError};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MeshError {
NoPositions,
NotIndexed,
Tensor(TensorError),
}
impl std::fmt::Display for MeshError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NoPositions => write!(f, "geometry has no 3-component position attribute"),
Self::NotIndexed => write!(f, "geometry has no index buffer"),
Self::Tensor(e) => write!(f, "{e}"),
}
}
}
impl std::error::Error for MeshError {}
impl From<TensorError> for MeshError {
fn from(e: TensorError) -> Self {
Self::Tensor(e)
}
}
pub fn laplacian_smooth(
geometry: &mut BufferGeometry,
iterations: usize,
lambda: f32,
device: Device,
) -> Result<(), MeshError> {
let umbrella = Umbrella::of(geometry)?;
if umbrella.count == 0 {
return Ok(());
}
let mut runner = umbrella.compile(lambda, device);
let mut positions = umbrella.positions(geometry)?;
for _ in 0..iterations {
positions = runner.run(&[("positions", &positions)]).remove(0);
}
write_back(geometry, &positions)
}
pub fn taubin_smooth(
geometry: &mut BufferGeometry,
iterations: usize,
lambda: f32,
mu: f32,
device: Device,
) -> Result<(), MeshError> {
let umbrella = Umbrella::of(geometry)?;
if umbrella.count == 0 {
return Ok(());
}
let mut shrink = umbrella.compile(lambda, device);
let mut inflate = umbrella.compile(mu, device);
let mut positions = umbrella.positions(geometry)?;
for _ in 0..iterations {
positions = shrink.run(&[("positions", &positions)]).remove(0);
positions = inflate.run(&[("positions", &positions)]).remove(0);
}
write_back(geometry, &positions)
}
struct Umbrella {
count: usize,
width: usize,
neighbours: Vec<f32>,
weights: Vec<f32>,
}
impl Umbrella {
fn of(geometry: &BufferGeometry) -> Result<Self, MeshError> {
let positions = geometry
.get_attribute("position")
.filter(|a| a.item_size == 3)
.ok_or(MeshError::NoPositions)?;
let index = geometry.index.as_ref().ok_or(MeshError::NotIndexed)?;
let count = positions.count();
let mut sets: Vec<BTreeSet<u32>> = vec![BTreeSet::new(); count];
for tri in index.chunks_exact(3) {
for (a, b) in [(0, 1), (1, 2), (2, 0)] {
let (u, v) = (tri[a] as usize, tri[b] as usize);
if u < count && v < count && u != v {
sets[u].insert(tri[b]);
sets[v].insert(tri[a]);
}
}
}
let width = sets.iter().map(|s| s.len()).max().unwrap_or(0).max(1);
let mut neighbours = vec![0.0f32; count * width];
let mut weights = vec![0.0f32; count * width];
for (v, set) in sets.iter().enumerate() {
if set.is_empty() {
neighbours[v * width] = v as f32;
weights[v * width] = 1.0;
continue;
}
let share = 1.0 / set.len() as f32;
for (slot, n) in set.iter().enumerate() {
neighbours[v * width + slot] = *n as f32;
weights[v * width + slot] = share;
}
}
Ok(Self {
count,
width,
neighbours,
weights,
})
}
fn positions(&self, geometry: &BufferGeometry) -> Result<Tensor, MeshError> {
let attr = geometry
.get_attribute("position")
.ok_or(MeshError::NoPositions)?;
Ok(Tensor::from(attr))
}
fn compile(&self, step: f32, device: Device) -> GraphRunner {
let mut g = Graph::new("umbrella");
let p = g.input("positions", Shape::new(&[self.count, 3], DType::F32));
let idx = g.param(
"neighbours",
Shape::new(&[self.count * self.width], DType::F32),
);
let w = g.param(
"weights",
Shape::new(&[self.count, self.width, 1], DType::F32),
);
let gathered = g.gather_(p, idx, 0); let rows = g.reshape_(gathered, vec![self.count as i64, self.width as i64, 3]);
let weighted = g.mul(rows, w);
let average = g.sum(weighted, vec![1], false);
let delta = g.sub(average, p);
let scaled = {
let k = g.constant(step as f64, DType::F32);
g.mul(delta, k)
};
let moved = g.add(p, scaled);
g.set_outputs(vec![moved]);
let mut runner = GraphRunner::new(g, device);
runner.set_param("neighbours", &self.neighbours);
runner.set_param("weights", &self.weights);
runner
}
}
fn write_back(geometry: &mut BufferGeometry, positions: &Tensor) -> Result<(), MeshError> {
let attr = BufferAttribute::try_from(positions)?;
geometry.set_attribute("position", attr);
compute_vertex_normals(geometry);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::geometries::SphereGeometry;
use crate::rlx::preferred_device;
fn roughened_sphere() -> BufferGeometry {
let mut geometry = SphereGeometry::new(1.0, 24, 12);
let attr = geometry.get_attribute("position").unwrap().clone();
let mut array = attr.array.clone();
for (i, v) in array.chunks_exact_mut(3).enumerate() {
let jitter = 1.0 + 0.12 * (((i * 2654435761) % 1000) as f32 / 1000.0 - 0.5);
v[0] *= jitter;
v[1] *= jitter;
v[2] *= jitter;
}
geometry.set_attribute("position", BufferAttribute::new(array, 3));
geometry
}
fn roughness(geometry: &BufferGeometry) -> f32 {
let umbrella = Umbrella::of(geometry).unwrap();
let radii: Vec<f32> = geometry
.positions()
.unwrap()
.map(|p| (p.x * p.x + p.y * p.y + p.z * p.z).sqrt())
.collect();
let (mut total, mut counted) = (0.0f32, 0usize);
for v in 0..umbrella.count {
let row = v * umbrella.width..(v + 1) * umbrella.width;
let neighbourhood: f32 = umbrella.neighbours[row.clone()]
.iter()
.zip(&umbrella.weights[row])
.map(|(n, w)| w * radii[*n as usize])
.sum();
total += (radii[v] - neighbourhood).abs();
counted += 1;
}
total / counted as f32
}
#[test]
fn one_full_step_lands_on_the_neighbour_average() {
let mut geometry = BufferGeometry::new();
geometry.set_attribute(
"position",
BufferAttribute::new(
vec![
-1.0, 0.0, -1.0, 1.0, 0.0, -1.0, 1.0, 0.0, 1.0, -1.0, 0.0, 1.0, 0.0, 4.0, 0.0, ],
3,
),
);
geometry.set_index(vec![0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4]);
laplacian_smooth(&mut geometry, 1, 1.0, preferred_device()).unwrap();
let p: Vec<f32> = geometry.get_attribute("position").unwrap().array.clone();
let apex = &p[12..15];
assert!(
apex[0].abs() < 1e-5 && apex[1].abs() < 1e-5 && apex[2].abs() < 1e-5,
"apex went to {apex:?}, not the centroid of the base"
);
}
#[test]
fn smoothing_removes_the_bumps() {
let mut geometry = roughened_sphere();
let before = roughness(&geometry);
laplacian_smooth(&mut geometry, 8, 0.5, preferred_device()).unwrap();
let after = roughness(&geometry);
assert!(after < before * 0.5, "{before} → {after}");
}
#[test]
fn laplacian_shrinks_and_taubin_does_not() {
let volume = |g: &BufferGeometry| {
g.positions()
.unwrap()
.map(|p| (p.x * p.x + p.y * p.y + p.z * p.z).sqrt())
.sum::<f32>()
};
let device = preferred_device();
let mut plain = roughened_sphere();
let start = volume(&plain);
laplacian_smooth(&mut plain, 24, 0.5, device).unwrap();
let shrunk = volume(&plain);
let mut taubin = roughened_sphere();
taubin_smooth(&mut taubin, 12, 0.5, -0.53, device).unwrap();
let held = volume(&taubin);
assert!(shrunk < start * 0.97, "plain Laplacian did not shrink");
assert!(
held > start * 0.97,
"Taubin lost volume: {start} → {held} (plain gave {shrunk})"
);
}
#[test]
fn normals_follow_the_new_surface() {
let mut geometry = roughened_sphere();
laplacian_smooth(&mut geometry, 4, 0.5, preferred_device()).unwrap();
let normals = geometry.get_attribute("normal").expect("normals rebuilt");
let positions = geometry.get_attribute("position").unwrap();
let used: std::collections::BTreeSet<u32> =
geometry.index.as_ref().unwrap().iter().copied().collect();
for v in used {
let n = &normals.array[v as usize * 3..v as usize * 3 + 3];
let p = &positions.array[v as usize * 3..v as usize * 3 + 3];
let dot = n[0] * p[0] + n[1] * p[1] + n[2] * p[2];
assert!(dot > 0.0, "normal {n:?} at {p:?} points inwards");
}
}
#[test]
fn an_empty_geometry_is_left_alone_rather_than_compiled() {
let mut geometry = BufferGeometry::new();
geometry.set_attribute("position", BufferAttribute::new(Vec::new(), 3));
geometry.set_index(Vec::new());
let device = preferred_device();
assert_eq!(laplacian_smooth(&mut geometry, 3, 0.5, device), Ok(()));
assert_eq!(taubin_smooth(&mut geometry, 3, 0.5, -0.53, device), Ok(()));
assert_eq!(geometry.get_attribute("position").unwrap().count(), 0);
}
#[test]
fn an_unindexed_mesh_is_refused_rather_than_treated_as_dust() {
let mut geometry = BufferGeometry::new();
geometry.set_attribute("position", BufferAttribute::new(vec![0.0; 9], 3));
assert_eq!(
laplacian_smooth(&mut geometry, 1, 0.5, preferred_device()),
Err(MeshError::NotIndexed)
);
}
}