use crate::shading::motion_tiles::{MOTION_TILES, MotionTilesUniform};
use crate::view::frame::FrameContext;
use crate::view::motion_tiles::MotionTiles;
pub(crate) struct Reach {
tiles: MotionTiles,
}
impl Reach {
pub fn new(device: &wgpu::Device) -> Self {
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("TAA motion reach"),
source: wgpu::ShaderSource::Wgsl(crate::shading::compose(&[&MOTION_TILES]).into()),
});
Self {
tiles: MotionTiles::new(device, &module),
}
}
pub fn forget_inputs(&mut self) {
self.tiles.forget_inputs();
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn cached_groups(&self) -> usize {
self.tiles.cached_groups()
}
pub fn encode(&mut self, ctx: &mut FrameContext<'_>) -> wgpu::TextureView {
let motion = &ctx.targets.motion;
let values = MotionTilesUniform {
velocity_scale: ctx.sizes.render.map(|v| v as f32),
render_scale: [1.; 2],
};
let mut pass = ctx
.encoder
.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("TAA motion reach"),
timestamp_writes: ctx.timing.and_then(|t| t.compute_pass("TAA motion reach")),
});
self.tiles
.encode(ctx.device, ctx.queue, &mut pass, [motion, motion], values)
.clone()
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use crate::renderer::test_frame::TestRenderer;
use crate::settings::{self, Antialiasing, RenderPreset, Settings};
use crate::{Camera, FrameInput, Scene, test_support};
#[test]
fn a_resize_leaves_the_reach_one_group_set() {
let Some((device, queue)) = test_support::device() else {
return;
};
let size = [64, 48];
let high = Settings {
antialiasing: Antialiasing::Taa,
scene_resolution: settings::SceneResolution::Full,
preset: RenderPreset::High,
..Settings::default()
};
let low = Settings {
preset: RenderPreset::Low,
..high
};
let mut renderer = TestRenderer::for_test(&device, &queue, size, &high);
let mut scene = Scene::new(&device, &queue);
test_support::add_static(&device, &queue, &mut scene, test_support::cube());
let output = crate::view::targets::target(
&device,
"reach groups frame",
size,
crate::shading::gbuffer::COLOR,
);
let input = FrameInput::new(Camera {
eye: glam::Vec3::new(0., 0., 4.),
view: glam::Mat4::from_translation(glam::Vec3::new(0., 0., -4.)),
projection: crate::perspective(1., size[0] as f32 / size[1] as f32, 0.1),
});
for settings in [high, low, high, low] {
renderer.view.resize(&device, size, 1., &settings);
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
&device,
&queue,
&mut encoder,
&mut scene,
&input,
&settings,
&output,
None,
);
queue.submit([encoder.finish()]);
renderer.finish_frame(&mut scene);
assert_eq!(renderer.reach_groups(), Some(1), "{:?}", settings.preset);
}
}
}