crater/primitives/

mesh.rs

//! `N = 3` [`TriangleMesh`] and [`MeshCollection`] types.

use crate::primitives::nvector::{NVector, cross, normalize_mut, sub};
use serde::{Deserialize, Serialize};

/// Represents a 3D vertex using a 64-bit float vector.
pub type Vertex = NVector<3>;

/// Represents a normal vector using a 64-bit float vector.
pub type Normal = NVector<3>;

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
/// Represents a triangle in 3D space.
pub struct Triangle {
    /// The three vertices that define the triangle.
    pub vertices: [Vertex; 3],
}

impl Triangle {
    /// Creates a new triangle from three vertices.
    pub fn new(vertices: [Vertex; 3]) -> Self {
        Self { vertices }
    }

    /// Calculates the normal vector of the triangle.
    pub fn normal(&self) -> Normal {
        let v0 = sub(&self.vertices[1], &self.vertices[0]);
        let v1 = sub(&self.vertices[2], &self.vertices[0]);
        let mut c = cross(&v0, &v1);
        normalize_mut(&mut c);
        c
    }
    /// Returns the first vertex of the triangle.
    pub fn p0(&self) -> Vertex {
        self.vertices[0]
    }
    /// Returns the second vertex of the triangle.
    pub fn p1(&self) -> Vertex {
        self.vertices[1]
    }
    /// Returns the third vertex of the triangle.
    pub fn p2(&self) -> Vertex {
        self.vertices[2]
    }
}

/// Represents a mesh of triangles in 3D space.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct TriangleMesh {
    /// Normal vectors for each triangle in the mesh.
    pub normals: Vec<Normal>,
    /// The triangles that make up the mesh.
    pub triangles: Vec<Triangle>,
}

impl TriangleMesh {
    /// Creates a new triangle mesh from a vector of triangles.
    pub fn new(triangles: Vec<Triangle>) -> Self {
        let normals = triangles.iter().map(|triangle| triangle.normal()).collect();
        Self { normals, triangles }
    }
    /// Returns the number of triangles in the mesh.
    pub fn num_triangles(&self) -> usize {
        self.triangles.len()
    }
    /// Returns the number of vertices in the mesh.
    pub fn num_vertices(&self) -> usize {
        self.triangles.len() * 3
    }
    /// Returns the number of normal vectors in the mesh.
    pub fn num_normals(&self) -> usize {
        self.normals.len()
    }
    /// A slice of all the vertices in the mesh.
    pub fn vertices(&self) -> &[Vertex] {
        let ptr = self.triangles.as_ptr() as *const Vertex;
        unsafe { std::slice::from_raw_parts(ptr, self.num_vertices()) }
    }
    /// A slice of all the normal vectors in the mesh.
    pub fn normals(&self) -> &[Normal] {
        self.normals.as_slice()
    }
}

/// Represents a collection of [`TriangleMesh`] objects.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct MeshCollection {
    pub meshes: Vec<TriangleMesh>,
}

