use super::bvh::{self, Primitive};
use super::{RayModel, SceneRays};
use crate::content::instance::Mobility;
use crate::counters::{BuildStep, step};
use crate::scene::SceneError;
use crate::scene::static_edits::posed_bounds;
use glam::{Mat4, Vec3};
use std::ops::Range;
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
pub(super) struct InstanceEntry {
pub inverse_world: [[f32; 4]; 4],
pub mesh_word: u32,
pub bvh_root: u32,
pub padding: [u32; 2],
}
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
pub(crate) struct InstanceLeaf {
pub index: u32,
}
pub(crate) type Bounded = Primitive<InstanceLeaf>;
pub(crate) struct StaticBuild<'a> {
pub instances: &'a mut [Bounded],
pub edits: u64,
pub covered: Vec<u32>,
}
pub(crate) fn bounded(index: usize, bounds: [Vec3; 2], pose: Mat4) -> Bounded {
let [min, max] = posed_bounds(bounds, pose);
Primitive::new(
min,
max,
InstanceLeaf {
index: index as u32,
},
)
}
#[derive(Default)]
struct InstanceBvh {
range: Range<u32>,
capacity: usize,
root: u32,
}
impl InstanceBvh {
fn reserve(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
rays: &mut SceneRays,
instances: usize,
) -> Result<bool, SceneError> {
if instances <= self.capacity {
return Ok(false);
}
let capacity = instances.max(self.capacity * 2);
let range = rays.allocate(device, queue, bvh::words::<InstanceLeaf>(capacity))?;
rays.free(std::mem::replace(&mut self.range, range));
self.capacity = capacity;
self.root = 0;
Ok(true)
}
fn build(
&mut self,
queue: &wgpu::Queue,
rays: &SceneRays,
instances: &mut [Bounded],
words: &mut Vec<u32>,
) {
words.clear();
self.root =
bvh::append_primitives(instances, bvh::Split::EqualCounts, words, self.range.start);
debug_assert!(words.len() <= self.range.len(), "a BVH fits its range");
rays.write(queue, self.range.start, words);
}
}
pub(crate) struct RayInstances {
buffer: wgpu::Buffer,
entries: Vec<InstanceEntry>,
dirty: Vec<bool>,
written: Vec<u32>,
staging: wgpu::Buffer,
packed: Vec<InstanceEntry>,
statics: InstanceBvh,
moving: InstanceBvh,
statics_built: Option<u64>,
statics_covered: Vec<u32>,
roots: [u32; 2],
words: Vec<u32>,
}
impl RayInstances {
pub fn new(device: &wgpu::Device) -> Self {
Self {
buffer: entry_buffer(device, 1),
entries: Vec::new(),
dirty: Vec::new(),
written: Vec::new(),
staging: staging_buffer(device, 1),
packed: Vec::new(),
statics: InstanceBvh::default(),
moving: InstanceBvh::default(),
statics_built: None,
statics_covered: Vec::new(),
roots: [0; 2],
words: Vec::new(),
}
}
pub fn buffer(&self) -> &wgpu::Buffer {
&self.buffer
}
pub fn capacity(&self) -> usize {
(self.buffer.size() / std::mem::size_of::<InstanceEntry>() as u64) as usize
}
pub fn reserve(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
rays: &mut SceneRays,
count: usize,
kind: Mobility,
instances: usize,
) -> Result<(), SceneError> {
let stride = std::mem::size_of::<InstanceEntry>() as u64;
let capacity = self.buffer.size() / stride;
if count as u64 > capacity {
let limits = device.limits();
let limit = limits
.max_storage_buffer_binding_size
.min(limits.max_buffer_size)
/ stride;
if count as u64 > limit {
return Err(SceneError::DeviceLimit);
}
self.buffer = entry_buffer(device, (count as u64).max(capacity * 2).min(limit));
for index in 0..self.entries.len() {
self.mark(index);
}
}
match kind {
Mobility::Static => {
if self.statics.reserve(device, queue, rays, instances)? {
self.statics_built = None;
}
}
Mobility::Moving => {
self.moving.reserve(device, queue, rays, instances)?;
}
}
Ok(())
}
pub fn set(&mut self, index: usize, model: RayModel, pose: Mat4) {
if self.entries.len() <= index {
self.entries.resize(index + 1, bytemuck::Zeroable::zeroed());
self.dirty.resize(index + 1, false);
}
self.entries[index] = InstanceEntry {
inverse_world: pose.inverse().to_cols_array_2d(),
mesh_word: model.mesh_word,
bvh_root: model.bvh_root,
padding: [0; 2],
};
self.mark(index);
}
fn mark(&mut self, index: usize) {
if !self.dirty[index] {
self.dirty[index] = true;
self.written.push(index as u32);
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn pending(&self) -> usize {
self.written.len()
}
pub fn rebuild_statics(&mut self) {
self.statics_built = None;
}
pub fn statics_stale(&self, edits: u64, covered: &[u32]) -> bool {
self.statics_built != Some(edits) || self.statics_covered != covered
}
pub fn update(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
rays: &SceneRays,
statics: Option<StaticBuild<'_>>,
moving: &mut [Bounded],
) {
self.upload_entries(device, queue);
if let Some(statics) = statics {
step(BuildStep::StaticInstanceBvh, || {
self.statics
.build(queue, rays, statics.instances, &mut self.words)
});
self.statics_built = Some(statics.edits);
self.statics_covered = statics.covered;
}
step(BuildStep::MovingInstanceBvh, || {
self.moving.build(queue, rays, moving, &mut self.words)
});
let roots = [self.statics.root, self.moving.root];
if roots != self.roots {
rays.set_instance_roots(queue, roots);
self.roots = roots;
}
}
fn upload_entries(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
if self.written.is_empty() {
return;
}
self.written.sort_unstable();
self.packed.clear();
for &index in &self.written {
self.dirty[index as usize] = false;
self.packed.push(self.entries[index as usize]);
}
let stride = std::mem::size_of::<InstanceEntry>() as u64;
let capacity = self.staging.size() / stride;
if self.packed.len() as u64 > capacity {
self.staging = staging_buffer(device, (self.packed.len() as u64).max(capacity * 2));
}
crate::counters::write_buffer(queue, &self.staging, 0, bytemuck::cast_slice(&self.packed));
let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("scene ray instance entries"),
});
let mut packed = 0;
for run in self.written.chunk_by(|a, b| a + 1 == *b) {
let len = run.len() as u64;
encoder.copy_buffer_to_buffer(
&self.staging,
packed * stride,
&self.buffer,
u64::from(run[0]) * stride,
len * stride,
);
packed += len;
}
queue.submit([encoder.finish()]);
self.written.clear();
}
}
fn entry_buffer(device: &wgpu::Device, capacity: u64) -> wgpu::Buffer {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("scene ray instance entries"),
size: capacity * std::mem::size_of::<InstanceEntry>() as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
)
}
fn staging_buffer(device: &wgpu::Device, capacity: u64) -> wgpu::Buffer {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("scene ray instance entry uploads"),
size: capacity * std::mem::size_of::<InstanceEntry>() as u64,
usage: wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
)
}