thdmaker 0.0.4

A comprehensive 3D file format library supporting AMF, STL, 3MF and other 3D manufacturing formats
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::iter;
use std::fmt::{Display, Formatter, Result};

/// Triangle mesh.
#[derive(Debug, Clone, Default)]
pub struct Mesh {
    /// STL file format.
    pub format: Format,
    /// Name of the mesh, ascii format only.
    pub name: Option<String>,
    /// Start index of the mesh in the STL file.
    pub start: usize,
    /// Mesh all triangle vertices for indices.
    pub vertices: Vec<Vertex>,
    /// Mesh triangle vertex indices.
    pub indices: Vec<[usize; 3]>,
    /// Mesh triangle normals.
    pub normals: Vec<Vertex>,
    /// Header of the mesh, binary format only.
    pub header: Option<[u8; 80]>,
    /// Color of the mesh, binary format only.
    pub color: Option<Color>,
    /// Mesh triangle colors, binary format only.
    pub colors: Option<Vec<Color>>,
    /// Mesh triangle attributes, binary format only.
    pub attrs: Option<Vec<u16>>,
}

impl Mesh {
    pub fn triangles(&self) -> Vec<Triangle> {
        self.indices.iter().enumerate().map(|(i, v)| Triangle {
            normal: self.normals[i],
            vertices: [self.vertices[v[0]], self.vertices[v[1]], self.vertices[v[2]]],
        }).collect()
    }

    pub fn get_positions(&self) -> Vec<[f32; 3]> {
        self.vertices.iter().map(|v| {
            // Convert Z-up coordinates to Y-up coordinates
            // Z-up: (x, y, z) -> Y-up: (x, z, -y)
            [v.x, v.z, -v.y]
        }).collect()
    }

    pub fn get_normals(&self) -> Vec<[f32; 3]> {
        self.normals.iter().flat_map(|v| {
            // Convert Z-up coordinates to Y-up coordinates
            // Z-up: (x, y, z) -> Y-up: (x, z, -y)
            iter::repeat([v.x, v.z, -v.y]).take(3)
        }).collect()
    }

    pub fn get_indices(&self) -> Vec<u32> {
        self.indices.iter().flat_map(|v| [v[0] as u32, v[1] as u32, v[2] as u32]).collect()
    }
}

/// STL file format.
#[derive(Debug, Clone, Default)]
pub enum Format {
    #[default]
    Ascii,
    Binary,
}

impl Display for Format {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        match self {
            Format::Ascii => write!(f, "ascii"),
            Format::Binary => write!(f, "binary"),
        }
    }
}

/// A triangle in a 3D mesh.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Triangle {
    /// Normal vector of the Triangle.
    pub normal: Vertex,
    /// The three vertices of the Triangle.
    pub vertices: [Vertex; 3],
}

/// A vertex in a 3D mesh.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Vertex {
    /// X coordinate of the Vertex.
    pub x: f32,
    /// Y coordinate of the Vertex.
    pub y: f32,
    /// Z coordinate of the Vertex.
    pub z: f32,
}

impl From<&[f32; 3]> for Vertex {
    fn from(xyz: &[f32; 3]) -> Self {
        Self {
            x: xyz[0],
            y: xyz[1],
            z: xyz[2],
        }
    }
}

impl From<&Vertex> for [f32; 3] {
    fn from(v: &Vertex) -> Self {
        [v.x, v.y, v.z]
    }
}

/// Color in RGBA format.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Color {
    /// Red (0-255)
    pub r: u8,
    /// Green (0-255)
    pub g: u8,
    /// Blue (0-255)
    pub b: u8,
    /// Alpha (0-255, 255 = fully opaque)
    pub a: u8,
}

/// Convert a 4-byte array to a Color.
impl From<&[u8; 4]> for Color {
    fn from(rgba: &[u8; 4]) -> Self {
        Self {
            r: rgba[0],
            g: rgba[1],
            b: rgba[2],
            a: rgba[3],
        }
    }
}