gltf_kun/graph/gltf/
mesh.rs1use 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 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}