use crate::content::identity::Identity;
use crate::content::instance::Mobility;
use crate::scene::instances::Instances;
use crate::scene::models::Models;
use crate::scene::ray_class::RayClass;
use crate::scene::static_edits::posed_bounds;
use crate::shading::RayQueryForm;
use glam::{Mat4, Vec3};
use std::sync::atomic::{AtomicBool, Ordering};
mod blas;
use blas::{BlasBuild, Blases};
pub(crate) const MASK_STATIC: u8 = 1;
pub(crate) const MASK_MOVING: u8 = 2;
const CUSTOM_INDICES: usize = 1 << 24;
pub(crate) fn supported(device: &wgpu::Device) -> bool {
let limits = device.limits();
device
.features()
.contains(wgpu::Features::EXPERIMENTAL_RAY_QUERY)
&& limits.max_blas_primitive_count > 0
&& limits.max_blas_geometry_count > 0
&& limits.max_tlas_instance_count > 0
&& limits.max_acceleration_structures_per_shader_stage > 0
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct RayTracingStats {
pub hardware: u32,
pub portable: u32,
pub left_out: u32,
}
struct TlasEntry {
index: usize,
blas: wgpu::Blas,
pose: Mat4,
mask: u8,
deforms: bool,
}
fn keep<T>(
entries: &mut [T],
capacity: usize,
index: impl Fn(&T) -> usize,
distance: impl Fn(&T) -> f32,
) -> usize {
entries.sort_by_key(|entry| index(entry) >= CUSTOM_INDICES);
let named = entries.partition_point(|entry| index(entry) < CUSTOM_INDICES);
if named <= capacity {
return named;
}
entries[..named].sort_by_cached_key(|entry| distance(entry).max(0.).to_bits());
capacity
}
struct FrameWork {
builds: Vec<BlasBuild>,
encoded: AtomicBool,
}
pub(crate) struct AccelerationStructures {
blases: Blases,
tlas: wgpu::Tlas,
tlas_generation: u64,
capacity: usize,
held: usize,
holds: Vec<bool>,
frame: Option<FrameWork>,
}
fn distance(eye: Vec3, [min, max]: [Vec3; 2]) -> f32 {
eye.distance(eye.clamp(min, max))
}
fn allocated<T>(device: &wgpu::Device, create: impl FnOnce() -> T) -> Option<T> {
let scope = device.push_error_scope(wgpu::ErrorFilter::OutOfMemory);
let created = create();
let mut error = std::pin::pin!(scope.pop());
match error
.as_mut()
.poll(&mut std::task::Context::from_waker(std::task::Waker::noop()))
{
std::task::Poll::Ready(None) => Some(created),
std::task::Poll::Ready(Some(_)) | std::task::Poll::Pending => None,
}
}
fn tlas(device: &wgpu::Device, capacity: usize) -> Option<wgpu::Tlas> {
allocated(device, || {
device.create_tlas(&wgpu::CreateTlasDescriptor {
label: Some("scene TLAS"),
max_instances: capacity as u32,
flags: wgpu::AccelerationStructureFlags::PREFER_FAST_TRACE,
update_mode: wgpu::AccelerationStructureUpdateMode::Build,
})
})
}
fn tlas_transform(pose: Mat4) -> [f32; 12] {
pose.transpose().to_cols_array()[..12]
.try_into()
.expect("a 3×4 transform")
}
impl AccelerationStructures {
pub fn new(device: &wgpu::Device) -> Option<Self> {
Some(Self {
blases: Blases::default(),
tlas: tlas(device, 1)?,
tlas_generation: crate::scene::next_generation(),
capacity: 1,
held: 0,
holds: Vec::new(),
frame: None,
})
}
pub fn prepare(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
(models, instances): (&Models, &Instances),
(entries, eye, form): (usize, Vec3, RayQueryForm),
) -> RayTracingStats {
let limits = device.limits();
self.frame = None;
self.blases.forget_removed(models, instances, form);
self.blases.compact(device, queue);
let mut stats = RayTracingStats::default();
let mut traced = Vec::new();
let mut deforming = Vec::new();
for (id, instance) in instances.slots.iter() {
let model = models
.slots
.get(instance.state.model)
.expect("an instance's model lives");
if !instance.state.capture_visible || model.ray_class == RayClass::None {
continue;
}
if instance.deformation.is_some() {
deforming.push(id);
} else if model.ray_class.traced(form) {
traced.push(id);
} else {
stats.portable += 1;
}
}
let mut builds =
self.blases
.choose_models(device, &limits, models, instances, &traced, (eye, form));
let mut held = Vec::with_capacity(traced.len() + deforming.len());
for &id in &traced {
let instance = instances.slots.get(id).expect("a live instance");
let model = instance.state.model;
let Some(blas) = self.blases.model(models, model, form) else {
stats.portable += 1;
stats.left_out += u32::from(self.blases.left_out(models, model));
continue;
};
held.push(TlasEntry {
index: id.index(),
blas: blas.clone(),
pose: instance.state.pose,
mask: match instance.mobility {
Mobility::Static => MASK_STATIC,
Mobility::Moving => MASK_MOVING,
},
deforms: false,
});
}
for &id in &deforming {
let instance = instances.slots.get(id).expect("a live instance");
let Some(blas) =
self.blases
.deformed(device, &limits, models, (id, instance), (&mut builds, form))
else {
stats.left_out += 1;
continue;
};
held.push(TlasEntry {
index: id.index(),
blas,
pose: instance.state.pose,
mask: MASK_MOVING,
deforms: true,
});
}
self.reserve(device, &limits, entries);
let kept = keep(
&mut held,
self.capacity,
|entry| entry.index,
|entry| {
let instance = instances.slots.at(entry.index).expect("a live instance");
let model = models
.slots
.get(instance.state.model)
.expect("an instance's model lives");
distance(eye, posed_bounds(instance.bounds(model), entry.pose))
},
);
for entry in &held[kept..] {
stats.left_out += 1;
stats.portable += u32::from(!entry.deforms);
}
self.hold(&held[..kept]);
stats.hardware = kept as u32;
self.frame = Some(FrameWork {
builds,
encoded: AtomicBool::new(false),
});
stats
}
fn reserve(&mut self, device: &wgpu::Device, limits: &wgpu::Limits, entries: usize) {
let capacity = entries.min(limits.max_tlas_instance_count as usize);
if capacity > self.capacity
&& let Some(grown) = tlas(device, capacity)
{
self.tlas = grown;
self.tlas_generation = crate::scene::next_generation();
self.capacity = capacity;
self.held = 0;
}
}
pub fn skip_frame(&mut self) {
self.frame = None;
}
fn hold(&mut self, held: &[TlasEntry]) {
self.holds.clear();
for entry in held {
if self.holds.len() <= entry.index {
self.holds.resize(entry.index + 1, false);
}
self.holds[entry.index] = true;
}
for (slot, entry) in held.iter().enumerate() {
self.tlas[slot] = Some(wgpu::TlasInstance::new(
&entry.blas,
tlas_transform(entry.pose),
entry.index as u32,
entry.mask,
));
}
for slot in held.len()..self.held {
self.tlas[slot] = None;
}
self.held = held.len();
}
pub fn encode(&self, encoder: &mut wgpu::CommandEncoder, source: &wgpu::Buffer) {
let Some(frame) = &self.frame else {
return;
};
let entries: Vec<_> = frame
.builds
.iter()
.map(|build| build.entry(source))
.collect();
for build in &frame.builds {
build.count();
}
crate::counters::tlas_build();
encoder.build_acceleration_structures(&entries, [&self.tlas]);
frame.encoded.store(true, Ordering::Relaxed);
}
pub fn finish_frame(&mut self) {
if let Some(frame) = self.frame.take()
&& frame.encoded.into_inner()
{
self.blases.commit(frame.builds);
}
}
pub fn tlas(&self) -> (&wgpu::Tlas, u64) {
(&self.tlas, self.tlas_generation)
}
pub fn holds(&self, index: usize) -> bool {
self.holds.get(index).copied().unwrap_or(false)
}
#[cfg(any(test, feature = "diagnostics"))]
pub fn held(&self) -> (u64, u64) {
self.blases.held()
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;
#[cfg(test)]
mod pure_tests {
use super::{CUSTOM_INDICES, keep, tlas_transform};
use glam::{EulerRot, Mat4, Quat, Vec3, Vec4};
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn tlas_transforms_place_points_as_their_poses_do() {
let pose = Mat4::from_scale_rotation_translation(
Vec3::new(2., -1., 0.5),
Quat::from_euler(EulerRot::YXZ, 0.7, -0.3, 1.9),
Vec3::new(3., -7., 11.),
);
let rows = tlas_transform(pose);
let row = |r: usize| Vec4::from_slice(&rows[r * 4..r * 4 + 4]);
for point in [Vec3::ZERO, Vec3::X, Vec3::new(-2., 5., 0.25)] {
let p = point.extend(1.);
let placed = Vec3::new(row(0).dot(p), row(1).dot(p), row(2).dot(p));
let expected = pose.transform_point3(point);
assert!(
placed.distance(expected) < 1e-5,
"{point}: {placed} against {expected}"
);
}
}
#[wasm_bindgen_test(unsupported = test)]
fn the_tlas_keeps_the_nearest_named_instances() {
let entries = [
(5, 9.),
(CUSTOM_INDICES, 0.),
(1, 3.),
(CUSTOM_INDICES + 7, 1.),
(2, 1.),
(9, 4.),
];
let kept = |capacity: usize| {
let mut entries = entries;
let count = keep(&mut entries, capacity, |e| e.0, |e| e.1);
let mut kept: Vec<usize> = entries[..count].iter().map(|e| e.0).collect();
kept.sort_unstable();
kept
};
assert_eq!(kept(10), [1, 2, 5, 9]);
assert_eq!(kept(4), [1, 2, 5, 9]);
assert_eq!(kept(2), [1, 2]);
assert_eq!(kept(3), [1, 2, 9]);
}
}