use super::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mesh3dUploadBudgetResource {
RecoveryBytes,
GpuBytes,
StagingBytes,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Mesh3dUploadBudget {
max_recovery_bytes: usize,
max_gpu_bytes: usize,
max_staging_bytes: usize,
}
impl Mesh3dUploadBudget {
pub fn new(
max_recovery_bytes: usize,
max_gpu_bytes: usize,
max_staging_bytes: usize,
) -> Result<Self, Mesh3dResourceError> {
if [max_recovery_bytes, max_gpu_bytes, max_staging_bytes].contains(&0) {
return Err(Mesh3dResourceError::InvalidBudget);
}
Ok(Self {
max_recovery_bytes,
max_gpu_bytes,
max_staging_bytes,
})
}
pub const fn max_recovery_bytes(self) -> usize {
self.max_recovery_bytes
}
pub const fn max_gpu_bytes(self) -> usize {
self.max_gpu_bytes
}
pub const fn max_staging_bytes(self) -> usize {
self.max_staging_bytes
}
}
impl Default for Mesh3dUploadBudget {
fn default() -> Self {
Self {
max_recovery_bytes: 256 * 1024 * 1024,
max_gpu_bytes: 256 * 1024 * 1024,
max_staging_bytes: 256 * 1024 * 1024,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Mesh3dUploadReport {
recovery_bytes: usize,
uploaded_bytes: usize,
staging_bytes: usize,
peak_recovery_bytes: usize,
peak_gpu_bytes: usize,
}
impl Mesh3dUploadReport {
pub const fn recovery_bytes(self) -> usize {
self.recovery_bytes
}
pub const fn uploaded_bytes(self) -> usize {
self.uploaded_bytes
}
pub const fn staging_bytes(self) -> usize {
self.staging_bytes
}
pub const fn peak_recovery_bytes(self) -> usize {
self.peak_recovery_bytes
}
pub const fn peak_gpu_bytes(self) -> usize {
self.peak_gpu_bytes
}
pub const fn replaced_buffers(self) -> bool {
true
}
}
impl WgpuRenderer {
pub fn create_mesh3d_with_budget(
&self,
source: Mesh3d,
budget: Mesh3dUploadBudget,
) -> Result<RetainedMesh3d, Mesh3dResourceError> {
let prepared = prepare_with_budget(&self.device, source, budget)?;
Ok(upload_prepared_retained_mesh(
&self.device,
&self.queue,
Arc::clone(&self.renderer_identity),
prepared,
))
}
pub fn replace_mesh3d(
&self,
mesh: &mut RetainedMesh3d,
source: Mesh3d,
budget: Mesh3dUploadBudget,
) -> Result<Mesh3dUploadReport, Mesh3dResourceError> {
replace_resources(
&self.device,
&self.queue,
&self.renderer_identity,
mesh,
source,
budget,
)
}
}
pub(super) fn prepare_with_budget(
device: &wgpu::Device,
source: Mesh3d,
budget: Mesh3dUploadBudget,
) -> Result<PreparedRetainedMeshUpload, Mesh3dResourceError> {
let layout = preflight_mesh3d_source(&source, device.limits().max_buffer_size)?;
for (resource, limit, actual) in [
(
Mesh3dUploadBudgetResource::RecoveryBytes,
budget.max_recovery_bytes,
source.recovery_memory_bytes(),
),
(
Mesh3dUploadBudgetResource::GpuBytes,
budget.max_gpu_bytes,
layout.total_bytes as usize,
),
(
Mesh3dUploadBudgetResource::StagingBytes,
budget.max_staging_bytes,
layout
.vertex_bytes
.saturating_add(layout.edge_bytes)
.saturating_add(layout.texture_coordinate_bytes) as usize,
),
] {
if actual > limit {
return Err(Mesh3dResourceError::BudgetExceeded {
resource,
limit,
actual,
});
}
}
let mut prepared = prepare_retained_mesh_upload(device, source)?;
prepared.budget = budget;
Ok(prepared)
}
pub(super) fn replace_resources(
device: &wgpu::Device,
queue: &wgpu::Queue,
identity: &Arc<()>,
mesh: &mut RetainedMesh3d,
source: Mesh3d,
budget: Mesh3dUploadBudget,
) -> Result<Mesh3dUploadReport, Mesh3dResourceError> {
if !Arc::ptr_eq(identity, &mesh.renderer_identity) {
return Err(Mesh3dResourceError::RendererMismatch);
}
if mesh.material().is_some()
&& (source.texture_coordinates().len() != source.vertices().len()
|| source.triangle_count() == 0)
{
return Err(Mesh3dResourceError::Texture(
Texture3dError::MissingTextureCoordinates,
));
}
let prepared = prepare_with_budget(device, source, budget)?;
let report = Mesh3dUploadReport {
recovery_bytes: prepared.source.recovery_memory_bytes(),
uploaded_bytes: prepared.layout.total_bytes as usize,
staging_bytes: prepared
.layout
.vertex_bytes
.saturating_add(prepared.layout.edge_bytes)
.saturating_add(prepared.layout.texture_coordinate_bytes)
as usize,
peak_recovery_bytes: mesh.recovery_memory_bytes().saturating_add(
if mesh.source.vertices().as_ptr() == prepared.source.vertices().as_ptr() {
0
} else {
prepared.source.recovery_memory_bytes()
},
),
peak_gpu_bytes: mesh
.gpu_allocation_bytes()
.saturating_add(prepared.layout.total_bytes as usize),
};
let mut replacement =
upload_prepared_retained_mesh(device, queue, Arc::clone(identity), prepared);
replacement.material = mesh.material.clone();
*mesh = replacement;
Ok(report)
}