use std::collections::{HashMap, HashSet};
use super::CACHE_GRACE_FRAMES;
use crate::nodes::node::TextureSource;
use crate::textures::{MinFilter, TextureFilter, Wrapping};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) struct DrawKey {
pub object: Option<u32>,
pub geometry: usize,
pub material: usize,
pub variant: u64,
pub occurrence: u32,
}
#[derive(Default)]
pub(super) struct Occurrences(HashMap<DrawKey, u32>);
impl Occurrences {
pub fn next(&mut self, key: DrawKey) -> DrawKey {
let base = DrawKey {
occurrence: 0,
..key
};
let seen = self.0.entry(base).or_insert(0);
let occurrence = *seen;
*seen += 1;
DrawKey { occurrence, ..base }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) enum SlotOwner {
Draw(DrawKey),
Compute(u64),
CameraIndex(u32),
}
pub(super) const VERTEX_SLOTS: u32 = u32::MAX;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) struct SlotKey {
pub owner: SlotOwner,
pub group: u32,
pub binding: u32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) struct SamplerKey {
pub address: [wgpu::AddressMode; 3],
pub mag_filter: wgpu::FilterMode,
pub min_filter: wgpu::FilterMode,
pub mipmap_filter: wgpu::MipmapFilterMode,
pub anisotropy_clamp: u16,
pub compare: Option<wgpu::CompareFunction>,
}
impl SamplerKey {
pub fn of(source: &TextureSource) -> Self {
let filter = |f: TextureFilter| match f {
TextureFilter::Nearest => wgpu::FilterMode::Nearest,
TextureFilter::Linear => wgpu::FilterMode::Linear,
};
let mipmap = |f: TextureFilter| match f {
TextureFilter::Nearest => wgpu::MipmapFilterMode::Nearest,
TextureFilter::Linear => wgpu::MipmapFilterMode::Linear,
};
let address = |w: Wrapping| match w {
Wrapping::ClampToEdge => wgpu::AddressMode::ClampToEdge,
Wrapping::Repeat => wgpu::AddressMode::Repeat,
Wrapping::MirroredRepeat => wgpu::AddressMode::MirrorRepeat,
};
let clamp = wgpu::AddressMode::ClampToEdge;
let anisotropy = |mag: TextureFilter, min: MinFilter, anisotropy: u16| {
let linear = mag == TextureFilter::Linear
&& min.min() == TextureFilter::Linear
&& min.mipmap() == TextureFilter::Linear;
if linear {
anisotropy
} else {
1
}
};
match source {
TextureSource::Texture2D(texture) => {
let inner = texture.borrow();
Self {
address: [address(inner.wrap_s), address(inner.wrap_t), clamp],
mag_filter: filter(inner.mag_filter),
min_filter: filter(inner.min_filter.min()),
mipmap_filter: mipmap(inner.min_filter.mipmap()),
anisotropy_clamp: anisotropy(
inner.mag_filter,
inner.min_filter,
inner.anisotropy,
),
compare: None,
}
}
TextureSource::Cube(cube) => {
let inner = cube.inner().borrow();
Self {
address: [clamp; 3],
mag_filter: filter(inner.mag_filter),
min_filter: filter(inner.min_filter.min()),
mipmap_filter: mipmap(inner.min_filter.mipmap()),
anisotropy_clamp: anisotropy(
inner.mag_filter,
inner.min_filter,
inner.anisotropy,
),
compare: None,
}
}
TextureSource::ShadowMap(depth) => {
let inner = depth.inner().borrow();
Self {
address: [clamp; 3],
mag_filter: filter(inner.mag_filter),
min_filter: filter(inner.min_filter),
mipmap_filter: wgpu::MipmapFilterMode::Nearest,
anisotropy_clamp: 1,
compare: Some(wgpu::CompareFunction::LessEqual),
}
}
TextureSource::CubeDepth(cube) => {
let inner = cube.inner().borrow();
Self {
address: [clamp; 3],
mag_filter: filter(inner.mag_filter),
min_filter: filter(inner.min_filter),
mipmap_filter: wgpu::MipmapFilterMode::Nearest,
anisotropy_clamp: 1,
compare: Some(wgpu::CompareFunction::LessEqual),
}
}
TextureSource::Texture3D(texture) => {
let inner = texture.borrow();
Self {
address: [
address(inner.wrap_s),
address(inner.wrap_t),
address(inner.wrap_r),
],
mag_filter: filter(inner.mag_filter),
min_filter: filter(inner.min_filter.min()),
mipmap_filter: mipmap(inner.min_filter.mipmap()),
anisotropy_clamp: 1,
compare: None,
}
}
TextureSource::Depth(_)
| TextureSource::DataArray(_)
| TextureSource::Data(_)
| TextureSource::Storage(..)
| TextureSource::Storage3D(..) => {
panic!("three-rs: this texture is read with textureLoad, not sampled")
}
}
}
pub fn descriptor(&self) -> wgpu::SamplerDescriptor<'static> {
let [address_mode_u, address_mode_v, address_mode_w] = self.address;
wgpu::SamplerDescriptor {
label: Some("three-rs sampler"),
address_mode_u,
address_mode_v,
address_mode_w,
mag_filter: self.mag_filter,
min_filter: self.min_filter,
mipmap_filter: self.mipmap_filter,
anisotropy_clamp: self.anisotropy_clamp,
compare: self.compare,
..Default::default()
}
}
}
#[derive(Clone, Debug)]
pub(super) struct Serial<T> {
pub serial: u64,
pub gpu: T,
}
#[derive(Default)]
pub(super) struct Serials(u64);
impl Serials {
pub fn next(&mut self) -> u64 {
self.0 += 1;
self.0
}
}
pub(super) enum Resource {
Buffer(Serial<wgpu::Buffer>),
View(Serial<wgpu::TextureView>),
Sampler(Serial<wgpu::Sampler>),
}
impl Resource {
pub fn serial(&self) -> u64 {
match self {
Resource::Buffer(buffer) => buffer.serial,
Resource::View(view) => view.serial,
Resource::Sampler(sampler) => sampler.serial,
}
}
pub fn binding(&self) -> wgpu::BindingResource<'_> {
match self {
Resource::Buffer(buffer) => buffer.gpu.as_entire_binding(),
Resource::View(view) => wgpu::BindingResource::TextureView(&view.gpu),
Resource::Sampler(sampler) => wgpu::BindingResource::Sampler(&sampler.gpu),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) enum LayoutKey {
Render(u64),
Compute(u64),
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub(super) struct BindGroupKey {
layout: LayoutKey,
group: u32,
resources: Vec<u64>,
}
impl BindGroupKey {
pub fn of(layout: LayoutKey, group: u32, resources: &[Resource]) -> Self {
Self::from_serials(layout, group, resources.iter().map(Resource::serial))
}
fn from_serials(layout: LayoutKey, group: u32, serials: impl Iterator<Item = u64>) -> Self {
Self {
layout,
group,
resources: serials.collect(),
}
}
pub fn binds_any(&self, serials: &HashSet<u64>) -> bool {
self.resources.iter().any(|serial| serials.contains(serial))
}
}
pub(super) fn is_fresh(last_used: u64, frames: u64) -> bool {
last_used >= frames.saturating_sub(CACHE_GRACE_FRAMES)
}
pub(super) fn padded(bytes: &[u8]) -> std::borrow::Cow<'_, [u8]> {
if bytes.len().is_multiple_of(4) {
std::borrow::Cow::Borrowed(bytes)
} else {
let mut padded = bytes.to_vec();
padded.resize(bytes.len().next_multiple_of(4), 0);
std::borrow::Cow::Owned(padded)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn draw(object: u32, material: usize) -> DrawKey {
DrawKey {
object: Some(object),
geometry: 7,
material,
variant: 0,
occurrence: 0,
}
}
#[test]
fn a_repeated_draw_in_one_pass_gets_its_own_slot() {
let mut pass = Occurrences::default();
let first = pass.next(draw(1, 2));
let other = pass.next(draw(3, 2));
let second = pass.next(draw(1, 2));
assert_eq!((first.occurrence, other.occurrence), (0, 0));
assert_eq!(second.occurrence, 1);
assert_ne!(first, second);
let mut next = Occurrences::default();
assert_eq!(next.next(draw(1, 2)), first);
assert_eq!(next.next(draw(1, 2)), second);
}
#[test]
fn a_bind_group_key_knows_the_serials_it_binds() {
let key = BindGroupKey::from_serials(LayoutKey::Render(1), 0, [3, 5, 8].into_iter());
assert!(key.binds_any(&HashSet::from([5])));
assert!(key.binds_any(&HashSet::from([1, 8])));
assert!(!key.binds_any(&HashSet::from([1, 2, 4])));
assert!(!key.binds_any(&HashSet::new()));
}
#[test]
fn an_entry_survives_the_grace_window_and_no_longer() {
assert!(is_fresh(10, 10));
assert!(is_fresh(10, 10 + CACHE_GRACE_FRAMES));
assert!(!is_fresh(10, 11 + CACHE_GRACE_FRAMES));
assert!(is_fresh(0, 1));
}
#[test]
fn textures_that_filter_alike_share_a_sampler_key() {
use crate::textures::{DepthTexture, MinFilter, Texture};
let a = Texture::new(1, 1, None);
let b = Texture::new(4, 4, None);
let key = |texture: &Texture| SamplerKey::of(&TextureSource::Texture2D(texture.clone()));
assert_eq!(key(&a), key(&b));
b.set_wrapping(Wrapping::Repeat, Wrapping::ClampToEdge);
assert_ne!(key(&a), key(&b));
assert_eq!(key(&b).address[0], wgpu::AddressMode::Repeat);
b.set_wrapping(Wrapping::ClampToEdge, Wrapping::ClampToEdge);
assert_eq!(key(&a), key(&b));
b.set_min_filter(MinFilter::Nearest);
assert_ne!(key(&a), key(&b));
b.set_min_filter(a.borrow().min_filter);
b.set_anisotropy(a.borrow().anisotropy + 1);
assert_ne!(key(&a), key(&b));
b.set_anisotropy(16);
assert_eq!(key(&b).anisotropy_clamp, 16);
b.set_min_filter(MinFilter::LinearMipmapNearest);
assert_eq!(key(&b).anisotropy_clamp, 1);
b.set_min_filter(a.borrow().min_filter);
b.set_anisotropy(a.borrow().anisotropy);
let shadow = SamplerKey::of(&TextureSource::ShadowMap(DepthTexture::new()));
assert_eq!(shadow.compare, Some(wgpu::CompareFunction::LessEqual));
assert_ne!(shadow, key(&a));
let descriptor = key(&a).descriptor();
assert_eq!(descriptor.mag_filter, key(&a).mag_filter);
assert_eq!(descriptor.mipmap_filter, key(&a).mipmap_filter);
assert_eq!(descriptor.compare, None);
}
#[test]
fn a_bind_group_is_keyed_on_what_it_binds_not_on_its_contents() {
let mut serials = Serials::default();
let (uniforms, view, sampler) = (serials.next(), serials.next(), serials.next());
assert!(uniforms != view && view != sampler && uniforms != 0);
let key = |layout, group, members: &[u64]| {
BindGroupKey::from_serials(layout, group, members.iter().copied())
};
let first = key(LayoutKey::Render(9), 1, &[uniforms, view, sampler]);
assert_eq!(
key(LayoutKey::Render(9), 1, &[uniforms, view, sampler]),
first
);
let resized = serials.next();
assert_ne!(
key(LayoutKey::Render(9), 1, &[uniforms, resized, sampler]),
first
);
assert_ne!(
key(LayoutKey::Compute(9), 1, &[uniforms, view, sampler]),
first
);
assert_ne!(
key(LayoutKey::Render(9), 0, &[uniforms, view, sampler]),
first
);
assert_ne!(
key(LayoutKey::Render(9), 1, &[view, uniforms, sampler]),
first
);
}
#[test]
fn padding_is_to_four_bytes_and_zero_filled() {
assert_eq!(&*padded(&[1, 2, 3, 4]), &[1, 2, 3, 4]);
assert_eq!(&*padded(&[1, 2, 3, 4, 5]), &[1, 2, 3, 4, 5, 0, 0, 0]);
assert!(padded(&[]).is_empty());
}
}