sim_logic/rendering/three_d/
mesh_extraction.rs1use std::mem::size_of;
2
3use sim_engine::{Color, Transform3d};
4
5use crate::identity::{LogicEntity, WorldGeneration};
6
7use super::{
8 MeshVisual3d, ThreeDExtractionError, ThreeDLimitResource, ThreeDRenderLimits,
9 extraction::check_limit,
10};
11
12#[derive(Debug, Clone, PartialEq)]
14pub struct ResolvedMesh3d {
15 source: LogicEntity,
16 visual: MeshVisual3d,
17}
18
19impl ResolvedMesh3d {
20 pub const fn source(&self) -> LogicEntity {
22 self.source
23 }
24 pub const fn visual(&self) -> &MeshVisual3d {
26 &self.visual
27 }
28 pub const fn transform(&self) -> Transform3d {
30 self.visual.transform()
31 }
32 pub const fn color(&self) -> Color {
34 self.visual.color()
35 }
36}
37
38pub(crate) struct MeshSource {
39 entity: LogicEntity,
40 visual: MeshVisual3d,
41}
42
43impl MeshSource {
44 pub(crate) fn new(entity: LogicEntity, visual: &MeshVisual3d) -> Self {
45 Self {
46 entity,
47 visual: visual.clone(),
48 }
49 }
50}
51
52pub(super) fn extract_meshes(
53 resolved: &mut Vec<ResolvedMesh3d>,
54 generation: WorldGeneration,
55 limits: ThreeDRenderLimits,
56 mut triangles: usize,
57 sources: impl IntoIterator<Item = MeshSource>,
58) -> Result<(), ThreeDExtractionError> {
59 let mut source_bytes = 0_usize;
60 let mut texture_source_bytes = 0_usize;
61 let mut texture_gpu_bytes = 0_usize;
62 for source in sources {
63 if !source.visual.visible() {
64 continue;
65 }
66 if source.entity.world_generation() != generation {
67 return Err(ThreeDExtractionError::StaleEntity {
68 source: source.entity,
69 });
70 }
71 check_limit(
72 ThreeDLimitResource::Meshes,
73 resolved.len().saturating_add(1),
74 limits.max_meshes(),
75 )?;
76 triangles = checked_sum(
77 triangles,
78 source.visual.asset().mesh().triangle_count(),
79 ThreeDLimitResource::Triangles,
80 limits.max_triangles(),
81 )?;
82 source_bytes = checked_sum(
83 source_bytes,
84 source.visual.asset().source_bytes(),
85 ThreeDLimitResource::MeshSourceBytes,
86 limits.max_mesh_source_bytes(),
87 )?;
88 if let Some(texture) = source.visual.texture() {
89 texture_source_bytes = checked_sum(
90 texture_source_bytes,
91 texture.asset().source_bytes(),
92 ThreeDLimitResource::TextureSourceBytes,
93 limits.max_texture_source_bytes(),
94 )?;
95 let texel_bytes =
96 texture
97 .texel_bytes()
98 .map_err(|_| ThreeDExtractionError::LimitExceeded {
99 resource: ThreeDLimitResource::TextureGpuBytes,
100 requested: u64::MAX,
101 limit: limits.max_texture_gpu_bytes() as u64,
102 })?;
103 texture_gpu_bytes = checked_sum(
104 texture_gpu_bytes,
105 texel_bytes,
106 ThreeDLimitResource::TextureGpuBytes,
107 limits.max_texture_gpu_bytes(),
108 )?;
109 }
110 if resolved.len() == resolved.capacity() {
111 resolved
112 .try_reserve_exact(1)
113 .map_err(|_| ThreeDExtractionError::AllocationFailed {
114 requested_bytes: size_of::<ResolvedMesh3d>(),
115 })?;
116 }
117 resolved.push(ResolvedMesh3d {
118 source: source.entity,
119 visual: source.visual,
120 });
121 }
122 resolved.sort_unstable_by_key(|record| record.source.stable_bits());
123 Ok(())
124}
125
126fn checked_sum(
127 current: usize,
128 additional: usize,
129 resource: ThreeDLimitResource,
130 limit: usize,
131) -> Result<usize, ThreeDExtractionError> {
132 let sum = current
133 .checked_add(additional)
134 .ok_or(ThreeDExtractionError::LimitExceeded {
135 resource,
136 requested: u64::MAX,
137 limit: limit as u64,
138 })?;
139 check_limit(resource, sum, limit)?;
140 Ok(sum)
141}