egraphics_core/
triangle_mesh.rs

1use crate::Error::NoElements;
2use crate::{Error, Triangle, Vertex};
3
4#[derive(Clone, Debug, PartialEq)]
5pub struct TriangleMesh {
6    triangles: Vec<Triangle>,
7}
8
9impl TriangleMesh {
10    pub fn new(triangles: Vec<Triangle>) -> Result<Self, Error> {
11        if triangles.is_empty() {
12            return Err(NoElements);
13        }
14
15        Ok(Self { triangles })
16    }
17
18    fn buffer_length(&self) -> u32 {
19        self.triangles.iter().map(|x| x.buffer_length()).sum()
20    }
21
22    fn number_of_vertices(&self) -> usize {
23        self.triangles.iter().map(|x| x.len()).sum()
24    }
25
26    pub fn is_empty(&self) -> bool {
27        self.triangles.is_empty()
28    }
29
30    pub fn all_vertices(&self) -> Vec<Vertex> {
31        //let a = self.triangles.iter().map(|x| x.vertices).;
32
33        let mut all_vertices: Vec<Vertex> = Vec::new();
34        //let a = self.triangles.into_iter().map(|x| x.get_vertices()).flatten();
35        for triangle in &self.triangles {
36            all_vertices.extend(triangle.get_vertices());
37        }
38
39        //println!("all vertices");
40        all_vertices
41    }
42
43    pub fn get_min(&self) -> nalgebra::Point3<f32> {
44        let vertices: Vec<nalgebra::Point3<f32>> =
45            self.all_vertices().iter().map(|v| v.position).collect();
46
47        let min_x = vertices
48            .iter()
49            .map(|p| p.x)
50            .fold(f32::INFINITY, |a, b| a.min(b));
51        let min_y = vertices
52            .iter()
53            .map(|p| p.y)
54            .fold(f32::INFINITY, |a, b| a.min(b));
55        let min_z = vertices
56            .iter()
57            .map(|p| p.z)
58            .fold(f32::INFINITY, |a, b| a.min(b));
59
60        nalgebra::Point3::new(min_x, min_y, min_z)
61    }
62
63    pub fn get_max(&self) -> nalgebra::Point3<f32> {
64        let vertices: Vec<nalgebra::Point3<f32>> =
65            self.all_vertices().iter().map(|v| v.position).collect();
66
67        let max_x = vertices
68            .iter()
69            .map(|p| p.x)
70            .fold(f32::NEG_INFINITY, |a, b| a.max(b));
71        let max_y = vertices
72            .iter()
73            .map(|p| p.y)
74            .fold(f32::NEG_INFINITY, |a, b| a.max(b));
75        let max_z = vertices
76            .iter()
77            .map(|p| p.z)
78            .fold(f32::NEG_INFINITY, |a, b| a.max(b));
79
80        nalgebra::Point3::new(max_x, max_y, max_z)
81    }
82}