use super::mirror::Mirror;
use crate::content::identity::MaterialId;
use crate::scene::ranges::Ranges;
use crate::shading::culling::{DrawSet, SET_CASTS_DIRECTIONAL_SHADOW, SET_PAIRS};
use rustc_hash::FxHashMap;
use std::ops::Range;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) struct SetKey {
pub material: MaterialId,
pub mirrored: bool,
pub deforms: bool,
pub positions: u32,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub(crate) struct SetLook {
pub group: u32,
pub casts: bool,
pub opaque: bool,
}
#[derive(Clone)]
struct Set {
key: SetKey,
look: SetLook,
candidates: u32,
need: u32,
region: Range<u32>,
}
#[derive(Clone)]
pub(crate) struct Sets {
sets: Vec<Option<Set>>,
by_key: FxHashMap<SetKey, u32>,
free: Vec<u32>,
records: Mirror<DrawSet>,
regions: Ranges,
overflowed: bool,
}
impl Sets {
pub fn new() -> Self {
Self {
sets: Vec::new(),
by_key: FxHashMap::default(),
free: Vec::new(),
records: Mirror::new("draw sets"),
regions: Ranges::new(0),
overflowed: false,
}
}
pub fn add(&mut self, key: SetKey, look: SetLook, need: u32) -> u32 {
let index = match self.by_key.get(&key) {
Some(&index) => index,
None => {
let index = self.free.pop().unwrap_or(self.sets.len() as u32);
if index as usize == self.sets.len() {
self.sets.push(None);
}
self.sets[index as usize] = Some(Set {
key,
look,
candidates: 0,
need: 0,
region: 0..0,
});
self.by_key.insert(key, index);
index
}
};
let set = self.sets[index as usize].as_mut().unwrap();
set.candidates += 1;
set.need += need;
self.place(index);
index
}
pub fn remove(&mut self, index: u32, need: u32) {
let set = self.sets[index as usize]
.as_mut()
.expect("a candidate's set lives");
set.candidates -= 1;
set.need -= need;
if set.candidates == 0 {
let set = self.sets[index as usize].take().unwrap();
self.regions.free(set.region);
self.by_key.remove(&set.key);
self.free.push(index);
self.records
.set(index, DrawSet::default(), DrawSet::default());
return;
}
self.place(index);
}
fn place(&mut self, index: u32) {
let set = self.sets[index as usize].as_mut().unwrap();
let capacity = set.region.len() as u32;
if set.need > capacity || set.need <= capacity / 4 {
self.regions.free(set.region.clone());
let capacity = set.need.saturating_add(set.need / 2);
set.region = self.regions.allocate(capacity).unwrap_or_else(|| {
self.overflowed = true;
0..0
});
}
self.records.set(index, record(set), DrawSet::default());
}
pub fn material_changed(&mut self, id: MaterialId, look: SetLook) {
for (index, set) in self.sets.iter_mut().enumerate() {
if let Some(set) = set.as_mut().filter(|set| set.key.material == id) {
set.look = look;
self.records
.set(index as u32, record(set), DrawSet::default());
}
}
}
pub fn fit(&self, most: u32) -> bool {
!self.overflowed && self.regions.end() <= most
}
pub fn region_end(&self) -> u32 {
self.regions.end()
}
pub fn end(&self) -> u32 {
self.sets.len() as u32
}
pub fn iter(&self) -> impl Iterator<Item = (u32, SetKey, Range<u32>)> + '_ {
self.sets.iter().enumerate().filter_map(|(index, set)| {
set.as_ref()
.map(|set| (index as u32, set.key, set.region.clone()))
})
}
pub fn buffer(&self) -> &wgpu::Buffer {
self.records.buffer()
}
pub fn upload(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
self.records.upload(device, queue);
}
#[cfg(test)]
pub fn changed(&self) -> usize {
self.records.changed()
}
#[cfg(any(test, feature = "diagnostics"))]
pub fn bytes(&self) -> u64 {
self.records.bytes()
}
}
fn record(set: &Set) -> DrawSet {
DrawSet {
region: set.region.start,
capacity: set.region.len() as u32,
visibility_group: set.look.group,
flags: if set.look.casts {
SET_CASTS_DIRECTIONAL_SHADOW
} else {
0
} | if set.look.opaque { SET_PAIRS } else { 0 },
}
}