use std::mem::size_of;
use sim_engine::{Color, Transform3d};
use crate::identity::{LogicEntity, WorldGeneration};
use super::{
MeshVisual3d, ThreeDExtractionError, ThreeDLimitResource, ThreeDRenderLimits,
extraction::check_limit,
};
#[derive(Debug, Clone, PartialEq)]
pub struct ResolvedMesh3d {
source: LogicEntity,
visual: MeshVisual3d,
}
impl ResolvedMesh3d {
pub const fn source(&self) -> LogicEntity {
self.source
}
pub const fn visual(&self) -> &MeshVisual3d {
&self.visual
}
pub const fn transform(&self) -> Transform3d {
self.visual.transform()
}
pub const fn color(&self) -> Color {
self.visual.color()
}
}
pub(crate) struct MeshSource {
entity: LogicEntity,
visual: MeshVisual3d,
}
impl MeshSource {
pub(crate) fn new(entity: LogicEntity, visual: &MeshVisual3d) -> Self {
Self {
entity,
visual: visual.clone(),
}
}
}
pub(super) fn extract_meshes(
resolved: &mut Vec<ResolvedMesh3d>,
generation: WorldGeneration,
limits: ThreeDRenderLimits,
mut triangles: usize,
sources: impl IntoIterator<Item = MeshSource>,
) -> Result<(), ThreeDExtractionError> {
let mut source_bytes = 0_usize;
let mut texture_source_bytes = 0_usize;
let mut texture_gpu_bytes = 0_usize;
for source in sources {
if !source.visual.visible() {
continue;
}
if source.entity.world_generation() != generation {
return Err(ThreeDExtractionError::StaleEntity {
source: source.entity,
});
}
check_limit(
ThreeDLimitResource::Meshes,
resolved.len().saturating_add(1),
limits.max_meshes(),
)?;
triangles = checked_sum(
triangles,
source.visual.asset().mesh().triangle_count(),
ThreeDLimitResource::Triangles,
limits.max_triangles(),
)?;
source_bytes = checked_sum(
source_bytes,
source.visual.asset().source_bytes(),
ThreeDLimitResource::MeshSourceBytes,
limits.max_mesh_source_bytes(),
)?;
if let Some(texture) = source.visual.texture() {
texture_source_bytes = checked_sum(
texture_source_bytes,
texture.asset().source_bytes(),
ThreeDLimitResource::TextureSourceBytes,
limits.max_texture_source_bytes(),
)?;
let texel_bytes =
texture
.texel_bytes()
.map_err(|_| ThreeDExtractionError::LimitExceeded {
resource: ThreeDLimitResource::TextureGpuBytes,
requested: u64::MAX,
limit: limits.max_texture_gpu_bytes() as u64,
})?;
texture_gpu_bytes = checked_sum(
texture_gpu_bytes,
texel_bytes,
ThreeDLimitResource::TextureGpuBytes,
limits.max_texture_gpu_bytes(),
)?;
}
if resolved.len() == resolved.capacity() {
resolved
.try_reserve_exact(1)
.map_err(|_| ThreeDExtractionError::AllocationFailed {
requested_bytes: size_of::<ResolvedMesh3d>(),
})?;
}
resolved.push(ResolvedMesh3d {
source: source.entity,
visual: source.visual,
});
}
resolved.sort_unstable_by_key(|record| record.source.stable_bits());
Ok(())
}
fn checked_sum(
current: usize,
additional: usize,
resource: ThreeDLimitResource,
limit: usize,
) -> Result<usize, ThreeDExtractionError> {
let sum = current
.checked_add(additional)
.ok_or(ThreeDExtractionError::LimitExceeded {
resource,
requested: u64::MAX,
limit: limit as u64,
})?;
check_limit(resource, sum, limit)?;
Ok(sum)
}