use crate::{Error, assets::MeshId};
use rayengine_core::{
glam::{Vec2, Vec3},
mesh::{MeshData, MeshError},
};
use std::{
collections::VecDeque,
fmt,
time::{Duration, Instant},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MeshUploadTarget {
Create,
Replace(MeshId),
}
#[derive(Debug)]
pub struct MeshUpload<K> {
pub tag: K,
pub revision: u64,
pub target: MeshUploadTarget,
pub data: MeshData,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MeshQueueError {
Full,
MemoryLimit,
InvalidMesh(MeshError),
TooLarge,
}
impl fmt::Display for MeshQueueError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Full => f.write_str("mesh upload queue is full"),
Self::MemoryLimit => f.write_str("mesh upload queue CPU byte limit exceeded"),
Self::InvalidMesh(error) => fmt::Display::fmt(error, f),
Self::TooLarge => f.write_str("mesh byte count exceeds platform limits"),
}
}
}
impl std::error::Error for MeshQueueError {}
#[derive(Debug)]
pub struct MeshEnqueueError<K> {
pub request: MeshUpload<K>,
pub reason: MeshQueueError,
}
#[derive(Clone, Copy, Debug)]
pub struct UploadBudget {
pub max_requests: usize,
pub max_bytes: usize,
pub max_time: Duration,
}
impl Default for UploadBudget {
fn default() -> Self {
Self {
max_requests: 4,
max_bytes: 4 * 1024 * 1024,
max_time: Duration::from_millis(2),
}
}
}
#[derive(Debug)]
pub enum MeshUploadOutcome {
Uploaded(MeshId),
Failed(Error),
Stale,
}
#[derive(Debug)]
pub struct MeshUploadResult<K> {
pub tag: K,
pub revision: u64,
pub outcome: MeshUploadOutcome,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct UploadReport {
pub processed: usize,
pub attempted: usize,
pub uploaded: usize,
pub failed: usize,
pub discarded: usize,
pub bytes: usize,
pub elapsed: Duration,
pub remaining: usize,
pub blocked_upload_bytes: Option<usize>,
}
struct Queued<K> {
request: MeshUpload<K>,
cpu_bytes: usize,
upload_bytes: usize,
}
pub struct MeshUploadQueue<K> {
pending: VecDeque<Queued<K>>,
max_requests: usize,
max_pending_bytes: usize,
pending_bytes: usize,
}
impl<K> MeshUploadQueue<K> {
pub fn new(max_requests: usize, max_pending_bytes: usize) -> Result<Self, Error> {
if max_requests == 0 || max_pending_bytes == 0 {
return Err(Error::Config("mesh queue limits must be positive".into()));
}
Ok(Self {
pending: VecDeque::new(),
max_requests,
max_pending_bytes,
pending_bytes: 0,
})
}
pub fn len(&self) -> usize {
self.pending.len()
}
pub fn is_empty(&self) -> bool {
self.pending.is_empty()
}
pub fn pending_bytes(&self) -> usize {
self.pending_bytes
}
pub fn front_upload_bytes(&self) -> Option<usize> {
self.pending.front().map(|q| q.upload_bytes)
}
#[allow(clippy::result_large_err)]
pub fn try_push(&mut self, request: MeshUpload<K>) -> Result<(), MeshEnqueueError<K>> {
let admission = (|| {
if self.pending.len() == self.max_requests {
return Err(MeshQueueError::Full);
}
request
.data
.validate()
.map_err(MeshQueueError::InvalidMesh)?;
let (cpu_bytes, upload_bytes) = byte_counts(&request.data)?;
if cpu_bytes > self.max_pending_bytes - self.pending_bytes {
return Err(MeshQueueError::MemoryLimit);
}
Ok((cpu_bytes, upload_bytes))
})();
match admission {
Ok((cpu_bytes, upload_bytes)) => {
self.pending_bytes += cpu_bytes;
self.pending.push_back(Queued {
request,
cpu_bytes,
upload_bytes,
});
Ok(())
}
Err(reason) => Err(MeshEnqueueError { request, reason }),
}
}
pub fn pop(&mut self) -> Option<MeshUpload<K>> {
let queued = self.pending.pop_front()?;
self.pending_bytes -= queued.cpu_bytes;
Some(queued.request)
}
pub(crate) fn process(
&mut self,
budget: UploadBudget,
is_current: impl FnMut(&K, u64) -> bool,
upload: impl FnMut(MeshUploadTarget, &MeshData) -> Result<MeshId, Error>,
on_result: impl FnMut(MeshUploadResult<K>),
) -> UploadReport {
let start = Instant::now();
self.process_with_clock(budget, is_current, upload, on_result, || start.elapsed())
}
fn process_with_clock(
&mut self,
budget: UploadBudget,
mut is_current: impl FnMut(&K, u64) -> bool,
mut upload: impl FnMut(MeshUploadTarget, &MeshData) -> Result<MeshId, Error>,
mut on_result: impl FnMut(MeshUploadResult<K>),
mut elapsed: impl FnMut() -> Duration,
) -> UploadReport {
let mut report = UploadReport::default();
while report.processed < budget.max_requests && elapsed() < budget.max_time {
let Some(front) = self.pending.front() else {
break;
};
let current = is_current(&front.request.tag, front.request.revision);
let bytes = front.upload_bytes;
if current && bytes > budget.max_bytes - report.bytes {
report.blocked_upload_bytes = Some(bytes);
break;
}
let request = self.pop().expect("front is present");
report.processed += 1;
let outcome = if current {
report.attempted += 1;
report.bytes += bytes;
match upload(request.target, &request.data) {
Ok(id) => {
report.uploaded += 1;
MeshUploadOutcome::Uploaded(id)
}
Err(error) => {
report.failed += 1;
MeshUploadOutcome::Failed(error)
}
}
} else {
report.discarded += 1;
MeshUploadOutcome::Stale
};
on_result(MeshUploadResult {
tag: request.tag,
revision: request.revision,
outcome,
});
}
report.remaining = self.pending.len();
report.elapsed = elapsed();
report
}
}
fn byte_counts(data: &MeshData) -> Result<(usize, usize), MeshQueueError> {
let checked_sum = |terms: &[(usize, usize)]| -> Result<usize, MeshQueueError> {
terms.iter().try_fold(0_usize, |sum, &(count, size)| {
count
.checked_mul(size)
.and_then(|bytes| sum.checked_add(bytes))
.ok_or(MeshQueueError::TooLarge)
})
};
let cpu = checked_sum(&[
(data.positions.capacity(), size_of::<Vec3>()),
(
data.normals.as_ref().map_or(0, Vec::capacity),
size_of::<Vec3>(),
),
(
data.texcoords.as_ref().map_or(0, Vec::capacity),
size_of::<Vec2>(),
),
(
data.colors.as_ref().map_or(0, Vec::capacity),
size_of::<[u8; 4]>(),
),
(
data.indices.as_ref().map_or(0, Vec::capacity),
size_of::<u16>(),
),
])?;
let gpu = checked_sum(&[
(data.positions.len(), size_of::<[f32; 3]>()),
(data.positions.len(), size_of::<[f32; 2]>()), (
data.normals.as_ref().map_or(0, Vec::len),
size_of::<[f32; 3]>(),
),
(
data.colors.as_ref().map_or(0, Vec::len),
size_of::<[u8; 4]>(),
),
(data.indices.as_ref().map_or(0, Vec::len), size_of::<u16>()),
])?;
Ok((cpu, gpu))
}
#[cfg(test)]
mod tests;