use super::FORMAT;
use crate::view::history::HistoryFrame;
pub(super) struct Volumes {
pub size: [u32; 3],
pub integrated_size: [u32; 3],
pub scattering: [wgpu::TextureView; 2],
pub holds: Holds,
pub integrated_from: usize,
pub integrated: wgpu::TextureView,
pub inject: Option<(wgpu::Buffer, wgpu::Buffer, [wgpu::BindGroup; 2])>,
pub integrate: Option<(wgpu::TextureView, [wgpu::BindGroup; 2])>,
pub filter: [[wgpu::BindGroup; 2]; 2],
}
impl Volumes {
pub fn new(
device: &wgpu::Device,
filter_layout: &wgpu::BindGroupLayout,
uniform: &wgpu::Buffer,
(size, integrated_size): ([u32; 3], [u32; 3]),
) -> Self {
let scattering = [
volume(device, "fog froxels", size),
volume(device, "fog froxels", size),
];
let (integrated, filter) =
integrated(device, filter_layout, uniform, &scattering, integrated_size);
Self {
size,
integrated_size,
scattering,
holds: Holds::default(),
integrated_from: 0,
integrated,
inject: None,
integrate: None,
filter,
}
}
pub fn resize_integrated(
&mut self,
device: &wgpu::Device,
filter_layout: &wgpu::BindGroupLayout,
uniform: &wgpu::Buffer,
integrated_size: [u32; 3],
) {
(self.integrated, self.filter) = integrated(
device,
filter_layout,
uniform,
&self.scattering,
integrated_size,
);
self.integrated_size = integrated_size;
self.integrate = None;
}
pub fn bind_aerial(
&mut self,
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
uniform: &wgpu::Buffer,
(aerial, sampler): (&wgpu::TextureView, &wgpu::Sampler),
) {
if self
.integrate
.as_ref()
.is_none_or(|(bound, _)| bound != aerial)
{
let view = wgpu::BindingResource::TextureView;
let groups = [0, 1].map(|index| {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("volumetric fog integration"),
layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: uniform.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 4,
resource: view(&self.scattering[index]),
},
wgpu::BindGroupEntry {
binding: 5,
resource: view(&self.integrated),
},
wgpu::BindGroupEntry {
binding: 10,
resource: view(aerial),
},
wgpu::BindGroupEntry {
binding: 11,
resource: wgpu::BindingResource::Sampler(sampler),
},
],
})
});
self.integrate = Some((aerial.clone(), groups));
}
}
pub fn integrate_group(&self, index: usize) -> &wgpu::BindGroup {
&self
.integrate
.as_ref()
.expect("bind_aerial before integrating")
.1[index]
}
}
fn volume(device: &wgpu::Device, label: &str, size: [u32; 3]) -> wgpu::TextureView {
device
.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: size[0],
height: size[1],
depth_or_array_layers: size[2],
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D3,
format: FORMAT,
usage: wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::STORAGE_BINDING
| wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
})
.create_view(&Default::default())
}
fn integrated(
device: &wgpu::Device,
filter_layout: &wgpu::BindGroupLayout,
uniform: &wgpu::Buffer,
scattering: &[wgpu::TextureView; 2],
size: [u32; 3],
) -> (wgpu::TextureView, [[wgpu::BindGroup; 2]; 2]) {
let integrated = volume(device, "integrated fog", size);
let view = wgpu::BindingResource::TextureView;
let filter_pass = |source, dest| {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("volumetric fog filter"),
layout: filter_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: uniform.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 7,
resource: view(source),
},
wgpu::BindGroupEntry {
binding: 8,
resource: view(dest),
},
],
})
};
let filter = [0, 1].map(|index| {
[
filter_pass(&scattering[index], &integrated),
filter_pass(&integrated, &scattering[1 - index]),
]
});
(integrated, filter)
}
#[derive(Clone, Copy, Default)]
pub(super) struct Holds {
frames: [Option<(u32, f32)>; 2],
#[cfg(all(test, not(target_arch = "wasm32")))]
last_injected: usize,
}
impl Holds {
pub fn frame(
&mut self,
history: &HistoryFrame,
length: Option<f32>,
) -> Option<(usize, Option<f32>)> {
if !history.valid {
self.frames = [None; 2];
}
let length = length?;
let index = (history.frames % 2) as usize;
let previous = self.frames[1 - index]
.filter(|&(frames, _)| frames == history.frames.wrapping_sub(1))
.map(|(_, length)| length);
self.frames[index] = Some((history.frames, length));
#[cfg(all(test, not(target_arch = "wasm32")))]
{
self.last_injected = index;
}
Some((index, previous))
}
pub fn filtered(&mut self, index: usize) {
self.frames[1 - index] = self.frames[index];
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn last(&self) -> usize {
self.last_injected
}
}
#[cfg(test)]
mod tests {
use super::Holds;
use crate::view::history::{CameraFrame, CameraHistory};
use glam::{DVec3, Mat4};
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn a_reset_without_fog_ends_the_froxels_history() {
let camera = CameraFrame {
view: Mat4::IDENTITY,
projection: Mat4::IDENTITY,
jitter: [0.; 2],
};
let mut history = CameraHistory::default();
let mut holds = Holds::default();
let frames = [
(true, true, Some(false)),
(false, true, Some(true)),
(true, false, None),
(false, true, Some(false)),
(false, true, Some(true)),
];
for (frame, (reset, fog, expected)) in frames.into_iter().enumerate() {
let begun = history.begin(camera, reset, DVec3::ZERO, 0., 0);
let reprojects = holds
.frame(&begun, fog.then_some(64.))
.map(|(_, previous)| previous.is_some());
assert_eq!(
reprojects, expected,
"frame {frame}, count {}",
begun.frames
);
history.finish(begun);
}
}
}