impl MeshCollection {
    /// Creates a new [`MeshCollection`] from a vector of [`TriangleMesh`]es
    pub fn new(meshes: Vec<TriangleMesh>) -> Self {
        Self { meshes }
    }
    /// Returns the number of meshes in the collection.
    pub fn num_meshes(&self) -> usize {
        self.meshes.len()
    }
    /// Returns the number of triangles in the collection.
    pub fn num_triangles(&self) -> usize {
        self.meshes.iter().map(|m| m.num_triangles()).sum()
    }
    /// Returns the number of vertices in the collection.
    pub fn num_vertices(&self) -> usize {
        self.meshes.iter().map(|m| m.num_vertices()).sum()
    }
    /// Returns the number of normal vectors in the collection.
    pub fn num_normals(&self) -> usize {
        self.meshes.iter().map(|m| m.num_normals()).sum()
    }
    /// Returns an iterator over all the [`Triangle`]s in the collection.
    pub fn triangles(&self) -> impl Iterator<Item = Triangle> + '_ {
        self.meshes.iter().flat_map(|m| m.triangles.iter().copied())
    }
    /// Returns an iterator over all the [`Vertex`] objects in the collection.
    pub fn vertices(&self) -> impl Iterator<Item = Vertex> + '_ {
        self.meshes
            .iter()
            .flat_map(|m| m.triangles.iter().flat_map(|t| t.vertices.iter().copied()))
    }
    /// Returns an iterator over all the [`Normal`]s in the collection.
    pub fn normals(&self) -> impl Iterator<Item = Normal> + '_ {
        self.meshes.iter().flat_map(|m| m.normals.iter().copied())
    }
    /// Returns the index of the first [`Vertex`] of a given [`TriangleMesh`] in the collection.
    pub fn index_of_first_vertex(&self, mesh_index: usize) -> usize {
        self.meshes
            .iter()
            .take(mesh_index)
            .map(|m| m.num_vertices())
            .sum()
    }
}

impl From<MeshCollection> for TriangleMesh {
    fn from(mesh_collection: MeshCollection) -> Self {
        let normals = mesh_collection
            .meshes
            .iter()
            .flat_map(|mesh| mesh.normals.clone())
            .collect();
        let triangles = mesh_collection
            .meshes
            .iter()
            .flat_map(|mesh| mesh.triangles.clone())
            .collect();
        Self { normals, triangles }
    }
}

impl From<TriangleMesh> for MeshCollection {
    fn from(triangle_mesh: TriangleMesh) -> Self {
        let meshes = vec![triangle_mesh];
        Self { meshes }
    }
}

impl<I> From<I> for MeshCollection
where
    I: IntoIterator<Item = TriangleMesh>,
{
    fn from(meshes: I) -> Self {
        let meshes = meshes.into_iter().collect();
        Self { meshes }
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_triangle_creation() {
        let vertices = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]];
        let triangle = Triangle::new(vertices);
        assert_eq!(triangle.vertices, vertices);
    }

    #[test]
    fn test_triangle_normal() {
        let triangle = Triangle::new([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]);
        let expected_normal = [0.0, 0.0, 1.0];
        assert_eq!(triangle.normal(), expected_normal);
    }

    #[test]
    fn test_triangle_mesh_creation() {
        let triangle1 = Triangle::new([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]);
        let triangle2 = Triangle::new([[1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 0.0]]);
        let triangles = vec![triangle1, triangle2];
        let mesh = TriangleMesh::new(triangles);

        assert_eq!(mesh.normals.len(), 2);
        assert_eq!(mesh.triangles.len(), 2);
    }

    #[test]
    fn test_triangle_mesh_normals() {
        let triangle1 = Triangle::new([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]);
        let triangle2 = Triangle::new([[1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 0.0]]);
        let triangles = vec![triangle1, triangle2];
        let mesh = TriangleMesh::new(triangles);

        assert_eq!(mesh.normals, vec![[0.0, 0.0, 1.0], [0.0, 0.0, 1.0]]);
    }

    #[test]
    fn test_mesh_collection() {
        let triangle1 = Triangle::new([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]);
        let triangle2 = Triangle::new([[1.0, 0.0, 0.0], [1.0, 1.0, 0.0], [0.0, 1.0, 0.0]]);
        let triangles1 = vec![triangle1];
        let triangles2 = vec![triangle2];
        let mesh1 = TriangleMesh::new(triangles1);
        let mesh2 = TriangleMesh::new(triangles2);
        let collection = MeshCollection::new(vec![mesh1, mesh2]);
        let triangles: Vec<_> = collection.triangles().collect();
        assert_eq!(triangles.len(), 2);
        let vertices: Vec<_> = collection.vertices().collect();
        assert_eq!(vertices.len(), 6);
        let normals: Vec<_> = collection.normals().collect();
        assert_eq!(normals.len(), 2);
    }
}