use super::SceneError;
use super::ranges::Ranges;
use crate::shading::vertex::CasterVertex;
const MIN_SLAB_BYTES: u64 = 1 << 20;
const MAX_SLAB_BYTES: u64 = 512 << 20;
const LARGE_BYTES: u64 = 256 << 20;
const GROWTH: f64 = 1.5;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Elements {
Positions,
Indices,
}
impl Elements {
const fn size(self) -> u64 {
match self {
Self::Positions => std::mem::size_of::<CasterVertex>() as u64,
Self::Indices => 4,
}
}
fn usage(self) -> wgpu::BufferUsages {
let copies = wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::COPY_DST;
match self {
Self::Positions => copies | wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::STORAGE,
Self::Indices => copies | wgpu::BufferUsages::INDEX,
}
}
fn label(self) -> &'static str {
match self {
Self::Positions => "scene geometry positions",
Self::Indices => "scene geometry indices",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct GeometryRange {
pub slab: u32,
pub first: u32,
pub count: u32,
}
impl GeometryRange {
pub const EMPTY: Self = Self {
slab: u32::MAX,
first: 0,
count: 0,
};
}
struct Slab {
elements: Elements,
buffer: wgpu::Buffer,
ranges: Option<Ranges>,
capacity: u32,
group: Option<wgpu::BindGroup>,
}
pub(crate) struct GeometryBuffers {
slabs: Vec<Option<Slab>>,
limit: u64,
positions_limit: u64,
layout: wgpu::BindGroupLayout,
no_positions: wgpu::BindGroup,
}
impl GeometryBuffers {
pub fn new(device: &wgpu::Device) -> Self {
let limits = device.limits();
let layout = crate::shading::bind::caster_positions(device);
let stand_in = crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("no caster positions"),
size: Elements::Positions.size(),
usage: wgpu::BufferUsages::STORAGE,
mapped_at_creation: false,
},
);
Self {
slabs: Vec::new(),
limit: limits.max_buffer_size,
positions_limit: limits
.max_buffer_size
.min(limits.max_storage_buffer_binding_size),
no_positions: positions_group(device, &layout, &stand_in),
layout,
}
}
pub fn buffer(&self, slab: u32) -> &wgpu::Buffer {
&self.slabs[slab as usize]
.as_ref()
.expect("a placed range's slab lives")
.buffer
}
pub fn positions_group(&self, slab: u32) -> &wgpu::BindGroup {
if slab == GeometryRange::EMPTY.slab {
return &self.no_positions;
}
self.slabs[slab as usize]
.as_ref()
.and_then(|slab| slab.group.as_ref())
.expect("a placed positions range's slab lives")
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn limit_positions(&mut self, bytes: u64) {
self.positions_limit = bytes;
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn positions_slabs(&self) -> usize {
self.slabs
.iter()
.flatten()
.filter(|slab| slab.elements == Elements::Positions)
.count()
}
fn limit(&self, elements: Elements) -> u64 {
match elements {
Elements::Positions => self.positions_limit,
Elements::Indices => self.limit,
}
}
pub fn place(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
elements: Elements,
count: usize,
) -> Result<GeometryRange, SceneError> {
if count == 0 {
return Ok(GeometryRange::EMPTY);
}
let size = elements.size();
let bytes = count as u64 * size;
let count = u32::try_from(count).map_err(|_| SceneError::DeviceLimit)?;
let limit = self.limit(elements);
let largest = MAX_SLAB_BYTES.min(limit);
if bytes >= LARGE_BYTES.min(largest) {
self.place_large(device, elements, count, limit)
} else {
Ok(self.place_general(device, queue, elements, count, (largest / size) as u32))
}
}
pub fn write(&self, queue: &wgpu::Queue, range: GeometryRange, data: &[u8]) {
if range.count == 0 {
return;
}
let slab = self.slabs[range.slab as usize]
.as_ref()
.expect("a placed range's slab lives");
let size = slab.elements.size();
debug_assert_eq!(
data.len() as u64,
u64::from(range.count) * size,
"its elements"
);
crate::counters::write_buffer(queue, &slab.buffer, u64::from(range.first) * size, data);
}
fn place_general(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
elements: Elements,
count: u32,
most: u32,
) -> GeometryRange {
for (index, slot) in self.slabs.iter_mut().enumerate() {
let Some(slab) = slot.as_mut().filter(|slab| slab.elements == elements) else {
continue;
};
let Some(ranges) = slab.ranges.as_mut() else {
continue;
};
let Some(range) = ranges.allocate(count) else {
continue;
};
if range.end > most {
ranges.free(range);
continue;
}
if range.end > slab.capacity {
let mut capacity = slab.capacity;
while capacity < range.end {
capacity = ((f64::from(capacity) * GROWTH).ceil() as u32).min(most);
}
slab.grow(device, queue, capacity, &self.layout);
}
return GeometryRange {
slab: index as u32,
first: range.start,
count,
};
}
let capacity = (MIN_SLAB_BYTES.div_ceil(elements.size()) as u32)
.max(count)
.min(most);
let mut ranges = Ranges::new(0);
let range = ranges.allocate(count).expect("a new slab has room");
let slab = self.insert(Slab::new(
device,
&self.layout,
elements,
Some(ranges),
capacity,
));
GeometryRange {
slab,
first: range.start,
count,
}
}
fn place_large(
&mut self,
device: &wgpu::Device,
elements: Elements,
count: u32,
limit: u64,
) -> Result<GeometryRange, SceneError> {
if u64::from(count) * elements.size() > limit {
return Err(SceneError::DeviceLimit);
}
let slab = self.insert(Slab::new(device, &self.layout, elements, None, count));
Ok(GeometryRange {
slab,
first: 0,
count,
})
}
fn insert(&mut self, slab: Slab) -> u32 {
match self.slabs.iter().position(Option::is_none) {
Some(free) => {
self.slabs[free] = Some(slab);
free as u32
}
None => {
self.slabs.push(Some(slab));
(self.slabs.len() - 1) as u32
}
}
}
pub fn free(&mut self, range: GeometryRange) {
if range.count == 0 {
return;
}
let slot = &mut self.slabs[range.slab as usize];
let slab = slot.as_mut().expect("a placed range's slab lives");
let empty = match slab.ranges.as_mut() {
Some(ranges) => {
ranges.free(range.first..range.first + range.count);
ranges.end() == 0
}
None => true,
};
if empty {
*slot = None;
}
}
#[cfg(any(test, feature = "diagnostics"))]
pub fn sizes(&self) -> [u64; 3] {
self.slabs
.iter()
.flatten()
.fold([0; 3], |[bytes, live, count], slab| {
let held = match &slab.ranges {
Some(ranges) => u64::from(ranges.end()) - ranges.free_units(),
None => u64::from(slab.capacity),
};
[
bytes + slab.buffer.size(),
live + held * slab.elements.size(),
count + 1,
]
})
}
}
impl Slab {
fn new(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
elements: Elements,
ranges: Option<Ranges>,
capacity: u32,
) -> Self {
let buffer = slab_buffer(device, elements, capacity);
Self {
group: (elements == Elements::Positions)
.then(|| positions_group(device, layout, &buffer)),
elements,
buffer,
ranges,
capacity,
}
}
fn grow(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
capacity: u32,
layout: &wgpu::BindGroupLayout,
) {
crate::counters::geometry_growth();
let grown = slab_buffer(device, self.elements, capacity);
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("grow scene geometry slab"),
});
encoder.copy_buffer_to_buffer(&self.buffer, 0, &grown, 0, self.buffer.size());
queue.submit([encoder.finish()]);
if self.group.is_some() {
self.group = Some(positions_group(device, layout, &grown));
}
self.buffer = grown;
self.capacity = capacity;
}
}
fn positions_group(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
buffer: &wgpu::Buffer,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("caster positions"),
layout,
entries: &[wgpu::BindGroupEntry {
binding: crate::shading::bind::caster::POSITIONS,
resource: buffer.as_entire_binding(),
}],
})
}
fn slab_buffer(device: &wgpu::Device, elements: Elements, capacity: u32) -> wgpu::Buffer {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some(elements.label()),
size: u64::from(capacity) * elements.size(),
usage: elements.usage(),
mapped_at_creation: false,
},
)
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use super::{Elements, GeometryBuffers, MIN_SLAB_BYTES};
use crate::shading::vertex::CasterVertex;
use crate::test_support;
#[test]
fn a_grown_slab_keeps_what_it_held() {
let Some((device, queue)) = test_support::device() else {
return;
};
let mut geometry = GeometryBuffers::new(&device);
let positions = |count: usize, from: f32| -> Vec<CasterVertex> {
(0..count)
.map(|index| CasterVertex {
position: [from + index as f32, -(index as f32), 0.5 * index as f32],
})
.collect()
};
let first = positions(100, 1.);
let place_and_write = |geometry: &mut GeometryBuffers, data: &[CasterVertex]| {
let range = geometry
.place(&device, &queue, Elements::Positions, data.len())
.unwrap();
geometry.write(&queue, range, bytemuck::cast_slice(data));
range
};
let placed = place_and_write(&mut geometry, &first);
let larger = (MIN_SLAB_BYTES / Elements::Positions.size()) as usize;
let grown = place_and_write(&mut geometry, &positions(larger, 1e4));
assert_eq!(
grown.slab, placed.slab,
"the larger mesh grew the first slab"
);
let words = test_support::read_words(&device, &queue, geometry.buffer(placed.slab));
let given: &[u32] = bytemuck::cast_slice(&first);
let at = placed.first as usize * 3;
assert_eq!(&words[at..at + given.len()], given);
}
}