Skip to main content

sim_logic/rendering/three_d/
mesh_extraction.rs

1use 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/// One validated immutable mesh presentation and its managed source identity.
13#[derive(Debug, Clone, PartialEq)]
14pub struct ResolvedMesh3d {
15    source: LogicEntity,
16    visual: MeshVisual3d,
17}
18
19impl ResolvedMesh3d {
20    /// Returns the managed entity producing this mesh.
21    pub const fn source(&self) -> LogicEntity {
22        self.source
23    }
24    /// Returns the complete immutable-asset presentation value.
25    pub const fn visual(&self) -> &MeshVisual3d {
26        &self.visual
27    }
28    /// Returns the sampled transform without interpolation.
29    pub const fn transform(&self) -> Transform3d {
30        self.visual.transform()
31    }
32    /// Returns normalized straight-linear surface tint, including alpha.
33    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}