use super::shader_tests::{Harness, SIZE, frame, ray, settings, texel, wall};
use crate::asset::{self, Vertex};
use crate::settings::Settings;
use crate::test_support::{self, VOLUME_SHADER, VolumeShaderParams};
use crate::{
AlphaMode, Camera, InstanceId, InstanceState, MaterialId, Mobility, ModelMesh, PreparedModel,
Scene, ShaderId, ShaderSource,
};
use glam::{DVec3, Mat4, Quat, Vec3};
const NONE: f32 = 0.;
const EXIT: f32 = 1.;
const OPAQUE: f32 = 2.;
const HIDDEN: f32 = 3.;
const ENTRY: f32 = 4.;
const EYE: f32 = 5.;
const MARGIN: f64 = 0.03;
#[derive(Clone, Copy)]
struct Cuboid {
center: Vec3,
half: Vec3,
pose: Mat4,
}
impl Cuboid {
fn new(center: [f32; 3], half: [f32; 3]) -> Self {
Self {
center: Vec3::from_array(center),
half: Vec3::from_array(half),
pose: Mat4::IDENTITY,
}
}
fn mesh(self) -> (Vec<Vertex>, Vec<u32>) {
let cube = test_support::cube();
let mesh = &cube.meshes[0];
let vertices = mesh
.vertices
.iter()
.map(|vertex| Vertex {
position: (self.center + Vec3::from_array(vertex.position) * 2. * self.half)
.to_array(),
..*vertex
})
.collect();
(vertices, mesh.indices.clone())
}
fn moved(self, by: Vec3) -> Self {
Self {
center: self.center + by,
..self
}
}
fn crossing(self, (origin, direction): (DVec3, DVec3), margin: f64) -> Option<(f64, f64)> {
let local = self.pose.as_dmat4().inverse();
let origin = local.transform_point3(origin);
let direction = local.transform_vector3(direction);
let (center, half) = (self.center.as_dvec3(), self.half.as_dvec3());
let (mut near, mut far) = (f64::NEG_INFINITY, f64::INFINITY);
for axis in 0..3 {
if direction[axis].abs() < 1e-12 {
if (origin[axis] - center[axis]).abs() >= half[axis] {
return None;
}
continue;
}
let a = (center[axis] - half[axis] - origin[axis]) / direction[axis];
let b = (center[axis] + half[axis] - origin[axis]) / direction[axis];
near = near.max(a.min(b));
far = far.min(a.max(b));
}
if near >= far || far <= 0. {
return None;
}
let clear = |t: f64| {
let point = origin + direction * t - center;
(0..3)
.filter(|&axis| point[axis].abs() > half[axis] - margin)
.count()
<= 1
};
(clear(far) && (near <= 0. || clear(near))).then_some((near, far))
}
fn near(self, ray: (DVec3, DVec3), margin: f64) -> bool {
let grown = Self {
half: self.half + Vec3::splat(margin as f32),
..self
};
grown.crossing(ray, -1.).is_some()
}
}
fn camera_at(eye: Vec3) -> Camera {
Camera {
view: Mat4::from_translation(-eye),
projection: crate::perspective(1., 1., 0.1),
eye,
}
}
fn black() -> asset::Material {
asset::Material {
base: [0., 0., 0., 1.],
unlit: true,
double_sided: true,
..Default::default()
}
}
fn add_volume_shader(scene: &mut Scene) -> ShaderId {
scene
.add_shader(ShaderSource {
wgsl: VOLUME_SHADER.into(),
label: "volume shader".into(),
})
.unwrap_or_else(|error| panic!("{error}"))
}
fn volume(
harness: &mut Harness,
shader: ShaderId,
params: VolumeShaderParams,
bound: f32,
) -> MaterialId {
let material = harness.shaded(
asset::Material {
alpha: AlphaMode::Blend {
receives_screen_space_reflections: false,
keeps_specular: false,
},
..black()
},
shader,
bound,
);
harness
.scene
.set_shader_parameters(&harness.queue, material, bytemuck::bytes_of(¶ms))
.unwrap();
material
}
fn place_box(
harness: &mut Harness,
cuboid: Cuboid,
material: MaterialId,
shown: [f32; 2],
) -> InstanceId {
let (device, queue) = (&harness.device, &harness.queue);
let (vertices, indices) = cuboid.mesh();
let mesh = ModelMesh {
vertices,
indices,
material,
deformation: Default::default(),
};
let prepared = PreparedModel::with_shader_data(vec![mesh], vec![Vec::new()]).unwrap();
let model = harness.scene.add_model(device, queue, prepared).unwrap();
let state = InstanceState {
pose: cuboid.pose,
..InstanceState::new(model)
};
let id = harness
.scene
.add_instance(device, queue, state, Mobility::Static)
.unwrap();
harness
.scene
.set_instance_shader_data(queue, id, [shown[0], shown[1], 0., 0.])
.unwrap();
id
}
fn place_wall(harness: &mut Harness, z: f32) -> InstanceId {
let material = harness.material(black());
harness.place(wall([-40., 40.], [-40., 40.], z), material, [0.; 4])
}
type Expected = Option<(f64, f32, bool)>;
fn check(composite: &[[f32; 4]], label: &str, expected: impl Fn([u32; 2]) -> Expected) -> usize {
let mut checked = 0;
for y in 0..SIZE[1] {
for x in 0..SIZE[0] {
let pixel = [x, y];
let Some((length, bound, front)) = expected(pixel) else {
continue;
};
let [observed, observed_bound, side, _] = texel(composite, pixel);
let tolerance = 0.01 * length + 2e-3;
assert!(
(f64::from(observed) - length).abs() <= tolerance
&& observed_bound == bound
&& side == f32::from(u8::from(front)),
"{label} {pixel:?}: length {observed}, bound {observed_bound}, front {side}; \
expected {length}, {bound}, {front}"
);
checked += 1;
}
}
checked
}
#[test]
fn a_front_fragment_measures_to_its_exit_whatever_lies_behind() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
if !harness.renderer.volume_paths_in_effect(&harness.settings) {
eprintln!("skipping: the Basic tier measures no volume path");
return;
}
let shader = add_volume_shader(&mut harness.scene);
let still = VolumeShaderParams {
direction: [1., 0., 0.],
lift: 0.,
};
let material = volume(&mut harness, shader, still, 2.);
let thin = Cuboid {
pose: Mat4::from_translation(Vec3::new(0., 0., -5.)) * Mat4::from_rotation_y(0.5),
..Cuboid::new([0., 0., 0.], [1.2, 1.2, 0.3])
};
place_box(&mut harness, thin, material, [1., 0.]);
let camera = camera_at(Vec3::ZERO);
let thickness = |cuboid: Cuboid| {
move |pixel| {
cuboid
.crossing(ray(&camera, pixel), MARGIN)
.map(|(near, far)| (far - near, EXIT, true))
}
};
let mut wall = place_wall(&mut harness, -9.);
for depth in [9., 15.] {
if depth != 9. {
harness.scene.remove_instance(wall).unwrap();
wall = place_wall(&mut harness, -depth);
}
harness.frame(&frame(camera, 0.));
let checked = check(
&harness.composite(),
&format!("the wall at {depth} m"),
thickness(thin),
);
assert!(checked >= 60, "the wall at {depth} m: {checked} pixels");
}
let lift = 1.5;
harness
.scene
.set_shader_parameters(
&harness.queue,
material,
bytemuck::bytes_of(&VolumeShaderParams { lift, ..still }),
)
.unwrap();
harness.frame(&frame(camera, 0.));
let moved = thin.moved(Vec3::X * lift);
let checked = check(&harness.composite(), "displaced", thickness(moved));
let off_rest = (0..SIZE[0] * SIZE[1])
.map(|index| [index % SIZE[0], index / SIZE[0]])
.filter(|&pixel| {
let ray = ray(&camera, pixel);
moved.crossing(ray, MARGIN).is_some() && !thin.near(ray, MARGIN)
})
.count();
assert!(
checked >= 60 && off_rest >= 20,
"displaced: {checked} pixels, {off_rest} off the box at rest"
);
}
#[test]
fn an_opaque_surface_inside_the_volume_bounds_its_path() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
if !harness.renderer.volume_paths_in_effect(&harness.settings) {
eprintln!("skipping: the Basic tier measures no volume path");
return;
}
let shader = add_volume_shader(&mut harness.scene);
let material = volume(&mut harness, shader, VolumeShaderParams::default(), 0.);
let outer = Cuboid::new([0., 0., -6.], [2., 2., 2.]);
let inner = Cuboid::new([0.2, -0.1, -6.], [0.7, 0.7, 0.7]);
place_box(&mut harness, outer, material, [1., 0.]);
let opaque = harness.material(black());
let (vertices, indices) = inner.mesh();
let (device, queue) = (&harness.device, &harness.queue);
let model = harness
.scene
.add_model(
device,
queue,
PreparedModel::new(vec![ModelMesh {
vertices,
indices,
material: opaque,
deformation: Default::default(),
}])
.unwrap(),
)
.unwrap();
harness
.scene
.add_instance(device, queue, InstanceState::new(model), Mobility::Static)
.unwrap();
let camera = camera_at(Vec3::ZERO);
harness.frame(&frame(camera, 0.));
let composite = harness.composite();
let at_inner = check(&composite, "over the opaque cube", |pixel| {
let ray = ray(&camera, pixel);
let (entry, _) = outer.crossing(ray, MARGIN)?;
let (inside, _) = inner.crossing(ray, MARGIN)?;
Some((inside - entry, OPAQUE, true))
});
let beside = check(&composite, "beside the opaque cube", |pixel| {
let ray = ray(&camera, pixel);
let (entry, exit) = outer.crossing(ray, MARGIN)?;
(!inner.near(ray, MARGIN)).then_some((exit - entry, EXIT, true))
});
assert!(
at_inner >= 20 && beside >= 40,
"{at_inner} pixels over the cube, {beside} beside it"
);
}
#[test]
fn a_volume_behind_another_measures_its_own_exit() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
if !harness.renderer.volume_paths_in_effect(&harness.settings) {
eprintln!("skipping: the Basic tier measures no volume path");
return;
}
let shader = add_volume_shader(&mut harness.scene);
let material = volume(&mut harness, shader, VolumeShaderParams::default(), 0.);
let near = Cuboid::new([0.1, 0., -3.], [0.5, 0.5, 0.25]);
let middle = Cuboid::new([0., 0.1, -5.], [1.4, 1.4, 0.3]);
let far = Cuboid::new([0., 0., -8.], [3.5, 3.5, 0.5]);
place_box(&mut harness, near, material, [0., 0.]);
place_box(&mut harness, middle, material, [0., 0.]);
place_box(&mut harness, far, material, [1., 0.]);
place_wall(&mut harness, -12.);
let camera = camera_at(Vec3::ZERO);
harness.frame(&frame(camera, 0.));
let composite = harness.composite();
let counted =
[(true, true), (false, true), (false, false)].map(|(behind_near, behind_middle)| {
let label =
format!("behind the near box {behind_near}, the middle box {behind_middle}");
check(&composite, &label, |pixel| {
let ray = ray(&camera, pixel);
let crosses = |cuboid: Cuboid| {
if cuboid.crossing(ray, MARGIN).is_some() {
Some(true)
} else if cuboid.near(ray, MARGIN) {
None
} else {
Some(false)
}
};
if crosses(near)? != behind_near || crosses(middle)? != behind_middle {
return None;
}
let (entry, exit) = far.crossing(ray, MARGIN)?;
if behind_near {
let to_wall = (-12. - ray.0.z) / ray.1.z;
Some((to_wall - entry, HIDDEN, true))
} else {
Some((exit - entry, EXIT, true))
}
})
});
assert!(
counted.iter().all(|&count| count >= 15),
"pixels behind both nearer boxes, the middle alone and neither: {counted:?}"
);
}
#[test]
fn a_back_fragment_measures_from_its_entry_or_the_eye() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
if !harness.renderer.volume_paths_in_effect(&harness.settings) {
eprintln!("skipping: the Basic tier measures no volume path");
return;
}
let shader = add_volume_shader(&mut harness.scene);
let material = volume(&mut harness, shader, VolumeShaderParams::default(), 0.);
let cuboid = Cuboid {
pose: Mat4::from_translation(Vec3::new(0., 0., -5.)) * Mat4::from_rotation_y(0.3),
..Cuboid::new([0., 0., 0.], [2., 2., 2.])
};
place_box(&mut harness, cuboid, material, [0., 1.]);
place_wall(&mut harness, -14.);
let outside = camera_at(Vec3::ZERO);
harness.frame(&frame(outside, 0.));
let from_entry = check(&harness.composite(), "from outside", |pixel| {
let (entry, exit) = cuboid.crossing(ray(&outside, pixel), MARGIN)?;
Some((exit - entry, ENTRY, false))
});
let eye = Vec3::new(0.4, -0.3, -4.2);
let inside = camera_at(eye);
harness.frame(&frame(inside, 0.));
let from_eye = check(&harness.composite(), "from inside", |pixel| {
let ray = ray(&inside, pixel);
let (_, exit) = cuboid.crossing(ray, MARGIN)?;
Some(((ray.0 + ray.1 * exit).distance(eye.as_dvec3()), EYE, false))
});
assert!(
from_entry >= 60 && from_eye >= 200,
"{from_entry} pixels from outside, {from_eye} from inside"
);
}
#[test]
fn a_back_fragment_behind_another_exit_is_hidden() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
if !harness.renderer.volume_paths_in_effect(&harness.settings) {
eprintln!("skipping: the Basic tier measures no volume path");
return;
}
let shader = add_volume_shader(&mut harness.scene);
let material = volume(&mut harness, shader, VolumeShaderParams::default(), 0.);
let outer = Cuboid::new([0., 0., -3.], [3., 3., 4.]);
let inner = Cuboid::new([0.1, -0.1, -3.5], [0.8, 0.8, 0.4]);
place_box(&mut harness, outer, material, [0., 1.]);
place_box(&mut harness, inner, material, [0., 0.]);
place_wall(&mut harness, -12.);
let eye = Vec3::new(0.2, -0.1, 0.);
let camera = camera_at(eye);
harness.frame(&frame(camera, 0.));
let composite = harness.composite();
let counted = [true, false].map(|behind| {
check(
&composite,
&format!("behind the inner box {behind}"),
|pixel| {
let ray = ray(&camera, pixel);
let crosses = if inner.crossing(ray, MARGIN).is_some() {
true
} else if inner.near(ray, MARGIN) {
return None;
} else {
false
};
if crosses != behind {
return None;
}
let (_, exit) = outer.crossing(ray, MARGIN)?;
let from_eye = (ray.0 + ray.1 * exit).distance(eye.as_dvec3());
Some((from_eye, if behind { HIDDEN } else { EYE }, false))
},
)
});
assert!(
counted[0] >= 20 && counted[1] >= 100,
"{} pixels behind the inner box, {} beside it",
counted[0],
counted[1]
);
}
#[test]
fn a_mirrored_volume_keeps_its_sides() {
let Some(mut harness) = Harness::new(settings()) else {
return;
};
if !harness.renderer.volume_paths_in_effect(&harness.settings) {
eprintln!("skipping: the Basic tier measures no volume path");
return;
}
let shader = add_volume_shader(&mut harness.scene);
let material = volume(&mut harness, shader, VolumeShaderParams::default(), 0.);
let mirrored = Cuboid {
pose: Mat4::from_translation(Vec3::new(0., 0., -5.))
* Mat4::from_rotation_y(0.4)
* Mat4::from_scale(Vec3::new(-1., 1., 1.)),
..Cuboid::new([0.3, 0., 0.], [1.2, 1., 0.5])
};
let id = place_box(&mut harness, mirrored, material, [1., 0.]);
place_wall(&mut harness, -12.);
let camera = camera_at(Vec3::ZERO);
for (front, bound, shown) in [(true, EXIT, [1., 0.]), (false, ENTRY, [0., 1.])] {
harness
.scene
.set_instance_shader_data(&harness.queue, id, [shown[0], shown[1], 0., 0.])
.unwrap();
harness.frame(&frame(camera, 0.));
let checked = check(&harness.composite(), &format!("front {front}"), |pixel| {
let (entry, exit) = mirrored.crossing(ray(&camera, pixel), MARGIN)?;
Some((exit - entry, bound, front))
});
assert!(checked >= 60, "front {front}: {checked} pixels");
}
}
#[test]
fn no_path_is_measured_on_the_basic_tier_or_with_the_setting_off() {
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();
let off = Settings {
volume_paths: false,
..settings()
};
for (label, device, settings) in [
("Extended, off", test_support::device(), off),
("Basic, on", Some(basic), settings()),
] {
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, label.starts_with("Extended"), "{label}: the tier");
assert!(
!harness.renderer.volume_paths_in_effect(&harness.settings),
"{label}: volume paths in effect"
);
if extended {
assert!(
harness
.renderer
.volume_paths_in_effect(&super::shader_tests::settings()),
"{label}: volume paths out of effect with the setting on"
);
}
let shader = add_volume_shader(&mut harness.scene);
let material = volume(&mut harness, shader, VolumeShaderParams::default(), 0.);
let cuboid = Cuboid::new([0., 0., -5.], [1.5, 1.5, 0.5]);
place_box(&mut harness, cuboid, material, [1., 0.]);
place_wall(&mut harness, -9.);
let camera = camera_at(Vec3::ZERO);
harness.frame(&frame(camera, 0.));
let checked = check(&harness.composite(), label, |pixel| {
cuboid
.crossing(ray(&camera, pixel), MARGIN)
.map(|_| (0., NONE, true))
});
assert!(checked >= 60, "{label}: {checked} pixels");
}
}
#[test]
fn volume_layers_are_drawn_only_for_a_shader_that_reads_them() {
let Some(gpu) = test_support::device_choosing(|adapter| {
crate::graphics_device::features(adapter)
| (adapter.features() & wgpu::Features::TIMESTAMP_QUERY)
}) else {
return;
};
let mut harness = Harness::on(gpu, settings());
let Some(mut timing) = crate::timing::GpuTiming::new(&harness.device, &harness.queue) else {
eprintln!("skipping: the adapter has no timestamp queries");
return;
};
if !harness.renderer.volume_paths_in_effect(&harness.settings) {
eprintln!("skipping: the Basic tier measures no volume path");
return;
}
let reading = add_volume_shader(&mut harness.scene);
let reading = volume(&mut harness, reading, VolumeShaderParams::default(), 0.);
let other = test_support::add_test_shader(&mut harness.scene);
let other = harness.shaded(
asset::Material {
alpha: AlphaMode::Blend {
receives_screen_space_reflections: false,
keeps_specular: false,
},
..black()
},
other,
0.,
);
place_box(
&mut harness,
Cuboid::new([0., 0., -5.], [1., 1., 1.]),
reading,
[1., 0.],
);
place_box(
&mut harness,
Cuboid::new([0., 0., 5.], [1., 1., 1.]),
other,
[1., 0.],
);
let mut drawn = |facing: Quat, on: bool| {
let settings = Settings {
volume_paths: on,
..harness.settings
};
let input = frame(
Camera {
view: Mat4::from_quat(facing),
..camera_at(Vec3::ZERO)
},
0.,
);
let (device, queue) = (&harness.device, &harness.queue);
let _ = timing.begin_frame(device, queue);
let mut encoder = device.create_command_encoder(&Default::default());
harness.renderer.render(
device,
queue,
&mut encoder,
&mut harness.scene,
&input,
&settings,
&harness.output,
Some(&timing),
);
queue.submit([encoder.finish()]);
timing.submitted(queue);
harness.renderer.finish_frame(&mut harness.scene);
for _ in 0..8 {
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
if let Some(frame) = timing.begin_frame(device, queue).next_back() {
return frame.passes.iter().any(|pass| pass.name == "volume layers");
}
}
panic!("the frame's timings did not complete");
};
let away = Quat::from_rotation_y(std::f32::consts::PI);
for (label, facing, on, expected) in [
("facing the reading box", Quat::IDENTITY, true, true),
("facing the other box", away, true, false),
("with the setting off", Quat::IDENTITY, false, false),
("facing the reading box again", Quat::IDENTITY, true, true),
] {
assert_eq!(drawn(facing, on), expected, "{label}");
}
}