use super::Renderer;
use crate::diagnostics::DiagnosticTarget;
use crate::settings::{Antialiasing, Bloom, Settings};
use crate::test_support::{self, half, read};
use crate::{Backdrop, Camera, FrameInput, InstanceState, Mobility, Scene, perspective};
use glam::{Mat4, Vec3};
const SIZE: [u32; 2] = [32, 32];
#[test]
fn diagnostics_switch_layers_between_frames_and_return_probe_reports() {
let Some((device, queue)) = test_support::device() else {
return;
};
let mut world = test_support::cube();
for vertex in &mut world.meshes[0].vertices {
vertex.position[2] += 10.;
}
let mut emitter = test_support::cube();
emitter.materials[0].emissive = [4.; 3];
let mut scene = Scene::new(&device, &queue);
test_support::add_static(&device, &queue, &mut scene, world);
let emitter = scene.add_asset(&device, &queue, emitter).unwrap();
scene
.add_instance(
&device,
&queue,
InstanceState {
model: emitter.model,
pose: Mat4::from_translation(Vec3::new(0., 0., -3.)),
visible: true,
capture_visible: true,
},
Mobility::Moving,
)
.unwrap();
let mut input = FrameInput::new(Camera {
view: Mat4::IDENTITY,
projection: perspective(1., 1., 0.1),
eye: Vec3::ZERO,
});
input.diffuse_environment.intensity = 0.;
input.backdrop = Backdrop::Color([0.; 3]);
let mut settings = Settings {
antialiasing: Antialiasing::Off,
bloom: Bloom::Off,
atmosphere: false,
..Settings::default()
};
let mut renderer = Renderer::for_test(&device, &queue, SIZE, &settings);
let output = crate::view::targets::target(
&device,
"frame output",
SIZE,
crate::shading::gbuffer::COLOR,
);
let frame = |renderer: &mut Renderer, scene: &mut Scene, settings: &Settings| {
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
&device,
&queue,
&mut encoder,
scene,
&input,
settings,
&output,
None,
);
queue.submit([encoder.finish()]);
renderer.finish_frame(scene);
let composite = renderer
.diagnostic_target(DiagnosticTarget::Composite)
.unwrap();
read(&device, &queue, composite.texture(), 8)
};
let center = |pixels: &[u8]| {
let at = ((SIZE[1] / 2 * SIZE[0] + SIZE[0] / 2) * 8) as usize;
half(&pixels[at..at + 2])
};
let emitting = frame(&mut renderer, &mut scene, &settings);
assert!(center(&emitting) > 1., "{}", center(&emitting));
assert!(
renderer
.diagnostic_target(DiagnosticTarget::ToneMapped)
.is_none(),
"the tone-mapped target was not captured"
);
settings.diagnostics.disable.instance_emission = true;
let dark = frame(&mut renderer, &mut scene, &settings);
assert!(center(&dark) < 0.01, "{}", center(&dark));
settings.diagnostics.disable.instance_emission = false;
settings.diagnostics.frame_probe = true;
let restored = frame(&mut renderer, &mut scene, &settings);
assert!(restored == emitting, "re-enabled emission differs");
assert!(
renderer
.diagnostic_target(DiagnosticTarget::ToneMapped)
.is_some()
);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let reports = renderer.take_frame_probe_reports(&device);
assert_eq!(reports.len(), 1, "{reports:?}");
assert_eq!(reports[0]["frame"], 0);
assert_eq!(reports[0]["lit_scene"]["observed"], true);
assert!(renderer.take_frame_probe_reports(&device).is_empty());
}
#[test]
fn an_abandoned_probed_frame_reports_nothing() {
let Some((device, queue)) = test_support::device() else {
return;
};
let mut scene = Scene::new(&device, &queue);
test_support::add_static(&device, &queue, &mut scene, test_support::cube());
let input = FrameInput::new(Camera {
view: Mat4::from_translation(Vec3::new(0., 0., -3.)),
projection: perspective(1., 1., 0.1),
eye: Vec3::new(0., 0., 3.),
});
let mut settings = Settings {
antialiasing: Antialiasing::Off,
..Settings::default()
};
let mut renderer = Renderer::for_test(&device, &queue, SIZE, &settings);
let output = crate::view::targets::target(
&device,
"frame output",
SIZE,
crate::shading::gbuffer::COLOR,
);
for probed in [true, false] {
settings.diagnostics.frame_probe = probed;
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
&device,
&queue,
&mut encoder,
&mut scene,
&input,
&settings,
&output,
None,
);
if !probed {
queue.submit([encoder.finish()]);
renderer.finish_frame(&mut scene);
}
}
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let reports = renderer.take_frame_probe_reports(&device);
assert!(reports.is_empty(), "{reports:?}");
}
#[test]
fn a_fsr2_fallback_does_not_compare_different_sized_frame_targets() {
let Some((device, queue)) = test_support::fsr2_device() else {
return;
};
let mut emitter = test_support::cube();
emitter.materials[0].emissive = [4.; 3];
let mut scene = Scene::new(&device, &queue);
let emitter = scene.add_asset(&device, &queue, emitter).unwrap();
scene
.add_instance(
&device,
&queue,
InstanceState {
model: emitter.model,
pose: Mat4::from_translation(Vec3::new(0., 0., -3.)),
visible: true,
capture_visible: true,
},
Mobility::Moving,
)
.unwrap();
let mut input = FrameInput::new(Camera {
view: Mat4::IDENTITY,
projection: perspective(1., 1., 0.1),
eye: Vec3::ZERO,
});
input.diffuse_environment.intensity = 0.;
input.backdrop = Backdrop::Color([0.; 3]);
let mut settings = Settings {
antialiasing: Antialiasing::Fsr2,
fsr2_quality: crate::settings::Fsr2Quality::Quality,
bloom: Bloom::Off,
atmosphere: false,
..Settings::default()
};
settings.diagnostics.disable.fsr2 = true;
settings.diagnostics.frame_probe = true;
let mut renderer = Renderer::for_test(&device, &queue, SIZE, &settings);
if renderer.antialiasing_in_effect(&settings) != Antialiasing::Fsr2 {
return;
}
let output = crate::view::targets::target(
&device,
"FSR2 fallback output",
SIZE,
crate::shading::gbuffer::COLOR,
);
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);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let reports = renderer.take_frame_probe_reports(&device);
assert_eq!(reports.len(), 1, "{reports:?}");
let report = &reports[0];
assert_ne!(
report["size"], report["output_size"],
"the fallback has a smaller source: {report}"
);
assert_eq!(report["tone_mapped"]["observed"], true);
assert!(
report["lit_scene"]["maximum_finite_component"]
.as_f64()
.unwrap()
> 1.,
"the emitter was rendered: {report}"
);
assert_eq!(
renderer.probe.as_ref().unwrap().last_params.get()[..2],
[4, 0],
"different-sized textures must not be compared",
);
}