use bytemuck::Pod;
#[derive(Clone)]
pub(super) struct Mirror<T: Pod> {
label: &'static str,
records: Vec<T>,
changed: Vec<u32>,
marked: Vec<bool>,
buffer: Option<wgpu::Buffer>,
}
impl<T: Pod> Mirror<T> {
pub fn new(label: &'static str) -> Self {
Self {
label,
records: Vec::new(),
changed: Vec::new(),
marked: Vec::new(),
buffer: None,
}
}
pub fn len(&self) -> usize {
self.records.len()
}
pub fn get(&self, index: u32) -> &T {
&self.records[index as usize]
}
pub fn set(&mut self, index: u32, record: T, fill: T) {
let at = index as usize;
if self.records.len() <= at {
self.records.resize(at + 1, fill);
self.marked.resize(at + 1, false);
}
self.records[at] = record;
if !self.marked[at] {
self.marked[at] = true;
self.changed.push(index);
}
}
#[cfg(test)]
pub fn changed(&self) -> usize {
self.changed.len()
}
fn uploaded(&mut self) {
for &index in &self.changed {
self.marked[index as usize] = false;
}
self.changed.clear();
}
pub fn upload(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
let stride = std::mem::size_of::<T>() as u64;
let needed = (self.records.len() as u64).max(1) * stride;
if self
.buffer
.as_ref()
.is_none_or(|buffer| buffer.size() < needed)
{
let limits = device.limits();
let binding = limits
.max_storage_buffer_binding_size
.min(limits.max_buffer_size);
let size = self.buffer.as_ref().map_or(needed, |buffer| {
(buffer.size() * 2).min(binding).max(needed)
});
self.buffer = Some(crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some(self.label),
size,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
));
self.uploaded();
if !self.records.is_empty() {
let buffer = self.buffer.as_ref().unwrap();
crate::counters::write_buffer(
queue,
buffer,
0,
bytemuck::cast_slice(&self.records),
);
}
return;
}
let buffer = self.buffer.as_ref().unwrap();
self.changed.sort_unstable();
let mut at = 0;
while at < self.changed.len() {
let start = self.changed[at];
let mut end = start + 1;
at += 1;
while at < self.changed.len() && self.changed[at] == end {
end += 1;
at += 1;
}
let records = &self.records[start as usize..end as usize];
crate::counters::write_buffer(
queue,
buffer,
u64::from(start) * stride,
bytemuck::cast_slice(records),
);
}
self.uploaded();
}
pub fn buffer(&self) -> &wgpu::Buffer {
self.buffer
.as_ref()
.expect("the scene uploads its candidates before a frame binds them")
}
#[cfg(any(test, feature = "diagnostics"))]
pub fn bytes(&self) -> u64 {
self.buffer.as_ref().map_or(0, wgpu::Buffer::size)
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use super::Mirror;
#[test]
fn growth_stops_at_what_the_device_binds() {
let Some(adapter) = crate::test_support::adapter() else {
return;
};
let binding = 100 * 48;
let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
required_limits: wgpu::Limits {
max_storage_buffer_binding_size: binding,
..crate::graphics_device::limits(&adapter)
},
..Default::default()
}))
.unwrap();
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
let mut mirror = Mirror::<[u32; 12]>::new("records");
let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
for count in [60u32, 90] {
for index in 0..count {
mirror.set(index, [index; 12], [0; 12]);
}
mirror.upload(&device, &queue);
let _ = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None,
layout: &layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: mirror.buffer().as_entire_binding(),
}],
});
}
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
if let Some(error) = pollster::block_on(validation.pop()) {
panic!("{error}");
}
assert!((90 * 48..=binding).contains(&mirror.bytes()));
}
}