use super::SceneError;
use crate::shading::uniforms::ObjectUniform;
use crate::static_lighting::AmbientCube;
const STRIDE: u64 = std::mem::size_of::<ObjectUniform>() as u64;
const SHADER_DATA_STRIDE: u64 = std::mem::size_of::<ShaderData>() as u64;
pub(crate) type ShaderData = [[f32; 4]; 2];
pub(crate) struct Objects {
buffer: wgpu::Buffer,
shader_data: wgpu::Buffer,
}
impl Objects {
pub fn new(device: &wgpu::Device) -> Self {
Self {
buffer: object_buffer(device, 1),
shader_data: shader_data_buffer(device, 1),
}
}
pub fn buffer(&self) -> &wgpu::Buffer {
&self.buffer
}
pub fn shader_data(&self) -> &wgpu::Buffer {
&self.shader_data
}
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);
}
let records = (count as u64).max(capacity * 2).min(limit);
self.buffer = object_buffer(device, records);
self.shader_data = shader_data_buffer(device, records);
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_shader_data(&self, queue: &wgpu::Queue, index: usize, data: &ShaderData) {
crate::counters::write_buffer(
queue,
&self.shader_data,
index as u64 * SHADER_DATA_STRIDE,
bytemuck::cast_slice(data),
);
}
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 shader_data_buffer(device: &wgpu::Device, records: u64) -> wgpu::Buffer {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("scene instance shader data"),
size: records * SHADER_DATA_STRIDE,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
)
}
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,
},
)
}