use super::{Renderer, View, ViewFrame};
use crate::settings::Settings;
use crate::{Camera, FrameInput, Scene, test_support};
const SIZE: [u32; 2] = [16, 16];
fn input() -> FrameInput {
FrameInput::new(Camera {
view: glam::Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: glam::Vec3::ZERO,
})
}
fn output(device: &wgpu::Device) -> wgpu::TextureView {
crate::view::targets::target(
device,
"view boundary",
SIZE,
crate::shading::gbuffer::COLOR,
)
}
fn view(renderer: &Renderer, device: &wgpu::Device, queue: &wgpu::Queue) -> View {
View::new(
renderer,
device,
queue,
crate::shading::gbuffer::COLOR,
SIZE,
1.,
&Settings::default(),
)
.unwrap()
}
fn render(
(device, queue): (&wgpu::Device, &wgpu::Queue),
renderer: &mut Renderer,
view: &mut View,
scene: &mut Scene,
output: &wgpu::TextureView,
) -> bool {
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
device,
queue,
&mut encoder,
scene,
&mut [ViewFrame {
view,
input: &input(),
settings: &Settings::default(),
output,
timing: None,
}],
);
queue.submit([encoder.finish()]);
view.rendered.as_ref().unwrap().history.valid
}
#[test]
fn finish_frame_of_another_scene_commits_nothing() {
let Some((device, queue)) = test_support::device() else {
return;
};
let gpu = (&device, &queue);
let mut renderer = Renderer::new(&device);
let mut view = view(&renderer, &device, &queue);
let output = output(&device);
let mut scene = Scene::new(&device, &queue);
let mut other = Scene::new(&device, &queue);
render(gpu, &mut renderer, &mut view, &mut scene, &output);
renderer.finish_frame(&mut other);
assert_eq!(
other.last_finished(),
None,
"the other scene finished nothing"
);
assert_eq!(
scene.last_finished(),
None,
"the rendered scene was not finished"
);
renderer.finish_frame(&mut scene);
assert!(
scene.last_finished().is_some(),
"the rendered scene's frame commits after another scene's finish"
);
assert!(
render(gpu, &mut renderer, &mut view, &mut scene, &output),
"the view continues from its scene's finished frame"
);
renderer.finish_frame(&mut other);
assert!(
render(gpu, &mut renderer, &mut view, &mut scene, &output),
"a frame finished as another scene's restarted the view"
);
renderer.finish_frame(&mut scene);
}
#[test]
fn a_view_used_between_render_and_finish_keeps_its_history() {
let Some((device, queue)) = test_support::device() else {
return;
};
let gpu = (&device, &queue);
let mut renderer = Renderer::new(&device);
let mut view = view(&renderer, &device, &queue);
let output = output(&device);
let mut scene = Scene::new(&device, &queue);
for frame in 0..3 {
let continued = render(gpu, &mut renderer, &mut view, &mut scene, &output);
assert_eq!(continued, frame > 0, "frame {frame}");
view.geometry_stats(&device);
view.resize(&device, SIZE, 1., &Settings::default());
renderer.finish_frame(&mut scene);
}
}
#[test]
fn a_view_of_another_renderer_is_refused() {
let Some((device, queue)) = test_support::device() else {
return;
};
let first = Renderer::new(&device);
let mut second = Renderer::new(&device);
let mut view = view(&first, &device, &queue);
let output = output(&device);
let mut scene = Scene::new(&device, &queue);
let refused = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
render(
(&device, &queue),
&mut second,
&mut view,
&mut scene,
&output,
)
}))
.expect_err("a renderer rendered another renderer's view");
let message = refused
.downcast_ref::<&str>()
.map(|message| message.to_string())
.or_else(|| refused.downcast_ref::<String>().cloned());
assert!(
message.is_some_and(|message| message.contains("created from it")),
"the refusal names the rule"
);
}
#[test]
fn a_view_left_out_of_a_frame_reads_back_its_own_finished_frame() {
let Some((device, queue)) = test_support::device() else {
return;
};
let settings = Settings {
occlusion_culling: false,
..Settings::default()
};
let mut renderer = Renderer::new(&device);
let [mut a, mut b] = [(); 2].map(|_| {
View::new(
&renderer,
&device,
&queue,
crate::shading::gbuffer::COLOR,
SIZE,
1.,
&settings,
)
.unwrap()
});
let outputs = [output(&device), output(&device)];
let mut scene = Scene::new(&device, &queue);
let model = scene
.add_asset(&device, &queue, test_support::cube())
.unwrap()
.model;
let wait = || device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let read = |view: &mut View| {
view.geometry_stats(&device);
wait();
view.geometry_stats(&device)
};
let input = input();
let frames = 7;
let mut of_a = Vec::new();
let mut of_b = Vec::new();
for frame in 0..frames {
let x = -3.5 + frame as f32;
scene
.add_instance(
&device,
&queue,
crate::InstanceState {
pose: glam::Mat4::from_translation(glam::Vec3::new(x, 0., -8.)),
..crate::InstanceState::new(model)
},
crate::Mobility::Static,
)
.unwrap();
if frame > 0 {
of_a.push(read(&mut a));
}
let with_b = frame % 2 == 0;
if with_b && frame > 0 {
of_b.push(read(&mut b));
}
let mut encoder = device.create_command_encoder(&Default::default());
let mut list = vec![ViewFrame {
view: &mut a,
input: &input,
settings: &settings,
output: &outputs[0],
timing: None,
}];
if with_b {
list.push(ViewFrame {
view: &mut b,
input: &input,
settings: &settings,
output: &outputs[1],
timing: None,
});
}
renderer.render(&device, &queue, &mut encoder, &mut scene, &mut list);
drop(list);
queue.submit([encoder.finish()]);
renderer.finish_frame(&mut scene);
wait();
}
assert!(
of_a.windows(2)
.all(|pair| pair[0].is_some() && pair[0] != pair[1]),
"each frame's statistics are its own: {of_a:?}"
);
for (index, b) in of_b.iter().enumerate() {
let frame = 2 * index;
assert_eq!(
*b,
of_a[frame],
"B's statistics after its frame {frame}, left out of frame {}",
frame + 1
);
}
}