Struct TriangleMesh 

pub struct TriangleMesh {
    pub vertices: Vec<Vec3>,
    pub indices: Vec<[usize; 3]>,
}

A triangle mesh defined by vertices and index triples.

Fields

vertices: Vec<Vec3>

Vertex positions.

indices: Vec<[usize; 3]>

Triangle indices (groups of three).

Implementations

impl TriangleMesh

pub fn new(vertices: Vec<Vec3>, indices: Vec<[usize; 3]>) -> Self

Create a new triangle mesh.

pub fn surface_area(&self) -> Real

Surface area: sum of triangle areas.

pub fn volume_explicit(&self) -> Real

Volume via signed tetrahedral decomposition (divergence theorem).

pub fn center_of_mass_explicit(&self) -> [f64; 3]

Center of mass via weighted tetrahedral centroids.

pub fn compute_normals(&self) -> Vec<[f64; 3]>

Compute per-face normals (unit vectors).

pub fn ray_cast_full( &self, origin: [f64; 3], direction: [f64; 3], max_toi: f64, ) -> Option<(f64, usize, [f64; 3])>

Ray cast returning (t, face_index, normal) via Moller-Trumbore for all triangles.

pub fn is_watertight(&self) -> bool

Check whether the mesh is watertight (every edge is shared by exactly two triangles).

pub fn vertex_to_faces(&self) -> Vec<Vec<usize>>

Build vertex-to-face adjacency: for each vertex index, the list of triangle indices that reference it.

pub fn face_adjacency(&self) -> Vec<Vec<usize>>

Build face-to-face adjacency via shared edges. Returns a vec of the same length as self.indices. Each entry contains the indices of adjacent faces (those sharing at least one edge).

pub fn unique_edges(&self) -> Vec<(usize, usize)>

Return the set of unique edges as sorted (min,max) vertex index pairs.

pub fn vertex_neighbors(&self) -> Vec<Vec<usize>>

Build vertex-to-vertex adjacency (1-ring neighbours).

pub fn edge_collapse(&mut self, v0: usize, v1: usize) -> bool

Collapse an edge between vertices v0 and v1, merging them to their midpoint. Triangles that degenerate (both endpoints are v0/v1) are removed.

Returns true if the edge was found and collapsed.

pub fn compute_vertex_normals(&self) -> Vec<[f64; 3]>

Compute per-vertex normals by accumulating face normals weighted by the interior angle at each vertex.

pub fn laplacian_smooth(&mut self, factor: f64, iterations: usize)

Uniform Laplacian smoothing: move each vertex towards the average of its 1-ring neighbours by factor (0..1). Boundary vertices are not moved.

pub fn geodesic_distance(&self, source: usize) -> Vec<f64>

Compute approximate geodesic distances from source vertex to all other vertices using Dijkstra on edge lengths. Returns a vec of distances indexed by vertex, with f64::INFINITY for unreachable vertices.

pub fn loop_subdivide(&mut self)

Perform one iteration of Loop subdivision.

Each triangle is split into four by inserting edge midpoints (for boundary edges) or Loop-weighted edge vertices (for interior edges). Existing vertices are repositioned using the Loop weighting scheme.

pub fn boundary_edges(&self) -> Vec<(usize, usize)>

Return boundary edges (edges shared by only one triangle).

pub fn euler_characteristic(&self) -> i64

Compute the Euler characteristic: V - E + F.

pub fn non_manifold_edge_count(&self) -> usize

Count non-manifold edges (shared by more than 2 triangles).

pub fn compute_laplacian_matrix(&self) -> HashMap<(usize, usize), f64>

Compute the cotangent Laplacian weights for each directed edge (i → j).

Returns a HashMap<(usize, usize), f64> mapping (i, j) to the symmetric cotangent weight w_{ij} = (cot α + cot β) / 2, where α and β are the angles opposite to edge (i,j) in the two incident faces.

This is the standard discretisation used in geometry processing for Laplace-Beltrami operators on triangulated surfaces.

pub fn compute_heat_kernel_signature(&self, t_values: &[f64]) -> Vec<Vec<f64>>

Compute the Heat Kernel Signature (HKS) descriptor for each vertex at a set of time scales t_values.

The HKS approximates the diagonal of the heat kernel K(x, x, t) using the cotangent Laplacian’s (normalized) diagonal weights. The full spectral decomposition is expensive, so this implementation uses a fast approximation: for each vertex i and time t, it computes

HKS(i, t) = exp(-t * D[i])

where D[i] is the sum of cotangent weights incident on vertex i (the diagonal of the stiffness matrix, normalised by the vertex area).

Returns a Vec<Vecf64> of shape [n_vertices][t_values.len()].

pub fn smooth_laplacian(&mut self, factor: f64, iterations: usize)

Iterative Laplacian smoothing using cotangent weights.

Each iteration moves vertex i towards the weighted average of its neighbours:

v_i’ = v_i + factor * Σ_j w_{ij} * (v_j - v_i) / Σ_j w_{ij}

Boundary vertices (those on edges shared by only one triangle) are kept fixed.

factor – step size in [0, 1]; iterations – number of passes.

Trait Implementations

impl Clone for TriangleMesh

fn clone(&self) -> TriangleMesh

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TriangleMesh

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Shape for TriangleMesh

fn bounding_box(&self) -> Aabb

Compute the axis-aligned bounding box of this shape (in local space).

fn support_point(&self, direction: &Vec3) -> Vec3

Compute the support point in the given direction (for GJK).

fn volume(&self) -> Real

Compute the volume of this shape.

fn center_of_mass(&self) -> Vec3

Compute the center of mass in local space.

fn inertia_tensor(&self, mass: Real) -> Mat3

Compute the inertia tensor for the given mass.

fn ray_cast( &self, ray_origin: &Vec3, ray_direction: &Vec3, max_toi: Real, ) -> Option<RayHit>

Cast a ray against this shape (in local space). Returns the first intersection within max_toi.

fn mass_properties(&self, density: Real) -> MassProperties

Compute full mass properties for a given density.