1use crate::*;
2use itertools::*;
3
4impl CreateBuffers for PolygonMesh {
5 #[inline(always)]
6 fn buffers(
7 &self,
8 vertex_usage: BufferUsages,
9 index_usage: BufferUsages,
10 device: &Device,
11 ) -> (BufferHandler, BufferHandler) {
12 let expanded = self.expands(|attr| AttrVertex {
13 position: attr.position.cast().unwrap().into(),
14 uv_coord: attr
15 .uv_coord
16 .and_then(|v| Some(v.cast()?.into()))
17 .unwrap_or([0.0, 0.0]),
18 normal: attr
19 .normal
20 .and_then(|v| Some(v.cast()?.into()))
21 .unwrap_or([0.0, 0.0, 0.0]),
22 });
23 let indices = expanded
24 .faces()
25 .triangle_iter()
26 .flatten()
27 .map(|x| x as u32)
28 .collect::<Vec<_>>();
29 (
30 BufferHandler::from_slice(expanded.attributes(), device, vertex_usage),
31 BufferHandler::from_slice(&indices, device, index_usage),
32 )
33 }
34}
35
36impl Instance for PolygonInstance {
37 type Shaders = PolygonShaders;
38 fn standard_shaders(creator: &InstanceCreator) -> PolygonShaders {
39 creator.polygon_shaders.clone()
40 }
41}
42
43impl ToInstance<PolygonInstance> for PolygonMesh {
44 type State = PolygonState;
45 #[inline(always)]
46 fn to_instance(
47 &self,
48 handler: &DeviceHandler,
49 shaders: &PolygonShaders,
50 state: &PolygonState,
51 ) -> PolygonInstance {
52 let (vb, ib) = self.buffers(BufferUsages::VERTEX, BufferUsages::INDEX, handler.device());
53 PolygonInstance {
54 polygon: (Arc::new(vb), Arc::new(ib)),
55 state: state.clone(),
56 shaders: shaders.clone(),
57 id: RenderID::gen(),
58 }
59 }
60}
61
62impl ToInstance<WireFrameInstance> for PolygonMesh {
63 type State = WireFrameState;
64 fn to_instance(
65 &self,
66 handler: &DeviceHandler,
67 shaders: &WireShaders,
68 state: &WireFrameState,
69 ) -> WireFrameInstance {
70 let device = handler.device();
71 let positions: Vec<[f32; 3]> = self
72 .positions()
73 .iter()
74 .map(|p| p.cast().unwrap().into())
75 .collect();
76 let mut strips = Vec::<u32>::new();
77 self.faces().face_iter().for_each(|face| {
78 face.iter().circular_tuple_windows().for_each(|(a, b)| {
79 strips.extend([a.pos as u32, b.pos as u32]);
80 });
81 });
82 let vb = BufferHandler::from_slice(&positions, device, BufferUsages::VERTEX);
83 let ib = BufferHandler::from_slice(&strips, device, BufferUsages::INDEX);
84 WireFrameInstance {
85 vertices: Arc::new(vb),
86 strips: Arc::new(ib),
87 state: state.clone(),
88 shaders: shaders.clone(),
89 id: RenderID::gen(),
90 }
91 }
92}
93
94impl CreateBuffers for StructuredMesh {
95 #[inline(always)]
96 fn buffers(
97 &self,
98 vertex_usage: BufferUsages,
99 index_usage: BufferUsages,
100 device: &Device,
101 ) -> (BufferHandler, BufferHandler) {
102 let mut vertices = Vec::new();
103 let (m, n) = (self.positions().len(), self.positions()[0].len());
104 iproduct!(0..m, 0..n).for_each(|(i, j)| {
105 vertices.push(AttrVertex {
106 position: self.positions()[i][j].cast().unwrap().into(),
107 uv_coord: match self.uv_division() {
108 Some((udiv, vdiv)) => [udiv[i] as f32, vdiv[j] as f32],
109 None => [0.0, 0.0],
110 },
111 normal: match self.normals() {
112 Some(normals) => normals[i][j].cast().unwrap().into(),
113 None => [0.0, 0.0, 0.0],
114 },
115 });
116 });
117 let mut indices = Vec::<u32>::new();
118 iproduct!(1..m, 1..n).for_each(|(i, j)| {
119 indices.extend([
120 ((i - 1) * n + j - 1) as u32,
121 (i * n + j - 1) as u32,
122 ((i - 1) * n + j) as u32,
123 ((i - 1) * n + j) as u32,
124 (i * n + j - 1) as u32,
125 (i * n + j) as u32,
126 ]);
127 });
128 (
129 BufferHandler::from_slice(&vertices, device, vertex_usage),
130 BufferHandler::from_slice(&indices, device, index_usage),
131 )
132 }
133}
134
135impl ToInstance<PolygonInstance> for StructuredMesh {
136 type State = PolygonState;
137 #[inline(always)]
138 fn to_instance(
139 &self,
140 handler: &DeviceHandler,
141 shaders: &PolygonShaders,
142 state: &PolygonState,
143 ) -> PolygonInstance {
144 let (vb, ib) = self.buffers(BufferUsages::VERTEX, BufferUsages::INDEX, handler.device());
145 PolygonInstance {
146 polygon: (Arc::new(vb), Arc::new(ib)),
147 state: state.clone(),
148 shaders: shaders.clone(),
149 id: RenderID::gen(),
150 }
151 }
152}
153
154impl ToInstance<WireFrameInstance> for StructuredMesh {
155 type State = WireFrameState;
156 fn to_instance(
157 &self,
158 handler: &DeviceHandler,
159 shaders: &WireShaders,
160 state: &WireFrameState,
161 ) -> WireFrameInstance {
162 let device = handler.device();
163 let positions: Vec<[f32; 3]> = self
164 .positions()
165 .iter()
166 .flatten()
167 .map(|p| p.cast().unwrap().into())
168 .collect();
169 let mut strips = Vec::<u32>::new();
170 let len = self.positions()[0].len() as u32;
171 for i in 1..positions.len() as u32 {
172 strips.push((i - 1) * len);
173 strips.push(i * len);
174 }
175 for j in 1..len {
176 strips.push(j - 1);
177 strips.push(j);
178 }
179 for i in 1..self.positions().len() as u32 {
180 for j in 1..len {
181 strips.push((i - 1) * len + j);
182 strips.push(i * len + j);
183 strips.push(i * len + (j - 1));
184 strips.push(i * len + j);
185 }
186 }
187 let vb = BufferHandler::from_slice(&positions, device, BufferUsages::VERTEX);
188 let ib = BufferHandler::from_slice(&strips, device, BufferUsages::INDEX);
189 WireFrameInstance {
190 vertices: Arc::new(vb),
191 strips: Arc::new(ib),
192 state: state.clone(),
193 shaders: shaders.clone(),
194 id: RenderID::gen(),
195 }
196 }
197}
198
199impl ToInstance<WireFrameInstance> for PolylineCurve<Point3> {
200 type State = WireFrameState;
201 fn to_instance(
202 &self,
203 handler: &DeviceHandler,
204 shaders: &WireShaders,
205 state: &WireFrameState,
206 ) -> WireFrameInstance {
207 let device = handler.device();
208 let positions: Vec<[f32; 3]> = self.iter().map(|p| p.cast().unwrap().into()).collect();
209 let strips: Vec<u32> = (1..positions.len())
210 .flat_map(|i| vec![i as u32 - 1, i as u32])
211 .collect();
212 let vb = BufferHandler::from_slice(&positions, device, BufferUsages::VERTEX);
213 let ib = BufferHandler::from_slice(&strips, device, BufferUsages::INDEX);
214 WireFrameInstance {
215 vertices: Arc::new(vb),
216 strips: Arc::new(ib),
217 state: state.clone(),
218 shaders: shaders.clone(),
219 id: RenderID::gen(),
220 }
221 }
222}
223
224impl ToInstance<WireFrameInstance> for Vec<PolylineCurve<Point3>> {
225 type State = WireFrameState;
226 fn to_instance(
227 &self,
228 handler: &DeviceHandler,
229 shaders: &WireShaders,
230 state: &WireFrameState,
231 ) -> WireFrameInstance {
232 let device = handler.device();
233 let positions: Vec<[f32; 3]> = self
234 .iter()
235 .flat_map(|poly| poly.iter())
236 .map(|p| p.cast().unwrap().into())
237 .collect();
238 let mut counter = 0;
239 let strips: Vec<u32> = self
240 .iter()
241 .flat_map(|poly| {
242 let len = counter as u32;
243 counter += poly.len();
244 (1..poly.len()).flat_map(move |i| vec![len + i as u32 - 1, len + i as u32])
245 })
246 .collect();
247 let vb = BufferHandler::from_slice(&positions, device, BufferUsages::VERTEX);
248 let ib = BufferHandler::from_slice(&strips, device, BufferUsages::INDEX);
249 WireFrameInstance {
250 vertices: Arc::new(vb),
251 strips: Arc::new(ib),
252 state: state.clone(),
253 shaders: shaders.clone(),
254 id: RenderID::gen(),
255 }
256 }
257}