sim_logic/rendering/three_d/
extraction.rs1use std::{error::Error, fmt, mem::size_of};
2
3use sim_engine::{Color, Transform3d};
4
5use crate::identity::{LogicEntity, WorldGeneration};
6
7use super::{CuboidVisual3d, CuboidVisualError, MeshSource, ResolvedMesh3d, View3d, View3dError};
8
9#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
17pub struct ThreeDRenderLimits {
18 max_cuboids: usize,
19 max_triangles: usize,
20 max_target_pixels: u64,
21 max_meshes: usize,
22 max_mesh_source_bytes: usize,
23 max_texture_source_bytes: usize,
24 max_texture_gpu_bytes: usize,
25}
26
27impl ThreeDRenderLimits {
28 pub const fn new(max_cuboids: usize, max_triangles: usize, max_target_pixels: u64) -> Self {
30 Self {
31 max_cuboids,
32 max_triangles,
33 max_target_pixels,
34 max_meshes: 0,
35 max_mesh_source_bytes: 0,
36 max_texture_source_bytes: 0,
37 max_texture_gpu_bytes: 0,
38 }
39 }
40
41 pub const fn max_cuboids(self) -> usize {
43 self.max_cuboids
44 }
45
46 pub const fn max_triangles(self) -> usize {
48 self.max_triangles
49 }
50
51 pub const fn max_target_pixels(self) -> u64 {
53 self.max_target_pixels
54 }
55
56 pub const fn with_mesh_limits(mut self, max_meshes: usize, max_source_bytes: usize) -> Self {
63 self.max_meshes = max_meshes;
64 self.max_mesh_source_bytes = max_source_bytes;
65 self
66 }
67
68 pub const fn max_meshes(self) -> usize {
70 self.max_meshes
71 }
72
73 pub const fn max_mesh_source_bytes(self) -> usize {
75 self.max_mesh_source_bytes
76 }
77
78 pub const fn with_texture_limits(
83 mut self,
84 max_source_bytes: usize,
85 max_gpu_bytes: usize,
86 ) -> Self {
87 self.max_texture_source_bytes = max_source_bytes;
88 self.max_texture_gpu_bytes = max_gpu_bytes;
89 self
90 }
91
92 pub const fn max_texture_source_bytes(self) -> usize {
94 self.max_texture_source_bytes
95 }
96
97 pub const fn max_texture_gpu_bytes(self) -> usize {
99 self.max_texture_gpu_bytes
100 }
101}
102
103#[derive(Debug, Clone, Copy, PartialEq, Eq)]
105pub enum ThreeDLimitResource {
106 Cuboids,
108 Meshes,
110 MeshSourceBytes,
112 TextureSourceBytes,
114 TextureGpuBytes,
116 Triangles,
118 TargetPixels,
120}
121
122#[derive(Debug, Clone, Copy, PartialEq)]
124pub struct ResolvedCuboid3d {
125 source: LogicEntity,
126 visual: CuboidVisual3d,
127}
128
129impl ResolvedCuboid3d {
130 pub const fn source(self) -> LogicEntity {
132 self.source
133 }
134
135 pub const fn visual(self) -> CuboidVisual3d {
137 self.visual
138 }
139
140 pub const fn transform(self) -> Transform3d {
142 self.visual.transform()
143 }
144
145 pub const fn color(self) -> Color {
147 self.visual.color()
148 }
149}
150
151#[derive(Debug, Clone, Copy)]
156pub struct ThreeDSnapshot<'a> {
157 view: View3d,
158 cuboids: &'a [ResolvedCuboid3d],
159 meshes: &'a [ResolvedMesh3d],
160}
161
162impl<'a> ThreeDSnapshot<'a> {
163 pub const fn view(self) -> View3d {
165 self.view
166 }
167
168 pub const fn cuboids(self) -> &'a [ResolvedCuboid3d] {
170 self.cuboids
171 }
172
173 pub const fn meshes(self) -> &'a [ResolvedMesh3d] {
175 self.meshes
176 }
177
178 pub fn source_triangle_count(self) -> usize {
180 self.meshes
181 .iter()
182 .fold(self.cuboids.len().saturating_mul(12), |sum, mesh| {
183 sum.saturating_add(mesh.visual().asset().mesh().triangle_count())
184 })
185 }
186}
187
188#[derive(Debug, Clone, Copy)]
189pub(crate) struct CuboidSource {
190 entity: LogicEntity,
191 visual: CuboidVisual3d,
192}
193
194impl CuboidSource {
195 pub(crate) const fn new(entity: LogicEntity, visual: &CuboidVisual3d) -> Self {
196 Self {
197 entity,
198 visual: *visual,
199 }
200 }
201}
202
203pub(crate) struct ThreeDExtractionBuffer {
204 view: Option<View3d>,
205 resolved: Vec<ResolvedCuboid3d>,
206 pub(super) meshes: Vec<ResolvedMesh3d>,
207}
208
209impl ThreeDExtractionBuffer {
210 pub(crate) const fn new() -> Self {
211 Self {
212 view: None,
213 resolved: Vec::new(),
214 meshes: Vec::new(),
215 }
216 }
217
218 pub(crate) fn clear(&mut self) {
219 self.view = None;
220 self.resolved.clear();
221 self.meshes.clear();
222 }
223
224 pub(crate) fn extract(
225 &mut self,
226 generation: WorldGeneration,
227 limits: ThreeDRenderLimits,
228 view: Option<View3d>,
229 sources: impl IntoIterator<Item = CuboidSource>,
230 ) -> Result<(), ThreeDExtractionError> {
231 self.clear();
232 let Some(view) = view.filter(|view| view.enabled()) else {
233 return Ok(());
234 };
235 view.validate().map_err(ThreeDExtractionError::View)?;
236 for source in sources {
237 if !source.visual.visible() {
238 continue;
239 }
240 if source.entity.world_generation() != generation {
241 return Err(ThreeDExtractionError::StaleEntity {
242 source: source.entity,
243 });
244 }
245 let count = self.resolved.len().saturating_add(1);
246 check_limit(ThreeDLimitResource::Cuboids, count, limits.max_cuboids)?;
247 let triangles = count
248 .checked_mul(12)
249 .ok_or(ThreeDExtractionError::LimitExceeded {
250 resource: ThreeDLimitResource::Triangles,
251 requested: u64::MAX,
252 limit: limits.max_triangles as u64,
253 })?;
254 check_limit(
255 ThreeDLimitResource::Triangles,
256 triangles,
257 limits.max_triangles,
258 )?;
259 source
260 .visual
261 .validate()
262 .map_err(|error| ThreeDExtractionError::Cuboid {
263 source: source.entity,
264 error,
265 })?;
266 if self.resolved.len() == self.resolved.capacity() {
267 self.resolved.try_reserve_exact(1).map_err(|_| {
268 ThreeDExtractionError::AllocationFailed {
269 requested_bytes: size_of::<ResolvedCuboid3d>(),
270 }
271 })?;
272 }
273 self.resolved.push(ResolvedCuboid3d {
274 source: source.entity,
275 visual: source.visual,
276 });
277 }
278 self.resolved
279 .sort_unstable_by_key(|record| record.source.stable_bits());
280 self.view = Some(view);
281 Ok(())
282 }
283
284 pub(crate) fn snapshot(&self) -> Option<ThreeDSnapshot<'_>> {
285 self.view.map(|view| ThreeDSnapshot {
286 view,
287 cuboids: &self.resolved,
288 meshes: &self.meshes,
289 })
290 }
291
292 pub(crate) fn resolved(&self) -> &[ResolvedCuboid3d] {
293 &self.resolved
294 }
295
296 pub(crate) fn extract_meshes(
297 &mut self,
298 generation: WorldGeneration,
299 limits: ThreeDRenderLimits,
300 sources: impl IntoIterator<Item = MeshSource>,
301 ) -> Result<(), ThreeDExtractionError> {
302 if self.view.is_none() {
303 return Ok(());
304 }
305 if let Err(error) = super::mesh_extraction::extract_meshes(
306 &mut self.meshes,
307 generation,
308 limits,
309 self.resolved.len().saturating_mul(12),
310 sources,
311 ) {
312 self.view = None;
313 return Err(error);
314 }
315 Ok(())
316 }
317}
318
319pub(super) fn check_limit(
320 resource: ThreeDLimitResource,
321 requested: usize,
322 limit: usize,
323) -> Result<(), ThreeDExtractionError> {
324 if requested > limit {
325 return Err(ThreeDExtractionError::LimitExceeded {
326 resource,
327 requested: requested as u64,
328 limit: limit as u64,
329 });
330 }
331 Ok(())
332}
333
334#[derive(Debug, Clone, Copy, PartialEq)]
336pub enum ThreeDExtractionError {
337 StaleEntity {
339 source: LogicEntity,
341 },
342 LimitExceeded {
344 resource: ThreeDLimitResource,
346 requested: u64,
348 limit: u64,
350 },
351 View(View3dError),
353 Cuboid {
355 source: LogicEntity,
357 error: CuboidVisualError,
359 },
360 AllocationFailed {
362 requested_bytes: usize,
364 },
365}
366
367impl fmt::Display for ThreeDExtractionError {
368 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
369 match self {
370 Self::StaleEntity { source } => {
371 write!(formatter, "3D source {source:?} is from a stale World")
372 }
373 Self::LimitExceeded {
374 resource,
375 requested,
376 limit,
377 } => write!(
378 formatter,
379 "3D {resource:?} requested {requested}, exceeding {limit}"
380 ),
381 Self::View(error) => write!(formatter, "3D view extraction failed: {error}"),
382 Self::Cuboid { source, error } => {
383 write!(formatter, "3D cuboid {source:?} extraction failed: {error}")
384 }
385 Self::AllocationFailed { requested_bytes } => write!(
386 formatter,
387 "3D extraction could not reserve {requested_bytes} additional bytes"
388 ),
389 }
390 }
391}
392
393impl Error for ThreeDExtractionError {
394 fn source(&self) -> Option<&(dyn Error + 'static)> {
395 match self {
396 Self::View(error) => Some(error),
397 Self::Cuboid { error, .. } => Some(error),
398 _ => None,
399 }
400 }
401}