use super::{DrawBatch, Geometry};
use crate::Mobility;
use crate::content::identity::{MaterialId, ModelId};
use crate::shading::vertex::DrawInstance;
use crate::view::pipelines::Variant;
use rustc_hash::FxHashMap;
use std::ops::Range;
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub(super) struct BatchKey {
pub variant: Variant,
pub material: MaterialId,
pub geometry: Geometry,
pub mobility: Mobility,
}
pub(super) struct InstanceDraw {
pub key: BatchKey,
pub ranges: Range<usize>,
pub instance: DrawInstance,
pub order: (u32, u32),
}
struct Bin {
key: BatchKey,
ranges: Range<usize>,
order: (u32, u32),
next: Option<u32>,
count: u32,
start: u32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
struct BinKey {
key: BatchKey,
first: (u32, u32),
ranges: u32,
}
pub(super) type Merged<'a> = (
&'a [Range<u32>],
&'a mut Vec<DrawBatch>,
&'a mut Vec<DrawInstance>,
);
#[derive(Default)]
pub(super) struct Batcher {
draws: Vec<InstanceDraw>,
bin_of: Vec<u32>,
bins: Vec<Bin>,
bin_keys: FxHashMap<BinKey, u32>,
ranks: FxHashMap<ModelId, u32>,
}
impl Batcher {
pub fn clear(&mut self) {
self.draws.clear();
self.ranks.clear();
}
pub fn rank(&mut self, model: ModelId) -> u32 {
let next = self.ranks.len() as u32;
*self.ranks.entry(model).or_insert(next)
}
pub fn push(&mut self, draw: InstanceDraw) {
self.draws.push(draw);
}
pub fn sort_by_depth(&mut self, key: impl Fn(&InstanceDraw) -> f32) {
let mut keyed: Vec<_> = self
.draws
.drain(..)
.map(|draw| (key(&draw), draw))
.collect();
keyed.sort_by(|(a, _), (b, _)| a.total_cmp(b));
self.draws.extend(keyed.into_iter().map(|(_, draw)| draw));
}
pub fn merge_adjacent(&self, (ranges, batches, instances): Merged<'_>) {
for draw in &self.draws {
let index = instances.len() as u32;
instances.push(draw.instance);
if let Some(last) = batches.last_mut()
&& last.key == draw.key
&& draw.ranges.len() == 1
&& ranges[last.ranges.clone()] == ranges[draw.ranges.clone()]
{
last.instances.end = index + 1;
continue;
}
batches.push(batch(draw.key, draw.ranges.clone(), index..index + 1));
}
}
pub fn bin(&mut self, (ranges, batches, instances): Merged<'_>) {
self.bins.clear();
self.bin_keys.clear();
self.bin_of.clear();
for draw in &self.draws {
let drawn = &ranges[draw.ranges.clone()];
let lookup = BinKey {
key: draw.key,
first: (drawn[0].start, drawn[0].end),
ranges: drawn.len() as u32,
};
let created = self.bins.len() as u32;
let mut at = *self.bin_keys.entry(lookup).or_insert(created);
if at != created {
loop {
let bin = &self.bins[at as usize];
if ranges[bin.ranges.clone()] == *drawn {
break;
}
match bin.next {
Some(next) => at = next,
None => {
self.bins[at as usize].next = Some(created);
at = created;
break;
}
}
}
}
if at == created {
self.bins.push(Bin {
key: draw.key,
ranges: draw.ranges.clone(),
order: draw.order,
next: None,
count: 0,
start: 0,
});
}
self.bins[at as usize].count += 1;
self.bin_of.push(at);
}
let mut order: Vec<u32> = (0..self.bins.len() as u32).collect();
order.sort_unstable_by_key(|&bin| (self.bins[bin as usize].order, bin));
let mut start = 0;
for &bin in &order {
let bin = &mut self.bins[bin as usize];
bin.start = start;
start += bin.count;
bin.count = 0;
}
instances.resize(start as usize, bytemuck::Zeroable::zeroed());
for (draw, &bin) in self.draws.iter().zip(&self.bin_of) {
let bin = &mut self.bins[bin as usize];
instances[(bin.start + bin.count) as usize] = draw.instance;
bin.count += 1;
}
batches.extend(order.iter().map(|&bin| {
let bin = &self.bins[bin as usize];
batch(
bin.key,
bin.ranges.clone(),
bin.start..bin.start + bin.count,
)
}));
}
}
fn batch(key: BatchKey, ranges: Range<usize>, instances: Range<u32>) -> DrawBatch {
DrawBatch {
key,
ranges,
instances,
}
}