Skip to main content

gltf_kun/graph/gltf/
mesh.rs

1use petgraph::graph::NodeIndex;
2
3use crate::graph::{Edge, Extensions, Graph, GraphNodeEdges, GraphNodeWeight, Weight};
4
5use super::{GltfEdge, GltfWeight, Node, node::NodeEdge, primitive::Primitive};
6
7#[derive(Clone, Debug, PartialEq, Eq)]
8pub enum MeshEdge {
9    Primitive,
10}
11
12impl<'a> TryFrom<&'a Edge> for &'a MeshEdge {
13    type Error = ();
14    fn try_from(value: &'a Edge) -> Result<Self, Self::Error> {
15        match value {
16            Edge::Gltf(GltfEdge::Mesh(edge)) => Ok(edge),
17            _ => Err(()),
18        }
19    }
20}
21
22impl From<MeshEdge> for Edge {
23    fn from(edge: MeshEdge) -> Self {
24        Self::Gltf(GltfEdge::Mesh(edge))
25    }
26}
27
28#[derive(Clone, Debug, Default)]
29pub struct MeshWeight {
30    pub name: Option<String>,
31    pub extras: gltf::json::Extras,
32
33    pub weights: Vec<f32>,
34}
35
36impl From<MeshWeight> for Weight {
37    fn from(weight: MeshWeight) -> Self {
38        Self::Gltf(GltfWeight::Mesh(weight))
39    }
40}
41
42impl<'a> TryFrom<&'a Weight> for &'a MeshWeight {
43    type Error = ();
44    fn try_from(value: &'a Weight) -> Result<Self, Self::Error> {
45        match value {
46            Weight::Gltf(GltfWeight::Mesh(weight)) => Ok(weight),
47            _ => Err(()),
48        }
49    }
50}
51
52impl<'a> TryFrom<&'a mut Weight> for &'a mut MeshWeight {
53    type Error = ();
54    fn try_from(value: &'a mut Weight) -> Result<Self, Self::Error> {
55        match value {
56            Weight::Gltf(GltfWeight::Mesh(weight)) => Ok(weight),
57            _ => Err(()),
58        }
59    }
60}
61
62#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
63pub struct Mesh(pub NodeIndex);
64
65impl From<NodeIndex> for Mesh {
66    fn from(index: NodeIndex) -> Self {
67        Self(index)
68    }
69}
70
71impl From<Mesh> for NodeIndex {
72    fn from(mesh: Mesh) -> Self {
73        mesh.0
74    }
75}
76
77impl GraphNodeWeight<MeshWeight> for Mesh {}
78impl GraphNodeEdges for Mesh {}
79impl Extensions for Mesh {}
80
81impl Mesh {
82    /// Returns any Nodes using this Mesh.
83    pub fn nodes(&self, graph: &Graph) -> Vec<Node> {
84        self.edge_sources(graph, &NodeEdge::Mesh)
85    }
86
87    pub fn primitives(&self, graph: &Graph) -> Vec<Primitive> {
88        self.edge_targets(graph, &MeshEdge::Primitive)
89    }
90    pub fn add_primitive(&self, graph: &mut Graph, primitive: &Primitive) {
91        self.add_edge_target(graph, MeshEdge::Primitive, *primitive);
92    }
93    pub fn remove_primitive(&self, graph: &mut Graph, primitive: &Primitive) {
94        self.remove_edge_target(graph, MeshEdge::Primitive, *primitive);
95    }
96    pub fn create_primitive(&self, graph: &mut Graph) -> Primitive {
97        self.create_edge_target(graph, MeshEdge::Primitive)
98    }
99}
100
101#[cfg(test)]
102mod tests {
103    use super::*;
104
105    #[test]
106    fn nodes() {
107        let mut graph = Graph::default();
108
109        let mesh = Mesh::new(&mut graph);
110        let node_1 = Node::new(&mut graph);
111        let node_2 = Node::new(&mut graph);
112
113        node_1.set_mesh(&mut graph, Some(mesh));
114        assert_eq!(mesh.nodes(&graph), vec![node_1]);
115
116        node_2.set_mesh(&mut graph, Some(mesh));
117        assert_eq!(mesh.nodes(&graph), vec![node_1, node_2]);
118
119        node_1.set_mesh(&mut graph, None);
120        assert_eq!(mesh.nodes(&graph), vec![node_2]);
121
122        node_2.set_mesh(&mut graph, None);
123        assert!(mesh.nodes(&graph).is_empty());
124    }
125
126    #[test]
127    fn primitives() {
128        let mut graph = Graph::default();
129
130        let mesh = Mesh::new(&mut graph);
131        let primitive_1 = Primitive::new(&mut graph);
132        let primitive_2 = Primitive::new(&mut graph);
133
134        mesh.add_primitive(&mut graph, &primitive_1);
135        assert_eq!(mesh.primitives(&graph), vec![primitive_1]);
136
137        mesh.add_primitive(&mut graph, &primitive_2);
138        assert_eq!(mesh.primitives(&graph), vec![primitive_1, primitive_2]);
139
140        mesh.remove_primitive(&mut graph, &primitive_1);
141        assert_eq!(mesh.primitives(&graph), vec![primitive_2]);
142
143        mesh.remove_primitive(&mut graph, &primitive_2);
144        assert!(mesh.primitives(&graph).is_empty());
145    }
146}