use super::SceneError;
use crate::shading::uniforms::ObjectUniform;
use crate::static_lighting::AmbientCube;
const STRIDE: u64 = std::mem::size_of::<ObjectUniform>() as u64;
pub(crate) struct Objects {
buffer: wgpu::Buffer,
}
impl Objects {
pub fn new(device: &wgpu::Device) -> Self {
Self {
buffer: object_buffer(device, 1),
}
}
pub fn buffer(&self) -> &wgpu::Buffer {
&self.buffer
}
pub fn reserve(&mut self, device: &wgpu::Device, count: usize) -> Result<bool, SceneError> {
let capacity = self.buffer.size() / STRIDE;
if count as u64 <= capacity {
return Ok(false);
}
let limits = device.limits();
let limit = limits
.max_buffer_size
.min(limits.max_storage_buffer_binding_size)
/ STRIDE;
if count as u64 > limit {
return Err(SceneError::DeviceLimit);
}
self.buffer = object_buffer(device, (count as u64).max(capacity * 2).min(limit));
Ok(true)
}
pub fn write(&self, queue: &wgpu::Queue, index: usize, record: &ObjectUniform) {
crate::counters::write_buffer(
queue,
&self.buffer,
offset(index),
bytemuck::bytes_of(record),
);
}
pub fn write_all(&self, queue: &wgpu::Queue, records: &[ObjectUniform]) {
if !records.is_empty() {
crate::counters::write_buffer(queue, &self.buffer, 0, bytemuck::cast_slice(records));
}
}
pub fn write_baked_irradiance(&self, queue: &wgpu::Queue, index: usize, cube: AmbientCube) {
crate::counters::write_buffer(
queue,
&self.buffer,
offset(index) + std::mem::offset_of!(ObjectUniform, baked_irradiance) as u64,
bytemuck::cast_slice(&cube.packed()),
);
}
}
fn offset(index: usize) -> u64 {
index as u64 * STRIDE
}
fn object_buffer(device: &wgpu::Device, records: u64) -> wgpu::Buffer {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("scene objects"),
size: records * STRIDE,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
)
}