use std::{error::Error, fmt, mem::size_of};
use sim_engine::{Color, Transform3d};
use crate::identity::{LogicEntity, WorldGeneration};
use super::{CuboidVisual3d, CuboidVisualError, MeshSource, ResolvedMesh3d, View3d, View3dError};
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct ThreeDRenderLimits {
max_cuboids: usize,
max_triangles: usize,
max_target_pixels: u64,
max_meshes: usize,
max_mesh_source_bytes: usize,
max_texture_source_bytes: usize,
max_texture_gpu_bytes: usize,
}
impl ThreeDRenderLimits {
pub const fn new(max_cuboids: usize, max_triangles: usize, max_target_pixels: u64) -> Self {
Self {
max_cuboids,
max_triangles,
max_target_pixels,
max_meshes: 0,
max_mesh_source_bytes: 0,
max_texture_source_bytes: 0,
max_texture_gpu_bytes: 0,
}
}
pub const fn max_cuboids(self) -> usize {
self.max_cuboids
}
pub const fn max_triangles(self) -> usize {
self.max_triangles
}
pub const fn max_target_pixels(self) -> u64 {
self.max_target_pixels
}
pub const fn with_mesh_limits(mut self, max_meshes: usize, max_source_bytes: usize) -> Self {
self.max_meshes = max_meshes;
self.max_mesh_source_bytes = max_source_bytes;
self
}
pub const fn max_meshes(self) -> usize {
self.max_meshes
}
pub const fn max_mesh_source_bytes(self) -> usize {
self.max_mesh_source_bytes
}
pub const fn with_texture_limits(
mut self,
max_source_bytes: usize,
max_gpu_bytes: usize,
) -> Self {
self.max_texture_source_bytes = max_source_bytes;
self.max_texture_gpu_bytes = max_gpu_bytes;
self
}
pub const fn max_texture_source_bytes(self) -> usize {
self.max_texture_source_bytes
}
pub const fn max_texture_gpu_bytes(self) -> usize {
self.max_texture_gpu_bytes
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ThreeDLimitResource {
Cuboids,
Meshes,
MeshSourceBytes,
TextureSourceBytes,
TextureGpuBytes,
Triangles,
TargetPixels,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ResolvedCuboid3d {
source: LogicEntity,
visual: CuboidVisual3d,
}
impl ResolvedCuboid3d {
pub const fn source(self) -> LogicEntity {
self.source
}
pub const fn visual(self) -> CuboidVisual3d {
self.visual
}
pub const fn transform(self) -> Transform3d {
self.visual.transform()
}
pub const fn color(self) -> Color {
self.visual.color()
}
}
#[derive(Debug, Clone, Copy)]
pub struct ThreeDSnapshot<'a> {
view: View3d,
cuboids: &'a [ResolvedCuboid3d],
meshes: &'a [ResolvedMesh3d],
}
impl<'a> ThreeDSnapshot<'a> {
pub const fn view(self) -> View3d {
self.view
}
pub const fn cuboids(self) -> &'a [ResolvedCuboid3d] {
self.cuboids
}
pub const fn meshes(self) -> &'a [ResolvedMesh3d] {
self.meshes
}
pub fn source_triangle_count(self) -> usize {
self.meshes
.iter()
.fold(self.cuboids.len().saturating_mul(12), |sum, mesh| {
sum.saturating_add(mesh.visual().asset().mesh().triangle_count())
})
}
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct CuboidSource {
entity: LogicEntity,
visual: CuboidVisual3d,
}
impl CuboidSource {
pub(crate) const fn new(entity: LogicEntity, visual: &CuboidVisual3d) -> Self {
Self {
entity,
visual: *visual,
}
}
}
pub(crate) struct ThreeDExtractionBuffer {
view: Option<View3d>,
resolved: Vec<ResolvedCuboid3d>,
pub(super) meshes: Vec<ResolvedMesh3d>,
}
impl ThreeDExtractionBuffer {
pub(crate) const fn new() -> Self {
Self {
view: None,
resolved: Vec::new(),
meshes: Vec::new(),
}
}
pub(crate) fn clear(&mut self) {
self.view = None;
self.resolved.clear();
self.meshes.clear();
}
pub(crate) fn extract(
&mut self,
generation: WorldGeneration,
limits: ThreeDRenderLimits,
view: Option<View3d>,
sources: impl IntoIterator<Item = CuboidSource>,
) -> Result<(), ThreeDExtractionError> {
self.clear();
let Some(view) = view.filter(|view| view.enabled()) else {
return Ok(());
};
view.validate().map_err(ThreeDExtractionError::View)?;
for source in sources {
if !source.visual.visible() {
continue;
}
if source.entity.world_generation() != generation {
return Err(ThreeDExtractionError::StaleEntity {
source: source.entity,
});
}
let count = self.resolved.len().saturating_add(1);
check_limit(ThreeDLimitResource::Cuboids, count, limits.max_cuboids)?;
let triangles = count
.checked_mul(12)
.ok_or(ThreeDExtractionError::LimitExceeded {
resource: ThreeDLimitResource::Triangles,
requested: u64::MAX,
limit: limits.max_triangles as u64,
})?;
check_limit(
ThreeDLimitResource::Triangles,
triangles,
limits.max_triangles,
)?;
source
.visual
.validate()
.map_err(|error| ThreeDExtractionError::Cuboid {
source: source.entity,
error,
})?;
if self.resolved.len() == self.resolved.capacity() {
self.resolved.try_reserve_exact(1).map_err(|_| {
ThreeDExtractionError::AllocationFailed {
requested_bytes: size_of::<ResolvedCuboid3d>(),
}
})?;
}
self.resolved.push(ResolvedCuboid3d {
source: source.entity,
visual: source.visual,
});
}
self.resolved
.sort_unstable_by_key(|record| record.source.stable_bits());
self.view = Some(view);
Ok(())
}
pub(crate) fn snapshot(&self) -> Option<ThreeDSnapshot<'_>> {
self.view.map(|view| ThreeDSnapshot {
view,
cuboids: &self.resolved,
meshes: &self.meshes,
})
}
pub(crate) fn resolved(&self) -> &[ResolvedCuboid3d] {
&self.resolved
}
pub(crate) fn extract_meshes(
&mut self,
generation: WorldGeneration,
limits: ThreeDRenderLimits,
sources: impl IntoIterator<Item = MeshSource>,
) -> Result<(), ThreeDExtractionError> {
if self.view.is_none() {
return Ok(());
}
if let Err(error) = super::mesh_extraction::extract_meshes(
&mut self.meshes,
generation,
limits,
self.resolved.len().saturating_mul(12),
sources,
) {
self.view = None;
return Err(error);
}
Ok(())
}
}
pub(super) fn check_limit(
resource: ThreeDLimitResource,
requested: usize,
limit: usize,
) -> Result<(), ThreeDExtractionError> {
if requested > limit {
return Err(ThreeDExtractionError::LimitExceeded {
resource,
requested: requested as u64,
limit: limit as u64,
});
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ThreeDExtractionError {
StaleEntity {
source: LogicEntity,
},
LimitExceeded {
resource: ThreeDLimitResource,
requested: u64,
limit: u64,
},
View(View3dError),
Cuboid {
source: LogicEntity,
error: CuboidVisualError,
},
AllocationFailed {
requested_bytes: usize,
},
}
impl fmt::Display for ThreeDExtractionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::StaleEntity { source } => {
write!(formatter, "3D source {source:?} is from a stale World")
}
Self::LimitExceeded {
resource,
requested,
limit,
} => write!(
formatter,
"3D {resource:?} requested {requested}, exceeding {limit}"
),
Self::View(error) => write!(formatter, "3D view extraction failed: {error}"),
Self::Cuboid { source, error } => {
write!(formatter, "3D cuboid {source:?} extraction failed: {error}")
}
Self::AllocationFailed { requested_bytes } => write!(
formatter,
"3D extraction could not reserve {requested_bytes} additional bytes"
),
}
}
}
impl Error for ThreeDExtractionError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::View(error) => Some(error),
Self::Cuboid { error, .. } => Some(error),
_ => None,
}
}
}