use crate::asset::{self, Vertex};
use crate::renderer::Renderer;
use crate::settings::{self, Settings};
use crate::test_support::{self, TestShaderParams, add_test_shader, read, set_test_params};
use crate::{
AlphaMode, Camera, FrameInput, InstanceId, InstanceState, MaterialId, MaterialShader, Mobility,
ModelMesh, PreparedModel, Scene, SceneError, ShaderSource,
};
use glam::{DVec3, DVec4, Mat4, Vec3};
pub(super) const SIZE: [u32; 2] = [32, 32];
pub(super) fn settings() -> Settings {
Settings {
antialiasing: settings::Antialiasing::Off,
bloom: settings::Bloom::Off,
atmosphere: false,
ambient_occlusion: settings::AmbientOcclusionQuality::Off,
..Settings::default()
}
}
fn receiving() -> Settings {
Settings {
screen_space_reflections: settings::ScreenSpaceReflections::Full,
reflection_method: settings::ReflectionMethod::Velvet,
..settings()
}
}
pub(super) struct Harness {
pub device: wgpu::Device,
pub queue: wgpu::Queue,
pub renderer: Renderer,
pub settings: Settings,
pub output: wgpu::TextureView,
pub scene: Scene,
}
impl Harness {
pub fn new(settings: Settings) -> Option<Self> {
Some(Self::on(test_support::device()?, settings))
}
pub fn on((device, queue): (wgpu::Device, wgpu::Queue), settings: Settings) -> Self {
let renderer = Renderer::for_test(&device, &queue, SIZE, &settings);
let output = crate::view::targets::target(
&device,
"shader frames",
SIZE,
crate::shading::gbuffer::COLOR,
);
let scene = Scene::new(&device, &queue);
Self {
device,
queue,
renderer,
settings,
output,
scene,
}
}
pub fn frame(&mut self, input: &FrameInput) {
let mut encoder = self.device.create_command_encoder(&Default::default());
self.renderer.render(
&self.device,
&self.queue,
&mut encoder,
&mut self.scene,
input,
&self.settings,
&self.output,
None,
);
self.queue.submit([encoder.finish()]);
self.renderer.finish_frame(&mut self.scene);
}
fn depths(&self, texture: &wgpu::Texture) -> Vec<f32> {
bytemuck::cast_slice(&read(&self.device, &self.queue, texture, 4)).to_vec()
}
fn depth(&self) -> Vec<f32> {
self.depths(self.renderer.targets().depth.texture())
}
fn surface_depth(&self) -> Vec<f32> {
let surface = self.renderer.targets().surface.as_ref().expect("receivers");
self.depths(surface.depth.texture())
}
fn motion(&self) -> Vec<[f32; 2]> {
let texels = read(
&self.device,
&self.queue,
self.renderer.targets().motion.texture(),
4,
);
texels
.chunks_exact(4)
.map(|texel| [test_support::half(texel), test_support::half(&texel[2..])])
.collect()
}
pub fn composite(&self) -> Vec<[f32; 4]> {
let texels = read(
&self.device,
&self.queue,
self.renderer.targets().composite.texture(),
8,
);
texels
.chunks_exact(8)
.map(|texel| std::array::from_fn(|channel| test_support::half(&texel[channel * 2..])))
.collect()
}
pub fn material(&mut self, values: asset::Material) -> MaterialId {
let (device, queue) = (&self.device, &self.queue);
self.scene
.add_materials(device, queue, &[values], &[])
.unwrap_or_else(|error| panic!("{error}"))[0]
}
pub fn shaded(
&mut self,
values: asset::Material,
shader: crate::ShaderId,
bound: f32,
) -> MaterialId {
let material = self.material(values);
test_support::set_shader(&mut self.scene, &self.queue, material, (shader, bound));
material
}
pub fn place(
&mut self,
(vertices, data): (Vec<Vertex>, Vec<[f32; 4]>),
material: MaterialId,
instance: [f32; 4],
) -> InstanceId {
let (device, queue) = (&self.device, &self.queue);
let mesh = ModelMesh {
vertices,
indices: vec![0, 1, 2, 0, 2, 3],
material,
deformation: Default::default(),
};
let prepared = PreparedModel::with_shader_data(vec![mesh], vec![data]).unwrap();
let model = self.scene.add_model(device, queue, prepared).unwrap();
let id = self
.scene
.add_instance(device, queue, InstanceState::new(model), Mobility::Static)
.unwrap();
self.scene
.set_instance_shader_data(queue, id, instance)
.unwrap();
id
}
}
fn ground(x: [f32; 2], z: [f32; 2], slope: f32) -> (Vec<Vertex>, Vec<[f32; 4]>) {
let corners = [(x[0], z[1]), (x[1], z[1]), (x[1], z[0]), (x[0], z[0])];
let vertices = corners
.map(|(x, z)| Vertex {
position: [x, 0., z],
normal: [0., 1., 0.],
color: [1.; 4],
lightmap_bounds: [0., 0., 1., 1.],
..bytemuck::Zeroable::zeroed()
})
.to_vec();
let data = corners.map(|(x, _)| [slope * x, 0., 0., 0.]).to_vec();
(vertices, data)
}
pub(super) fn wall(x: [f32; 2], y: [f32; 2], z: f32) -> (Vec<Vertex>, Vec<[f32; 4]>) {
let corners = [(x[0], y[0]), (x[1], y[0]), (x[1], y[1]), (x[0], y[1])];
let vertices = corners
.map(|(x, y)| Vertex {
position: [x, y, z],
normal: [0., 0., 1.],
color: [1.; 4],
lightmap_bounds: [0., 0., 1., 1.],
..bytemuck::Zeroable::zeroed()
})
.to_vec();
(vertices, Vec::new())
}
fn opaque() -> asset::Material {
asset::Material {
base: [0.8, 0.8, 0.8, 1.],
metallic: 0.,
double_sided: true,
..Default::default()
}
}
fn receiver() -> asset::Material {
asset::Material {
alpha: AlphaMode::Blend {
receives_screen_space_reflections: true,
keeps_specular: true,
},
..opaque()
}
}
fn looking_down() -> Camera {
let eye = Vec3::new(0., 4., 6.);
Camera {
view: glam::camera::rh::view::look_at_mat4(eye, Vec3::ZERO, Vec3::Y),
projection: crate::perspective(1., 1., 0.1),
eye,
}
}
pub(super) fn frame(camera: Camera, time: f64) -> FrameInput {
let mut input = FrameInput::new(camera);
input.elapsed_seconds = time;
input.backdrop = crate::Backdrop::Color([0.; 3]);
input.baked_lighting = false;
input
}
pub(super) fn ray(camera: &Camera, [x, y]: [u32; 2]) -> (DVec3, DVec3) {
let clip_from_world = (camera.projection * camera.view).as_dmat4();
let world_from_clip = clip_from_world.inverse();
let ndc_x = (f64::from(x) + 0.5) / f64::from(SIZE[0]) * 2. - 1.;
let ndc_y = 1. - (f64::from(y) + 0.5) / f64::from(SIZE[1]) * 2.;
let at = |depth: f64| {
let p = world_from_clip * DVec4::new(ndc_x, ndc_y, depth, 1.);
p.truncate() / p.w
};
let (near, beyond) = (at(1.), at(0.5));
(near, (beyond - near).normalize())
}
fn meets((origin, direction): (DVec3, DVec3), (a, b): (f64, f64)) -> DVec3 {
let normal = DVec3::new(-b, 1., 0.);
let t = (a - normal.dot(origin)) / normal.dot(direction);
origin + direction * t
}
fn project(camera: &Camera, point: DVec3) -> (f64, [f64; 2]) {
let clip = (camera.projection * camera.view).as_dmat4() * point.extend(1.);
(
clip.z / clip.w,
[clip.x / clip.w * 0.5, -clip.y / clip.w * 0.5],
)
}
pub(super) fn texel<T: Copy>(texels: &[T], [x, y]: [u32; 2]) -> T {
texels[(y * SIZE[0] + x) as usize]
}
fn assert_depth(observed: f32, expected: f64, label: &str) {
assert!(
(f64::from(observed) - expected).abs() <= 2e-4 * expected,
"{label}: depth {observed}, expected {expected}"
);
}
const PIXELS: [[u32; 2]; 5] = [[4, 12], [27, 12], [16, 16], [6, 26], [25, 27]];
#[test]
fn the_vertex_function_places_the_surface_in_every_camera_pass() {
let Some(mut harness) = Harness::new(receiving()) else {
return;
};
let params = TestShaderParams {
direction: [0., 1., 0.],
lift: 0.25,
..Default::default()
};
let camera = looking_down();
let halves: [([f32; 2], f32); 2] = [([-8., 0.], 0.5), ([0., 8.], 1.)];
for (kind, receives) in [("opaque", false), ("receiver", true)] {
harness.scene = Scene::new(&harness.device, &harness.queue);
let shader = add_test_shader(&mut harness.scene);
let values = if receives { receiver() } else { opaque() };
let material = harness.shaded(values, shader, 2.);
set_test_params(&mut harness.scene, &harness.queue, material, params);
for (x, instance) in halves {
harness.place(ground(x, [-8., 8.], 0.1), material, [instance, 0., 0., 0.]);
}
harness.frame(&frame(camera, 0.));
let depths = if receives {
harness.surface_depth()
} else {
harness.depth()
};
let mut checked = 0;
for pixel in PIXELS {
let expected = halves.iter().find_map(|&(x, instance)| {
let hit = meets(ray(&camera, pixel), (0.25 + f64::from(instance), 0.1));
(hit.x > f64::from(x[0]) + 0.3 && hit.x < f64::from(x[1]) - 0.3)
.then(|| project(&camera, hit).0)
});
if let Some(expected) = expected {
assert_depth(
texel(&depths, pixel),
expected,
&format!("{kind} {pixel:?}"),
);
checked += 1;
}
}
assert!(checked >= 4, "{kind}: the pixels lie on the quads");
}
}
#[test]
fn motion_follows_the_shaders_time_and_parameters() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
let shader = add_test_shader(&mut harness.scene);
let material = harness.shaded(opaque(), shader, 2.);
let instance = harness.place(ground([-8., 8.], [-8., 8.], 0.), material, [0.; 4]);
let camera = looking_down();
let waving = TestShaderParams {
direction: [0., 1., 0.],
amplitude: 0.5,
frequency: 2.,
..Default::default()
};
let height = |params: TestShaderParams, time: f64, data: f32| {
f64::from(params.lift)
+ f64::from(params.amplitude) * (f64::from(params.frequency) * time).sin()
+ f64::from(data)
};
let lifted = TestShaderParams {
direction: [0., 1., 0.],
lift: 0.2,
..Default::default()
};
let steps = [
(waving, 0., 0.3, None),
(waving, 0., 0.55, Some(height(waving, 0.3, 0.))),
(lifted, 0., 0.55, Some(height(waving, 0.55, 0.))),
(lifted, 0., 0.55, Some(height(lifted, 0.55, 0.))),
(lifted, 0.3, 0.55, Some(height(lifted, 0.55, 0.))),
(lifted, 0.3, 0.55, Some(height(lifted, 0.55, 0.3))),
];
for (step, (params, data, time, previous)) in steps.into_iter().enumerate() {
set_test_params(&mut harness.scene, &harness.queue, material, params);
harness
.scene
.set_instance_shader_data(&harness.queue, instance, [data, 0., 0., 0.])
.unwrap();
harness.frame(&frame(camera, time));
let Some(previous) = previous else {
continue;
};
let motion = harness.motion();
let now = height(params, time, data);
for pixel in PIXELS {
let point = meets(ray(&camera, pixel), (now, 0.));
let before = point - DVec3::Y * (now - previous);
let (_, [x, y]) = project(&camera, point);
let (_, [x0, y0]) = project(&camera, before);
let expected = [x - x0, y - y0];
let observed = texel(&motion, pixel);
for axis in 0..2 {
assert!(
(f64::from(observed[axis]) - expected[axis]).abs()
<= 2e-3 * expected[axis].abs() + 2e-4,
"step {step} {pixel:?}: motion {observed:?}, expected {expected:?}"
);
}
}
}
}
#[test]
fn a_render_origin_move_moves_no_surface() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
let shader = add_test_shader(&mut harness.scene);
let material = harness.shaded(opaque(), shader, 4.);
set_test_params(
&mut harness.scene,
&harness.queue,
material,
TestShaderParams {
direction: [0., 1., 0.],
..Default::default()
},
);
harness.place(
ground([-8., 8.], [-8., 8.], 0.1),
material,
[0.75, 0., 0., 0.],
);
let camera = looking_down();
harness.frame(&frame(camera, 1.));
let before = harness.depth();
let by = Vec3::new(10., 0., -20.);
harness
.scene
.move_origin(&harness.device, &harness.queue, by)
.unwrap();
let moved = Camera {
view: camera.view * Mat4::from_translation(by),
eye: camera.eye - by,
..camera
};
harness.frame(&frame(moved, 1.));
let after = harness.depth();
let motion = harness.motion();
for pixel in PIXELS {
let (was, is) = (texel(&before, pixel), texel(&after, pixel));
assert!(
(was - is).abs() <= 1e-4 * was,
"{pixel:?}: depth {was} before the move, {is} after"
);
let [x, y] = texel(&motion, pixel);
assert!(
x.abs() < 1e-4 && y.abs() < 1e-4,
"{pixel:?}: motion {x}, {y}"
);
}
}
#[test]
fn culling_grows_the_bounds_by_the_displacement_bound() {
let Some(mut harness) = Harness::new(receiving()) else {
return;
};
let shader = add_test_shader(&mut harness.scene);
let params = TestShaderParams {
direction: [0., 1., 0.],
lift: 12.,
..Default::default()
};
let walls = [opaque(), receiver()].map(|values| {
let material = harness.shaded(values, shader, 0.);
set_test_params(&mut harness.scene, &harness.queue, material, params);
material
});
harness.place(wall([-2., -0.5], [-13., -11.], -4.), walls[0], [0.; 4]);
harness.place(wall([0.5, 2.], [-13., -11.], -4.), walls[1], [0.; 4]);
let camera = Camera {
view: Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: Vec3::ZERO,
};
let (left, right) = ([7, 16], [25, 16]);
for (bound, drawn) in [(0., false), (12., true)] {
for material in walls {
let mut values = harness.scene.material(material).unwrap();
values.shader = values.shader.map(|shader| MaterialShader {
displacement_bound: bound,
..shader
});
harness
.scene
.set_material(&harness.queue, material, values)
.unwrap();
}
harness.frame(&frame(camera, 0.));
let expected = if drawn { 0.1 / 4. } else { 0. };
assert_depth(
texel(&harness.depth(), left),
expected,
&format!("the opaque wall at a bound of {bound}"),
);
assert_depth(
texel(&harness.surface_depth(), right),
expected,
&format!("the receiver at a bound of {bound}"),
);
}
}
#[test]
fn blended_shaders_read_the_opaque_depth_behind_them_on_the_extended_tier() {
let Some(adapter) = test_support::adapter() else {
return;
};
let basic = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
required_limits: wgpu::Limits::default(),
..Default::default()
}))
.unwrap();
for (tier, device) in [("Extended", test_support::device()), ("Basic", Some(basic))] {
let Some(device) = device else {
return;
};
let mut harness = Harness::on(device, settings());
let extended =
harness.renderer.binding_tier() == crate::graphics_device::BindingTier::Extended;
assert_eq!(extended, tier == "Extended", "the {tier} device's tier");
let shader = add_test_shader(&mut harness.scene);
let black = asset::Material {
base: [0., 0., 0., 1.],
unlit: true,
double_sided: true,
..Default::default()
};
let ground_material = harness.material(black.clone());
harness.place(ground([-8., 8.], [-8., 8.], 0.), ground_material, [0.; 4]);
let glass = harness.shaded(
asset::Material {
alpha: AlphaMode::Blend {
receives_screen_space_reflections: false,
keeps_specular: false,
},
..black
},
shader,
1.,
);
set_test_params(
&mut harness.scene,
&harness.queue,
glass,
TestShaderParams {
direction: [0., 1., 0.],
lift: 1.,
..Default::default()
},
);
harness.place(ground([-8., 8.], [-8., 8.], 0.), glass, [0.; 4]);
let camera = looking_down();
harness.frame(&frame(camera, 0.));
let composite = harness.composite();
for pixel in PIXELS {
let [behind, available, ..] = texel(&composite, pixel);
let ray = ray(&camera, pixel);
let distance = meets(ray, (0., 0.)).distance(meets(ray, (1., 0.)));
if extended {
assert!(
(f64::from(behind) - distance).abs() <= 0.01 * distance && available == 1.,
"{tier} {pixel:?}: {behind} behind and available {available}, expected {distance}"
);
} else {
assert!(
behind == 0. && available == 0.,
"{tier} {pixel:?}: {behind} behind and available {available}"
);
}
}
}
}
#[test]
fn an_added_instance_reads_no_removed_instances_data() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
let shader = add_test_shader(&mut harness.scene);
let material = harness.shaded(opaque(), shader, 2.);
set_test_params(
&mut harness.scene,
&harness.queue,
material,
TestShaderParams {
direction: [0., 1., 0.],
..Default::default()
},
);
let lifted = harness.place(ground([-8., 8.], [-8., 8.], 0.), material, [1., 0., 0., 0.]);
let camera = looking_down();
harness.frame(&frame(camera, 0.));
let model = harness.scene.instance(lifted).unwrap().model;
harness.scene.remove_instance(lifted).unwrap();
harness
.scene
.add_instance(
&harness.device,
&harness.queue,
InstanceState::new(model),
Mobility::Static,
)
.unwrap();
harness.frame(&frame(camera, 0.));
let depths = harness.depth();
for pixel in PIXELS {
let expected = project(&camera, meets(ray(&camera, pixel), (0., 0.))).0;
assert_depth(texel(&depths, pixel), expected, &format!("{pixel:?}"));
}
}
#[test]
fn the_surface_function_reads_this_frames_instance_data() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
let shader = add_test_shader(&mut harness.scene);
let material = harness.shaded(
asset::Material {
base: [0., 0., 0., 1.],
unlit: true,
double_sided: true,
..Default::default()
},
shader,
0.,
);
let instance = harness.place(
ground([-8., 8.], [-8., 8.], 0.),
material,
[0., 0.25, 0., 0.],
);
let camera = looking_down();
harness.frame(&frame(camera, 0.));
let first = harness.composite();
harness
.scene
.set_instance_shader_data(&harness.queue, instance, [0., 0.5, 0., 0.])
.unwrap();
harness.frame(&frame(camera, 1. / 60.));
let second = harness.composite();
for pixel in PIXELS {
for (composite, expected) in [(&first, 0.25), (&second, 0.5)] {
let [red, green, blue, _] = texel(composite, pixel);
assert!(
red == 0. && green == 0. && (blue - expected).abs() <= 1e-3,
"{pixel:?}: emission {red}, {green}, {blue}, expected blue {expected}"
);
}
}
}
#[test]
fn a_removed_shader_frees_its_programs() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
let material = harness.material(asset::Material {
alpha: AlphaMode::Blend {
receives_screen_space_reflections: false,
keeps_specular: false,
},
..Default::default()
});
harness.place(ground([-8., 8.], [-8., 8.], 0.), material, [0.; 4]);
let camera = looking_down();
for _ in 0..4 {
let shader = add_test_shader(&mut harness.scene);
let mut values = harness.scene.material(material).unwrap();
values.shader = Some(MaterialShader {
shader,
displacement_bound: 0.,
});
harness
.scene
.set_material(&harness.queue, material, values)
.unwrap();
harness.frame(&frame(camera, 0.));
let (modules, pipelines) = harness.renderer.test_shader_programs();
assert!(modules > 0 && pipelines > 0, "a drawn shader's programs");
values.shader = None;
harness
.scene
.set_material(&harness.queue, material, values)
.unwrap();
harness.scene.remove_shader(shader).unwrap();
harness.frame(&frame(camera, 0.));
assert_eq!(harness.renderer.test_shader_programs(), (0, 0));
}
}
#[test]
fn shader_lifetimes_and_parameter_blocks_are_held_to() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
let (device, queue) = (harness.device.clone(), harness.queue.clone());
let shader = add_test_shader(&mut harness.scene);
let named = harness.shaded(opaque(), shader, 1.);
let plain = harness.material(asset::Material::default());
let scene = &mut harness.scene;
assert!(matches!(
scene.set_shader_parameters(&queue, named, &[0; 12]),
Err(SceneError::ShaderParameters {
expected: 32,
given: 12
})
));
assert!(matches!(
scene.set_shader_parameters(&queue, plain, &[0; 32]),
Err(SceneError::ShaderParameters {
expected: 0,
given: 32
})
));
assert!(matches!(
scene.remove_shader(shader),
Err(SceneError::ShaderInUse)
));
let mut other = Scene::new(&device, &queue);
let foreign = add_test_shader(&mut other);
let mut foreign_values = scene.material(plain).unwrap();
foreign_values.shader = Some(MaterialShader {
shader: foreign,
displacement_bound: 1.,
});
assert!(matches!(
scene.set_material(&queue, plain, foreign_values),
Err(SceneError::UnknownShader)
));
let mut values = scene.material(named).unwrap();
values.shader = None;
scene.set_material(&queue, named, values).unwrap();
scene.remove_shader(shader).unwrap();
assert!(matches!(
scene.remove_shader(shader),
Err(SceneError::UnknownShader)
));
assert!(matches!(
scene.shader_parameters_layout(shader),
Err(SceneError::UnknownShader)
));
values.shader = Some(MaterialShader {
shader,
displacement_bound: 1.,
});
assert!(matches!(
scene.set_material(&queue, named, values),
Err(SceneError::UnknownShader)
));
let live = add_test_shader(scene);
values.shader = Some(MaterialShader {
shader: live,
displacement_bound: f32::NAN,
});
assert!(matches!(
scene.set_material(&queue, named, values),
Err(SceneError::InvalidDisplacementBound)
));
assert!(matches!(
scene.add_shader(ShaderSource {
wgsl: "fn material_vertex() {}".into(),
label: "broken".into(),
}),
Err(SceneError::Shader(_))
));
let (vertices, mut data) = ground([0., 1.], [0., 1.], 0.);
data.pop();
let mesh = ModelMesh {
vertices,
indices: vec![0, 1, 2],
material: plain,
deformation: Default::default(),
};
assert!(matches!(
PreparedModel::with_shader_data(vec![mesh.clone(), mesh.clone()], vec![Vec::new(), data]),
Err(SceneError::ShaderDataLength { mesh: 1 })
));
assert!(matches!(
PreparedModel::with_shader_data(vec![mesh], Vec::new()),
Err(SceneError::ShaderDataLength { mesh: 0 })
));
}