use super::Renderer;
use crate::settings::Settings;
use crate::shading::uniforms::FrameValues;
use crate::view::draw_list::{DrawInstances, DrawList};
use crate::view::effective::Effective;
use crate::view::frame::FrameContext;
use crate::view::history::HistoryFrame;
use crate::view::pipelines::GeometryPass;
use crate::view::population::Population;
use crate::{FrameInput, Scene};
macro_rules! context {
($renderer:expr, $device:expr, $queue:expr, $encoder:expr, $scene:expr, $frame:expr) => {
FrameContext {
device: $device,
queue: $queue,
encoder: $encoder,
timing: None,
effective: &$frame.effective,
sizes: $renderer.sizes,
targets: &$renderer.targets,
surface: $renderer.targets.surface(false),
scene: $scene,
values: &$frame.values,
input: &$frame.input,
views: &$renderer.views,
bindings: &mut $renderer.bindings,
pipelines: &$renderer.pipelines,
history: $frame.history,
hardware_rays: crate::view::frame::HardwareRays::of(
&$frame.effective,
$scene,
$renderer.prepare.hardware_rays(),
$renderer.ray_form.as_ref(),
),
}
};
}
pub(crate) struct TestFrame {
effective: Effective,
slot_lights: crate::stages::shadows::traced::slots::SlotLights,
values: FrameValues,
input: FrameInput,
history: HistoryFrame,
}
impl Renderer {
pub(crate) fn for_test(
device: &wgpu::Device,
queue: &wgpu::Queue,
size: [u32; 2],
settings: &Settings,
) -> Self {
Self::new(
device,
queue,
crate::shading::gbuffer::COLOR,
size,
1.,
settings,
)
.unwrap()
}
pub(crate) fn prepare_test_frame(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
scene: &mut Scene,
input: &FrameInput,
settings: &Settings,
) -> TestFrame {
let input = *input;
let effective = super::effective::resolve(
settings,
&input,
super::effective::SceneContent::of(scene),
super::effective::Device {
fsr2_running: false,
fused_supported: self.pipelines.fused_supported,
occlusion_supported: self.cull.occlusion_supported(),
ray_queries: self.ray_form.as_ref().map(|form| form.form()),
tier: self.pipelines.tier,
},
);
self.pipelines.specialise(
device,
effective.layers,
scene,
effective.ray_traced_shadows,
);
let history = self.begin_history(scene, &input);
let values = self.prepare.run(
device,
queue,
scene,
&input,
history,
&effective,
None,
self.sizes.render,
&mut self.views,
&self.bindings.frame,
);
if scene.materials.holds_receivers() {
self.targets.hold_surface(device);
}
self.shadows.resize(device, effective.shadow_quality);
self.shadows.local.prepare(
device,
queue,
&self.bindings,
(scene, &mut self.views.instances),
(input.camera.view, input.camera.projection),
crate::stages::shadows::local::ShadowFrame {
mask: values.frame.visibility_mask,
time: input.elapsed_seconds,
},
effective.local_lights,
);
self.views.instances.upload(device, queue);
self.fog.prepare(device, effective.fog, self.sizes.render);
if let Some(dynamic_gi) = self.dynamic_gi.as_mut() {
dynamic_gi.prepare(device, scene, &effective);
}
self.cull_test_views(device, queue, scene);
let slot_lights = crate::stages::shadows::traced::slots::SlotLights::of(
&input,
&values.frame,
scene,
self.shadows.local.ranking(),
);
let effective =
super::effective::traced_shadows(effective, self.prepare.hardware_rays(), &slot_lights);
self.bindings.refresh(
device,
scene,
input.environment,
&self.views,
self.shadows.maps(),
self.fog.volume(),
self.dynamic_gi
.as_ref()
.map(crate::stages::dynamic_gi::DynamicGi::probes),
);
TestFrame {
effective,
slot_lights,
values,
input,
history,
}
}
pub(crate) fn set_test_cascade(
&mut self,
gpu: (&wgpu::Device, &wgpu::Queue),
scene: &Scene,
frame: &TestFrame,
clip_from_world: glam::Mat4,
) {
let (device, queue) = gpu;
crate::stages::prepare::set_cascades(
gpu,
scene,
&mut self.views,
frame.values.frame.visibility_mask,
std::iter::once(clip_from_world),
);
self.cull_test_views(device, queue, scene);
}
pub(crate) fn cull_test_views(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
scene: &Scene,
) {
let mut encoder = device.create_command_encoder(&Default::default());
self.deform
.dispatch(device, queue, &mut encoder, scene, None);
self.cull
.encode(device, &mut encoder, scene, &self.views, None);
queue.submit([encoder.finish()]);
}
pub(crate) fn encode_test_shadows(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
scene: &Scene,
frame: &TestFrame,
target: Option<&wgpu::TextureView>,
) {
let layer = target.map(|target| {
std::mem::replace(&mut self.shadows.directional.layers[0], target.clone())
});
let mut ctx = context!(self, device, queue, encoder, scene, frame);
self.shadows.encode_local(&mut ctx);
self.shadows.encode_directional(&mut ctx);
if let Some(layer) = layer {
self.shadows.directional.layers[0] = layer;
}
}
pub(crate) fn encode_test_opaque(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
scene: &Scene,
frame: &mut TestFrame,
fused: bool,
) {
frame.effective.fused = fused;
let mut ctx = context!(self, device, queue, encoder, scene, frame);
super::frame::encode_opaque(
&mut self.opaque,
&mut self.cull,
&mut self.traced_shadows,
&frame.slot_lights,
&mut ctx,
);
}
pub(crate) fn encode_test_transparent(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
scene: &Scene,
frame: &TestFrame,
beauty: &wgpu::TextureView,
) {
let mut ctx = context!(self, device, queue, encoder, scene, frame);
self.transparent.encode_volumes(&mut ctx);
self.transparent.encode(
&mut ctx,
crate::stages::transparent::Beauty::Incident(beauty),
);
}
pub(crate) fn encode_test_receivers(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
scene: &Scene,
frame: &TestFrame,
reflections: Option<&wgpu::TextureView>,
) {
let mut ctx = context!(self, device, queue, encoder, scene, frame);
let drew = self.transparent.encode_receivers(&mut ctx);
ctx.surface = self.targets.surface(drew);
self.transparent.encode_volumes(&mut ctx);
self.transparent.encode(
&mut ctx,
crate::stages::transparent::Beauty::Composite { reflections },
);
}
pub(crate) fn draw_test_camera(
&self,
scene: &Scene,
pass: &mut wgpu::RenderPass<'_>,
kind: GeometryPass,
) {
if kind == GeometryPass::Forward {
self.opaque.draw_sky(pass, self.bindings.camera_unlit());
}
pass.set_bind_group(0, self.bindings.camera_lit(), &[]);
self.views
.camera
.list
.draw(scene, &self.pipelines, pass, kind);
}
pub(crate) fn test_camera_lit(&self) -> &wgpu::BindGroup {
self.bindings.camera_lit()
}
pub(crate) fn test_ray_hit_lit(&self) -> &wgpu::BindGroup {
self.bindings.ray_hit_lit()
}
pub(crate) fn test_dynamic_gi(&self) -> &crate::stages::dynamic_gi::DynamicGi {
self.dynamic_gi
.as_ref()
.expect("the dynamic GI stage, on the Extended binding tier")
}
pub(crate) fn test_lit_layout(&self) -> &wgpu::BindGroupLayout {
&self.bindings.lit.layout
}
pub(crate) fn test_camera_phases(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
scene: &Scene,
) -> [Vec<crate::shading::vertex::DrawInstance>; 2] {
crate::view::draw_list::gpu::read_phases(&self.views.camera.list, device, queue, scene)
}
pub(crate) fn test_pyramid(&self) -> Option<&wgpu::Texture> {
self.cull.pyramid()
}
pub(crate) fn test_shader_programs(&self) -> (usize, usize) {
self.pipelines.shader_programs()
}
pub(crate) fn test_fused_supported(&self) -> bool {
self.pipelines.fused_supported
}
pub(crate) fn test_anisotropy_inline(&self) -> bool {
self.pipelines.anisotropy_inline
}
pub(crate) fn test_reflections(&self) -> &crate::stages::reflections::Reflections {
&self.reflections
}
pub(crate) fn test_fsr2(&self) -> Option<&crate::stages::antialiasing::fsr2::Fsr2> {
self.antialiasing.fsr2()
}
pub(crate) fn test_view_as_capture(&mut self, queue: &wgpu::Queue) {
let mut view = self.views.camera.view;
view.uniform.flags |= crate::shading::uniforms::VIEW_PROBE_CAPTURE;
self.views.camera.set(queue, view);
}
pub(crate) fn draw_static(
&self,
gpu: (&wgpu::Device, &wgpu::Queue),
scene: &Scene,
pass: &mut wgpu::RenderPass<'_>,
) {
let (device, queue) = gpu;
let mut instances = DrawInstances::default();
let mut list = DrawList::default();
list.build(
&mut instances,
scene,
&crate::view::View::camera(bytemuck::Zeroable::zeroed()),
None,
Population::ProbeFace,
);
pass.set_bind_group(0, self.bindings.camera_lit(), &[]);
instances.upload(device, queue);
list.draw(
scene,
&self.pipelines,
&instances,
pass,
GeometryPass::Forward,
);
}
}
#[test]
fn abandoned_automatic_exposure_still_snaps_then_adapts_after_finish() {
let Some((device, queue)) = crate::test_support::device() else {
return;
};
let settings = Settings {
antialiasing: crate::settings::Antialiasing::Off,
bloom: crate::settings::Bloom::Off,
..Default::default()
};
let size = [16, 16];
let mut renderer = Renderer::for_test(&device, &queue, size, &settings);
let mut scene = Scene::new(&device, &queue);
let output = crate::view::targets::target(
&device,
"exposure lifecycle",
size,
crate::shading::gbuffer::COLOR,
);
let mut input = FrameInput::new(crate::Camera {
view: glam::Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: glam::Vec3::ZERO,
});
input.backdrop = crate::Backdrop::Color([16.; 3]);
input.frame_time_ms = 0.;
for frame in 0..4 {
if frame == 1 {
input.exposure.automatic = Some(crate::AutoExposure {
speed_brighten: 0.,
speed_darken: 0.,
..Default::default()
});
}
if frame == 3 {
input.backdrop = crate::Backdrop::Color([1.; 3]);
}
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
&device,
&queue,
&mut encoder,
&mut scene,
&input,
&settings,
&output,
None,
);
if frame == 1 {
drop(encoder);
continue;
}
queue.submit([encoder.finish()]);
renderer.finish_frame(&mut scene);
if frame >= 2 {
let multiplier: f32 = bytemuck::pod_read_unaligned(&crate::test_support::read(
&device,
&queue,
renderer.exposure.texture(),
4,
));
assert!(
(multiplier.log2() + 4.).abs() < 0.3,
"frame {frame}: snap to luminance 16 then hold at zero speed: {multiplier}"
);
}
}
}