use std::collections::{HashMap, HashSet};
use std::sync::atomic::{AtomicU8, Ordering};
use std::sync::Arc;
pub(super) type ContextKey = (u32, Option<usize>);
pub(super) fn supported(backend: wgpu::Backend) -> bool {
backend != wgpu::Backend::BrowserWebGpu
}
const WAITING: u8 = 0;
const MAPPED: u8 = 1;
const FAILED: u8 = 2;
struct Readback {
buffer: wgpu::Buffer,
objects: Vec<u32>,
}
struct Pending {
readback: Readback,
state: Arc<AtomicU8>,
}
#[derive(Default)]
pub(super) struct OcclusionContext {
query_set: Option<(wgpu::QuerySet, u32)>,
buffer: Option<Readback>,
pending: Vec<Pending>,
pub(super) occluded: Option<HashSet<u32>>,
}
pub(super) fn query_objects(draws: impl Iterator<Item = (Option<u32>, bool)>) -> Vec<u32> {
let mut objects = Vec::new();
let mut last: Option<Option<u32>> = None;
for (object, test) in draws {
if last != Some(object) {
if test {
if let Some(id) = object {
objects.push(id);
}
}
last = Some(object);
}
}
objects
}
#[derive(Default)]
pub(super) struct Occlusion {
contexts: HashMap<ContextKey, OcclusionContext>,
resolve_buffers: HashMap<u64, wgpu::Buffer>,
}
impl Occlusion {
pub(super) fn occluded(&self, key: ContextKey) -> Option<&HashSet<u32>> {
self.contexts.get(&key)?.occluded.as_ref()
}
pub(super) fn has_pending(&self) -> bool {
self.contexts.values().any(|c| !c.pending.is_empty())
}
pub(super) fn collect(&mut self) {
for context in self.contexts.values_mut() {
while let Some(first) = context.pending.first() {
match first.state.load(Ordering::Acquire) {
WAITING => break,
MAPPED => {
let Pending { readback, .. } = context.pending.remove(0);
let occluded =
readback
.buffer
.slice(..)
.get_mapped_range()
.ok()
.map(|range| {
let results: Vec<u64> = bytemuck::pod_collect_to_vec(&range);
readback
.objects
.iter()
.zip(results)
.filter(|(_, samples)| *samples == 0)
.map(|(&id, _)| id)
.collect()
});
readback.buffer.unmap();
if occluded.is_some() {
context.occluded = occluded;
}
}
_ => {
context.pending.remove(0);
}
}
}
}
}
pub(super) fn begin(
&mut self,
device: &wgpu::Device,
key: ContextKey,
count: u32,
) -> Option<wgpu::QuerySet> {
let context = self.contexts.entry(key).or_default();
if count == 0 {
context.query_set = None;
return None;
}
match &context.query_set {
Some((set, capacity)) if *capacity >= count => Some(set.clone()),
_ => {
let set = device.create_query_set(&wgpu::QuerySetDescriptor {
label: Some("occlusionQuerySet"),
ty: wgpu::QueryType::Occlusion,
count,
});
context.query_set = Some((set.clone(), count));
Some(set)
}
}
}
pub(super) fn finish(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
key: ContextKey,
query_set: &wgpu::QuerySet,
objects: Vec<u32>,
) {
let count = objects.len() as u32;
let size = count as u64 * 8;
let resolve = self
.resolve_buffers
.entry(size)
.or_insert_with(|| {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some("occlusionQueryResolve"),
size,
usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
})
})
.clone();
let read = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("occlusionQueryRead"),
size,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
encoder.resolve_query_set(query_set, 0..count, &resolve, 0);
encoder.copy_buffer_to_buffer(&resolve, 0, &read, 0, size);
let context = self.contexts.entry(key).or_default();
let current = context.buffer.replace(Readback {
buffer: read,
objects,
});
if let Some(readback) = current {
let state = Arc::new(AtomicU8::new(WAITING));
let signal = state.clone();
readback
.buffer
.slice(..)
.map_async(wgpu::MapMode::Read, move |result| {
signal.store(
if result.is_ok() { MAPPED } else { FAILED },
Ordering::Release,
);
});
context.pending.push(Pending { readback, state });
}
}
}
#[cfg(test)]
mod tests {
use super::query_objects;
#[test]
fn one_query_per_run_of_a_tested_object() {
let draws = [
(None, false),
(Some(1), false),
(Some(2), true),
(Some(2), true),
(Some(3), false),
(Some(2), true),
];
assert_eq!(query_objects(draws.into_iter()), vec![2, 2]);
}
#[test]
fn no_tested_object_no_query() {
let draws = [(Some(1), false), (Some(2), false)];
assert!(query_objects(draws.into_iter()).is_empty());
}
}