use super::{allocated, distance};
use crate::content::identity::{Identity, InstanceId, ModelId};
use crate::scene::instances::{Instance, Instances};
use crate::scene::models::{Model, Models};
use crate::scene::ray_class::RayClass;
use crate::scene::static_edits::posed_bounds;
use crate::shading::RayQueryForm;
use crate::shading::deformation::DEFORMED_POSITION_WORDS;
pub(super) use build::BlasBuild;
use build::{Built, GeometryStart, built_non_opaque, create, fits, model_build, non_opaque, sizes};
use glam::Vec3;
use std::collections::{HashMap, VecDeque};
pub(super) const MOST_VERTICES_PER_FRAME: u32 = 400_000;
enum ModelBlas {
Built {
blas: wgpu::Blas,
geometry: u64,
non_opaque: Vec<bool>,
#[cfg(any(test, feature = "diagnostics"))]
triangles: u64,
},
LeftOut { geometry: u64 },
}
impl ModelBlas {
fn current(&self, model: &Model, form: RayQueryForm) -> bool {
match self {
Self::Built {
geometry,
non_opaque: built,
..
} => *geometry == model.geometry && built.iter().copied().eq(non_opaque(model, form)),
Self::LeftOut { geometry } => *geometry == model.geometry,
}
}
}
enum DeformedBlas {
Built {
blas: wgpu::Blas,
geometry: u64,
revision: u64,
non_opaque: Vec<bool>,
#[cfg(any(test, feature = "diagnostics"))]
triangles: u64,
},
LeftOut {
geometry: u64,
},
}
struct Compaction {
model: ModelId,
vertices: u32,
started: bool,
}
#[derive(Clone, Copy)]
struct Pending {
id: ModelId,
nearest: f32,
vertices: u32,
replaced: bool,
}
fn admit(mut pending: Vec<Pending>) -> Vec<ModelId> {
pending.sort_by(|a, b| {
b.replaced
.cmp(&a.replaced)
.then(a.nearest.total_cmp(&b.nearest))
.then(a.id.index().cmp(&b.id.index()))
});
let mut vertices = 0u32;
let mut admitted = Vec::new();
for pending in pending {
if !pending.replaced {
if vertices >= MOST_VERTICES_PER_FRAME {
break;
}
vertices = vertices.saturating_add(pending.vertices);
}
admitted.push(pending.id);
}
admitted
}
#[derive(Default)]
pub(super) struct Blases {
models: HashMap<ModelId, ModelBlas>,
deformed: HashMap<InstanceId, DeformedBlas>,
compaction: VecDeque<Compaction>,
building: HashMap<ModelId, wgpu::Blas>,
}
impl Blases {
pub fn forget_removed(&mut self, models: &Models, instances: &Instances, form: RayQueryForm) {
self.models.retain(|&id, _| {
models
.slots
.get(id)
.is_some_and(|model| model.ray_class.traced(form) && model.deformation.is_none())
});
self.deformed.retain(|&id, _| {
instances.slots.get(id).is_some_and(|instance| {
instance.deformation.is_some()
&& models
.slots
.get(instance.state.model)
.is_some_and(|model| model.ray_class != RayClass::None)
})
});
self.building.clear();
}
pub fn compact(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
let queued = self.compaction.len();
let mut looked = 0;
let mut vertices = 0;
while !self.compaction.is_empty() && vertices < MOST_VERTICES_PER_FRAME && looked < queued {
looked += 1;
let mut next = self.compaction.pop_front().expect("a queued BLAS");
let Some(ModelBlas::Built { blas, .. }) = self.models.get_mut(&next.model) else {
continue;
};
if !next.started {
blas.prepare_compaction_async(|_| {});
}
if blas.ready_for_compaction() {
if let Some(compacted) = allocated(device, || queue.compact_blas(blas)) {
*blas = compacted;
crate::counters::blas_compaction(next.vertices);
vertices += next.vertices;
}
continue;
}
next.started = true;
self.compaction.push_back(next);
}
}
pub fn choose_models(
&mut self,
device: &wgpu::Device,
limits: &wgpu::Limits,
models: &Models,
instances: &Instances,
traced: &[InstanceId],
(eye, form): (Vec3, RayQueryForm),
) -> Vec<BlasBuild> {
let mut pending: HashMap<ModelId, Pending> = HashMap::new();
for &id in traced {
let instance = instances.slots.get(id).expect("a live instance");
let model_id = instance.state.model;
let model = models
.slots
.get(model_id)
.expect("an instance's model lives");
let built = self.models.get(&model_id);
if built.is_some_and(|blas| blas.current(model, form)) {
continue;
}
let nearest = distance(eye, posed_bounds(model.bounds, instance.state.pose));
pending
.entry(model_id)
.and_modify(|pending| pending.nearest = pending.nearest.min(nearest))
.or_insert(Pending {
id: model_id,
nearest,
vertices: model.ray_meshes.iter().map(|mesh| mesh.vertex_count).sum(),
replaced: matches!(built, Some(ModelBlas::Built { .. })),
});
}
let mut builds = Vec::new();
let mut held = Vec::with_capacity(pending.len());
for pending in pending.into_values() {
let model = models.slots.get(pending.id).expect("a pending model lives");
if fits(&model.ray_meshes, limits) {
held.push(pending);
} else {
self.leave_out(pending.id, model);
}
}
for id in admit(held) {
let model = models.slots.get(id).expect("a pending model lives");
match model_build(device, id, model, form) {
Some(build) => {
self.building.insert(id, build.blas.clone());
builds.push(build);
}
None => self.leave_out(id, model),
}
}
builds
}
fn leave_out(&mut self, id: ModelId, model: &Model) {
self.models.insert(
id,
ModelBlas::LeftOut {
geometry: model.geometry,
},
);
}
pub fn model(&self, models: &Models, id: ModelId, form: RayQueryForm) -> Option<&wgpu::Blas> {
if let Some(blas) = self.building.get(&id) {
return Some(blas);
}
let model = models.slots.get(id).expect("a live model");
match self.models.get(&id) {
Some(built @ ModelBlas::Built { blas, .. }) if built.current(model, form) => Some(blas),
_ => None,
}
}
pub fn left_out(&self, models: &Models, id: ModelId) -> bool {
let geometry = models.slots.get(id).expect("a live model").geometry;
matches!(self.models.get(&id), Some(ModelBlas::LeftOut { geometry: g }) if *g == geometry)
}
pub fn deformed(
&mut self,
device: &wgpu::Device,
limits: &wgpu::Limits,
models: &Models,
(id, instance): (InstanceId, &Instance),
(builds, form): (&mut Vec<BlasBuild>, RayQueryForm),
) -> Option<wgpu::Blas> {
let model = models
.slots
.get(instance.state.model)
.expect("an instance's model lives");
let deformation = instance.deformation.as_ref().expect("a deforming instance");
let blas = match self.deformed.get(&id) {
Some(DeformedBlas::LeftOut { geometry }) if *geometry == model.geometry => {
return None;
}
Some(DeformedBlas::Built {
blas,
geometry,
revision,
non_opaque: built,
..
}) if *geometry == model.geometry
&& built.iter().copied().eq(non_opaque(model, form)) =>
{
if *revision == deformation.revision {
return Some(blas.clone());
}
blas.clone()
}
_ => {
let sizes = sizes(&model.ray_meshes, non_opaque(model, form));
let created = fits(&model.ray_meshes, limits)
.then(|| {
create(
device,
"scene deformed BLAS",
&sizes,
wgpu::AccelerationStructureFlags::PREFER_FAST_BUILD,
)
})
.flatten();
let Some(blas) = created else {
self.deformed.insert(
id,
DeformedBlas::LeftOut {
geometry: model.geometry,
},
);
return None;
};
blas
}
};
let rig = model.deformation.as_ref().expect("a deforming model");
let starts = model
.ray_meshes
.iter()
.enumerate()
.map(|(mesh, words)| {
let positions = deformation.positions(rig, mesh);
debug_assert_eq!(
positions % DEFORMED_POSITION_WORDS,
0,
"positions are aligned"
);
GeometryStart {
first_vertex: positions / DEFORMED_POSITION_WORDS,
first_index: words.indices,
}
})
.collect();
builds.push(BlasBuild {
built: Built::Deformed {
id,
geometry: model.geometry,
revision: deformation.revision,
},
blas: blas.clone(),
sizes: sizes(&model.ray_meshes, non_opaque(model, form)),
starts,
stride: u64::from(DEFORMED_POSITION_WORDS) * 4,
});
Some(blas)
}
pub fn commit(&mut self, builds: Vec<BlasBuild>) {
for build in builds {
#[cfg(any(test, feature = "diagnostics"))]
let triangles = build
.sizes
.iter()
.map(|size| u64::from(size.index_count.unwrap_or(0) / 3))
.sum();
let non_opaque = built_non_opaque(&build.sizes);
match build.built {
Built::Model {
id,
geometry,
vertices,
} => {
self.models.insert(
id,
ModelBlas::Built {
blas: build.blas,
geometry,
non_opaque,
#[cfg(any(test, feature = "diagnostics"))]
triangles,
},
);
self.compaction.retain(|queued| queued.model != id);
self.compaction.push_back(Compaction {
model: id,
vertices,
started: false,
});
}
Built::Deformed {
id,
geometry,
revision,
} => {
self.deformed.insert(
id,
DeformedBlas::Built {
blas: build.blas,
geometry,
revision,
non_opaque,
#[cfg(any(test, feature = "diagnostics"))]
triangles,
},
);
}
}
}
self.building.clear();
}
#[cfg(any(test, feature = "diagnostics"))]
pub fn held(&self) -> (u64, u64) {
let models = self.models.values().filter_map(|blas| match blas {
ModelBlas::Built { triangles, .. } => Some(*triangles),
ModelBlas::LeftOut { .. } => None,
});
let deformed = self.deformed.values().filter_map(|blas| match blas {
DeformedBlas::Built { triangles, .. } => Some(*triangles),
DeformedBlas::LeftOut { .. } => None,
});
models
.chain(deformed)
.fold((0, 0), |(count, sum), triangles| {
(count + 1, sum + triangles)
})
}
}
mod build;
#[cfg(test)]
mod tests {
use super::{MOST_VERTICES_PER_FRAME, Pending, admit};
use crate::content::identity::{Identity, ModelId};
use wasm_bindgen_test::wasm_bindgen_test;
fn pending(index: usize, nearest: f32, vertices: u32, replaced: bool) -> Pending {
Pending {
id: ModelId::issue(index, 1),
nearest,
vertices,
replaced,
}
}
#[wasm_bindgen_test(unsupported = test)]
fn pending_models_are_built_nearest_first_under_the_budget() {
let budget = MOST_VERTICES_PER_FRAME;
let ids = |admitted: Vec<ModelId>| -> Vec<usize> {
admitted.into_iter().map(Identity::index).collect()
};
assert_eq!(ids(admit(vec![pending(0, 10., budget * 5, false)])), [0]);
let fresh = [
pending(1, 30., budget / 4, false),
pending(2, 10., budget / 4 * 3, false),
pending(3, 20., budget / 8, false),
pending(4, 40., budget / 40, false),
];
assert_eq!(ids(admit(fresh.to_vec())), [2, 3, 1]);
let mut edited = fresh.to_vec();
edited.push(pending(5, 90., budget * 2, true));
assert_eq!(ids(admit(edited)), [5, 2, 3, 1]);
}
}