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 size = self
.buffer
.as_ref()
.map_or(needed, |buffer| needed.max(buffer.size() * 2));
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)
}
}