use super::froxels;
use crate::renderer::Renderer;
use crate::settings::{self, FogQuality, Settings};
use crate::shading::gbuffer;
use crate::{
Backdrop, Camera, DirectionalLight, DirectionalShadow, Fog, FrameInput, HemisphereLight,
InstanceState, Light, LightShape, Mobility, Scene, test_support,
};
use glam::{Mat4, Quat, Vec2, Vec3};
const SIZE: [u32; 2] = [160, 90];
const QUALITY: FogQuality = FogQuality::High;
fn projection() -> Mat4 {
crate::perspective(1., SIZE[0] as f32 / SIZE[1] as f32, 0.1)
}
fn settings(atmosphere: bool) -> Settings {
Settings {
antialiasing: settings::Antialiasing::Off,
bloom: settings::Bloom::Off,
atmosphere,
fog_quality: QUALITY,
..Settings::default()
}
}
fn input(fog: Fog) -> FrameInput {
let mut input = FrameInput::new(Camera {
view: Mat4::IDENTITY,
projection: projection(),
eye: Vec3::ZERO,
});
input.backdrop = Backdrop::Color([0.; 3]);
input.atmosphere = true;
input.fog = fog;
input
}
fn render(
device: &wgpu::Device,
queue: &wgpu::Queue,
scene: &mut Scene,
input: &FrameInput,
settings: &Settings,
frames: usize,
) -> Renderer {
let mut renderer = Renderer::for_test(device, queue, SIZE, settings);
let output = crate::view::targets::target(device, "fog frames", SIZE, gbuffer::COLOR);
for frame in 0..frames {
let mut input = *input;
input.camera_cut = frame == 0;
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);
}
renderer
}
fn texels(bytes: &[u8]) -> Vec<[f32; 4]> {
bytes
.chunks_exact(8)
.map(|texel| std::array::from_fn(|channel| test_support::half(&texel[channel * 2..])))
.collect()
}
fn read(device: &wgpu::Device, queue: &wgpu::Queue, view: &wgpu::TextureView) -> Vec<u8> {
test_support::read(device, queue, view.texture(), 8)
}
fn add_box(
device: &wgpu::Device,
queue: &wgpu::Queue,
scene: &mut Scene,
center: Vec3,
scale: Vec3,
) {
let ids = scene
.add_asset(device, queue, test_support::cube())
.unwrap();
scene
.add_instance(
device,
queue,
InstanceState {
model: ids.model,
pose: Mat4::from_translation(center) * Mat4::from_scale(scale),
visible: true,
capture_visible: true,
},
Mobility::Static,
)
.unwrap();
}
fn froxel_center(input: &FrameInput, size: [u32; 3], index: [u32; 3]) -> Vec3 {
let (ndc, depth) = froxel_ray(input, size, [index[0], index[1]], index[2]);
view_ray(input, ndc) * depth
}
fn froxel_ray(input: &FrameInput, size: [u32; 3], column: [u32; 2], slice: u32) -> (Vec2, f32) {
let u = (column[0] as f32 + 0.5) / size[0] as f32;
let v = (column[1] as f32 + 0.5) / size[1] as f32;
let unit = (slice as f32 + 0.5) / size[2] as f32;
let depth = input.fog.length * unit.powf(crate::shading::fog::DETAIL_SPREAD);
(Vec2::new(u * 2. - 1., 1. - v * 2.), depth)
}
fn view_ray(input: &FrameInput, ndc: Vec2) -> Vec3 {
let p = input.camera.projection;
Vec3::new(
(ndc.x + p.z_axis.x) / p.x_axis.x,
(ndc.y + p.z_axis.y) / p.y_axis.y,
-1.,
)
}
#[test]
fn froxels_stay_square_and_within_the_texture_limit_however_thin_the_frame() {
const LIMIT: u32 = 2048;
for quality in [FogQuality::Low, FogQuality::High] {
for render in [[60, 1900], [1900, 60], [40, 1300], [1920, 1080], [7, 7]] {
let [x, y, _] = froxels(quality, render, LIMIT);
let [across, down, _] = froxels(quality, [render[1], render[0]], LIMIT);
assert_eq!([x, y], [down, across], "{quality:?} {render:?} transposed");
let aspect = (render[0] as f32 / x as f32) / (render[1] as f32 / y as f32);
let truncation = (x + 1) as f32 / x as f32 * (y + 1) as f32 / y as f32;
assert!(
aspect.max(aspect.recip()) <= truncation,
"{quality:?} {render:?}: {x}×{y} froxels, aspect {aspect}"
);
}
for render in [[1, 1 << 20], [1 << 20, 1]] {
let [x, y, _] = froxels(quality, render, LIMIT);
assert!(
(1..=LIMIT).contains(&x) && (1..=LIMIT).contains(&y),
"{quality:?} {render:?}: {x}×{y} froxels"
);
}
}
}
#[test]
fn an_empty_medium_leaves_the_frame_as_no_fog_does() {
let Some((device, queue)) = test_support::device() else {
return;
};
let mut scene = Scene::new(&device, &queue);
add_box(
&device,
&queue,
&mut scene,
Vec3::new(0., -0.5, -6.),
Vec3::new(3., 1., 3.),
);
let mut frame = input(Fog {
density: 0.,
length: 30.,
anisotropy: 0.5,
ambient: 1.,
..Fog::default()
});
frame.directional_lights[0] = Some(DirectionalLight {
direction: Vec3::new(0.3, -1., -0.4),
color: [1., 0.9, 0.8],
illuminance: 4.,
shadow: Some(DirectionalShadow {
distance: 30.,
cascades: 2,
}),
..Default::default()
});
frame.hemisphere_light = HemisphereLight {
sky_color: [0.4, 0.5, 0.7],
ground_color: [0.1, 0.1, 0.1],
intensity: 1.,
};
frame.backdrop = Backdrop::Color([0.2, 0.3, 0.45]);
let composite = |renderer: &Renderer| read(&device, &queue, &renderer.targets().composite);
let unfogged = composite(&render(
&device,
&queue,
&mut scene,
&frame,
&settings(false),
1,
));
let skipped = composite(&render(
&device,
&queue,
&mut scene,
&frame,
&settings(true),
1,
));
assert!(skipped == unfogged, "no medium changed the frame");
scene
.update_fog_volumes(
&device,
&queue,
&[crate::FogVolume {
center: Vec3::new(0., 0., -6.),
rotation: glam::Quat::IDENTITY,
size: Vec3::splat(4.),
density: 0.,
albedo: [1.; 3],
edge_fade: 0.,
}],
)
.unwrap();
let empty = render(&device, &queue, &mut scene, &frame, &settings(true), 2);
let integrated = texels(&read(&device, &queue, empty.fog_volumes()[2]));
assert!(
integrated.iter().all(|texel| *texel == [0., 0., 0., 1.]),
"an empty medium scattered or dimmed"
);
assert!(
composite(&empty) == unfogged,
"an empty medium changed the frame"
);
frame.fog.density = 0.05;
let dense = composite(&render(
&device,
&queue,
&mut scene,
&frame,
&settings(true),
1,
));
assert!(dense != unfogged, "a dense medium left the frame unfogged");
}
fn henyey_greenstein(cos_theta: f32, g: f32) -> f32 {
(1. - g * g) / (4. * std::f32::consts::PI * (1. + g * g - 2. * g * cos_theta).powf(1.5))
}
#[test]
fn point_light_scattering_matches_a_single_scattering_integral() {
let Some((device, queue)) = test_support::device() else {
return;
};
let mut scene = Scene::new(&device, &queue);
let light_position = Vec3::new(1.2, 1.2, -4.5);
let intensity = 40.;
let range = 25.;
scene
.add_light(
&device,
&queue,
Light {
position: light_position,
shape: LightShape::Point {
radius: LightShape::DEFAULT_RADIUS,
},
color: [1.; 3],
intensity,
range,
baked: false,
specular: 1.,
casts_shadow: false,
..Default::default()
},
)
.unwrap();
let fog = Fog {
density: 0.06,
albedo: [1., 0.5, 0.25],
anisotropy: 0.4,
length: 10.,
..Fog::default()
};
let frame = input(fog);
let renderer = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let size = froxels(QUALITY, SIZE, device.limits().max_texture_dimension_3d);
let integrated = texels(&read(&device, &queue, renderer.fog_volumes()[2]));
let mut checked = 0;
for column in [
[size[0] / 2, size[1] / 2],
[size[0] * 3 / 4, size[1] / 2],
[size[0] / 3, size[1] / 3],
[size[0] * 2 / 3, size[1] * 2 / 3],
] {
let along = view_ray(&frame, froxel_ray(&frame, size, column, 0).0);
let direction = along.normalize();
let closest = (light_position - direction * light_position.dot(direction)).length();
assert!(
closest > 1.,
"column {column:?} passes {closest} m from the light"
);
for slice in [size[2] / 4, size[2] / 2, size[2] * 3 / 4, size[2] - 1] {
let distance = froxel_ray(&frame, size, column, slice).1 * along.length();
let steps = 20_000;
let step = distance / steps as f32;
let mut reference = [0f32; 3];
for index in 0..steps {
let t = (index as f32 + 0.5) * step;
let point = direction * t;
let to_light = light_position - point;
let square = to_light.length_squared();
let window = (1. - (square / (range * range)).powi(2))
.clamp(0., 1.)
.powi(2);
let irradiance = intensity * window / square.max(1e-4);
let phase = henyey_greenstein(direction.dot(to_light.normalize()), fog.anisotropy);
let attenuated = irradiance * phase * (-fog.density * t).exp() * step;
for (sum, albedo) in reference.iter_mut().zip(fog.albedo) {
*sum += fog.density * albedo * attenuated;
}
}
let texel = integrated[((slice * size[1] + column[1]) * size[0] + column[0]) as usize];
for channel in 0..3 {
let error = (texel[channel] - reference[channel]).abs();
assert!(
error <= 0.03 * reference[channel] + 1e-4,
"column {column:?} slice {slice} channel {channel}: {} against the integral's {}",
texel[channel],
reference[channel]
);
}
let transmittance = (-fog.density * distance).exp();
assert!(
(texel[3] - transmittance).abs() <= 2e-3,
"column {column:?} slice {slice}: transmittance {} against Beer-Lambert's {transmittance}",
texel[3]
);
checked += usize::from(reference[0] > 1e-3);
}
}
assert!(
checked >= 8,
"too few samples carry measurable light: {checked}"
);
}
#[test]
fn a_still_point_light_holds_its_froxel_steady_over_the_jitter_cycle() {
let Some((device, queue)) = test_support::device() else {
return;
};
let fog = Fog {
density: 0.05,
anisotropy: 0.,
length: 100.,
..Fog::default()
};
let frame = input(fog);
let size = froxels(QUALITY, SIZE, device.limits().max_texture_dimension_3d);
let corner = |unit: Vec3| {
let ndc = Vec2::new(unit.x * 2. - 1., 1. - unit.y * 2.);
view_ray(&frame, ndc) * fog.length * unit.z.powf(crate::shading::fog::DETAIL_SPREAD)
};
for column in [
[size[0] / 2, size[1] / 2],
[1, 1],
[size[0] - 2, size[1] - 2],
] {
let index = [column[0], column[1], 12];
let (mut low, mut high) = (Vec3::splat(f32::MAX), Vec3::splat(f32::MIN));
for offset in 0..8u32 {
let unit = Vec3::new(
(index[0] + (offset & 1)) as f32 / size[0] as f32,
(index[1] + (offset >> 1 & 1)) as f32 / size[1] as f32,
(index[2] + (offset >> 2)) as f32 / size[2] as f32,
);
let p = corner(unit);
low = low.min(p);
high = high.max(p);
}
let mut scene = Scene::new(&device, &queue);
scene
.add_light(
&device,
&queue,
Light {
position: (low + high) * 0.5,
shape: LightShape::Point {
radius: LightShape::DEFAULT_RADIUS,
},
color: [1.; 3],
intensity: 10.,
range: 25.,
baked: false,
specular: 1.,
casts_shadow: false,
..Default::default()
},
)
.unwrap();
let settings = settings(true);
let mut renderer = Renderer::for_test(&device, &queue, SIZE, &settings);
let output = crate::view::targets::target(&device, "fog frames", SIZE, gbuffer::COLOR);
let at = ((index[2] * size[1] + index[1]) * size[0] + index[0]) as usize;
let mut light = Vec::new();
for frame_index in 0..48 {
let mut input = frame;
input.camera_cut = frame_index == 0;
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);
if frame_index >= 32 {
light.push(texels(&read(&device, &queue, renderer.fog_volumes()[0]))[at][0]);
}
}
let (least, most) = light
.iter()
.fold((f32::MAX, 0f32), |(least, most), &value| {
(least.min(value), most.max(value))
});
assert!(
least > 1e-3,
"froxel {index:?}, holding the light, is unlit: {light:?}"
);
assert!(
most <= 1.25 * least,
"froxel {index:?}, holding a still light, ranged {least} to {most} over a jitter cycle: {light:?}"
);
}
}
#[test]
fn a_light_holds_the_same_fog_on_either_side_of_the_screen() {
let Some((device, queue)) = test_support::device() else {
return;
};
let fog = Fog {
density: 0.05,
anisotropy: 0.,
length: 100.,
..Fog::default()
};
let frame = input(fog);
let size = froxels(QUALITY, SIZE, device.limits().max_texture_dimension_3d);
let held = |index: [u32; 3]| {
let mut scene = Scene::new(&device, &queue);
scene
.add_light(
&device,
&queue,
Light {
position: {
let center = froxel_center(&frame, size, index);
center - center.normalize() * 0.01
},
shape: LightShape::Point {
radius: LightShape::DEFAULT_RADIUS,
},
color: [1.; 3],
intensity: 10.,
range: 25.,
baked: false,
specular: 1.,
casts_shadow: false,
..Default::default()
},
)
.unwrap();
let renderer = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let at = ((index[2] * size[1] + index[1]) * size[0] + index[0]) as usize;
texels(&read(&device, &queue, renderer.fog_volumes()[0]))[at][0]
};
for (column, slice) in [([1, 1], 12), ([size[0] - 2, 1], 12), ([3, 5], 20)] {
let index = [column[0], column[1], slice];
let mirror = [size[0] - 1 - column[0], size[1] - 1 - column[1], slice];
let (light, mirrored) = (held(index), held(mirror));
assert!(
light > 1e-3,
"froxel {index:?}, holding the light, is unlit"
);
assert!(
(light - mirrored).abs() <= 4e-3 * light,
"froxel {index:?} holds {light} of a light at its centre, its mirror image {mirror:?} {mirrored}"
);
}
}
#[test]
fn froxels_far_smaller_than_their_distance_to_a_light_keep_its_falloff() {
let Some((device, queue)) = test_support::device() else {
return;
};
let fog = Fog {
density: 0.05,
anisotropy: 0.,
length: 10.,
..Fog::default()
};
let frame = input(fog);
let size = froxels(QUALITY, SIZE, device.limits().max_texture_dimension_3d);
let light_position = Vec3::new(1.5, 0.5, -5.5);
let intensity = 40.;
let range = 25.;
let mut scene = Scene::new(&device, &queue);
scene
.add_light(
&device,
&queue,
Light {
position: light_position,
shape: LightShape::Point {
radius: LightShape::DEFAULT_RADIUS,
},
color: [1.; 3],
intensity,
range,
baked: false,
specular: 1.,
casts_shadow: false,
..Default::default()
},
)
.unwrap();
let renderer = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let written = texels(&read(&device, &queue, renderer.fog_volumes()[0]));
let mut checked = 0;
for slice in [8, 12, 16] {
for column in [
[size[0] / 2, size[1] / 2],
[size[0] / 4, size[1] / 3],
[size[0] * 3 / 4, size[1] * 2 / 3],
] {
let index = [column[0], column[1], slice];
let center = froxel_center(&frame, size, index);
let square = (light_position - center).length_squared();
let window = (1. - (square / (range * range)).powi(2))
.clamp(0., 1.)
.powi(2);
let expected =
fog.density * intensity * window / square * henyey_greenstein(0., fog.anisotropy);
let texel = written[((slice * size[1] + column[1]) * size[0] + column[0]) as usize][0];
assert!(
(texel - expected).abs() <= 2e-3 * expected,
"froxel {index:?}, {} m from the light: {texel} against its falloff's {expected}",
square.sqrt()
);
checked += 1;
}
}
assert_eq!(checked, 9);
}
const GODOT_GAUSS: [f32; 7] = [
0.071303, 0.131514, 0.189879, 0.214607, 0.189879, 0.131514, 0.071303,
];
fn godot_gaussian(volume: &[[f32; 4]], size: [u32; 3], axis: usize) -> Vec<[f32; 4]> {
let index = |at: [u32; 3]| ((at[2] * size[1] + at[1]) * size[0] + at[0]) as usize;
let mut blurred = vec![[0.; 4]; volume.len()];
for z in 0..size[2] {
for y in 0..size[1] {
for x in 0..size[0] {
let at = [x, y, z];
let sum = &mut blurred[index(at)];
for (tap, weight) in GODOT_GAUSS.iter().enumerate() {
let mut from = at;
from[axis] =
(at[axis] as i32 + tap as i32 - 3).clamp(0, size[axis] as i32 - 1) as u32;
for (channel, value) in volume[index(from)].iter().enumerate() {
sum[channel] += weight * value;
}
}
}
}
}
blurred
}
#[test]
fn the_filter_blurs_each_slice_by_godots_gaussian_and_leaves_the_history_unfiltered() {
let Some((device, queue)) = test_support::device() else {
return;
};
let mut scene = Scene::new(&device, &queue);
scene
.add_light(
&device,
&queue,
Light {
position: Vec3::new(0.5, 0.3, -3.),
shape: LightShape::Point {
radius: LightShape::DEFAULT_RADIUS,
},
color: [1.; 3],
intensity: 40.,
range: 25.,
baked: false,
specular: 1.,
casts_shadow: false,
..Default::default()
},
)
.unwrap();
let frame = input(Fog {
density: 0.06,
height: -1.,
height_falloff: 3.,
length: 10.,
..Fog::default()
});
let mut volumes = |fog_filter: bool| {
let settings = Settings {
fog_filter,
..settings(true)
};
let renderer = render(&device, &queue, &mut scene, &frame, &settings, 2);
renderer
.fog_volumes()
.map(|view| texels(&read(&device, &queue, view)))
};
let [written, filtered, integrated] = volumes(true);
let [unfiltered_written, _, unfiltered_integrated] = volumes(false);
assert!(
written == unfiltered_written,
"the filter changed the froxels the next frame reprojects"
);
assert!(
integrated != unfiltered_integrated,
"the integration ignored the filter"
);
let size = froxels(QUALITY, SIZE, device.limits().max_texture_dimension_3d);
let expected = godot_gaussian(&godot_gaussian(&written, size, 0), size, 1);
let tolerance = |expected: f32| 2e-3 * expected + 1e-6;
let mut spread = [0; 2];
for (index, ((filtered, expected), written)) in
filtered.iter().zip(&expected).zip(&written).enumerate()
{
for channel in 0..4 {
assert!(
(filtered[channel] - expected[channel]).abs() <= tolerance(expected[channel]),
"froxel {index} channel {channel}: {} against Godot's Gaussian {}",
filtered[channel],
expected[channel]
);
}
for (moved, channel) in spread.iter_mut().zip([0, 3]) {
*moved += usize::from(
(expected[channel] - written[channel]).abs() > 10. * tolerance(expected[channel]),
);
}
}
assert!(
spread.iter().all(|moved| *moved > 10_000),
"the filter moved only {spread:?} froxels' light and extinction"
);
}
#[test]
fn shadowed_lights_scatter_almost_nothing_behind_their_occluder() {
let Some((device, queue)) = test_support::device() else {
return;
};
let fog = Fog {
density: 0.1,
anisotropy: 0.,
length: 20.,
..Fog::default()
};
let slab = |device: &wgpu::Device, queue: &wgpu::Queue| {
let mut scene = Scene::new(device, queue);
add_box(
device,
queue,
&mut scene,
Vec3::new(0., 1.5, -10.),
Vec3::new(40., 0.2, 40.),
);
scene
};
let spot = Vec3::new(0., 4., -10.);
let reached = |local: bool, point: Vec3| {
if local {
let below = spot.y - point.y;
let across = Vec3::new(point.x - spot.x, 0., point.z - spot.z).length();
below > 0.5 && across < below * 0.6f32.tan() && (spot - point).length() < 12.
} else {
point.x.abs() < 15. && point.z < -2. && point.z > -25.
}
};
for (label, local) in [("local atlas", true), ("directional cascades", false)] {
let mut scene = slab(&device, &queue);
let mut frame = input(fog);
if local {
scene
.add_light(
&device,
&queue,
Light {
position: spot,
shape: LightShape::Spot {
direction: Vec3::NEG_Y,
inner_angle: 0.6,
outer_angle: 0.9,
radius: LightShape::DEFAULT_RADIUS,
},
color: [1.; 3],
intensity: 100.,
range: 15.,
baked: false,
specular: 1.,
casts_shadow: true,
..Default::default()
},
)
.unwrap();
} else {
frame.directional_lights[0] = Some(DirectionalLight {
direction: Vec3::new(0.2, -1., 0.1),
color: [1.; 3],
illuminance: 5.,
shadow: Some(DirectionalShadow {
distance: 40.,
cascades: 2,
}),
..Default::default()
});
}
let renderer = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let size = froxels(QUALITY, SIZE, device.limits().max_texture_dimension_3d);
let froxels = texels(&read(&device, &queue, renderer.fog_volumes()[0]));
let (mut below, mut above) = (Vec::new(), Vec::new());
for z in 0..size[2] {
for y in 0..size[1] {
for x in 0..size[0] {
let point = froxel_center(&frame, size, [x, y, z]);
if !reached(local, point) || point.z > -1. {
continue;
}
let light = froxels[((z * size[1] + y) * size[0] + x) as usize][0];
if point.y < 0.4 {
below.push(light);
} else if point.y > 2.6 {
above.push(light);
}
}
}
}
assert!(
below.len() > 100 && above.len() > 10,
"{label}: {} froxels below and {} above",
below.len(),
above.len()
);
let darkest_above = above.iter().copied().fold(f32::MAX, f32::min);
let brightest_below = below.iter().copied().fold(0., f32::max);
assert!(darkest_above > 0., "{label}: lit medium scattered nothing");
let most_below = if local {
0.
} else {
darkest_above * (-10f32 * 1.2).exp()
};
assert!(
brightest_below <= most_below,
"{label}: {brightest_below} scattered beneath the occluder, against {darkest_above} above it"
);
}
}
#[test]
fn fog_energy_scales_a_light_in_the_medium_alone() {
let Some((device, queue)) = test_support::device() else {
return;
};
let fog = Fog {
density: 0.05,
anisotropy: 0.3,
length: 20.,
..Fog::default()
};
for (label, local) in [("scene light", true), ("directional light", false)] {
let observe = |fog_energy: f32| {
let mut scene = Scene::new(&device, &queue);
add_box(
&device,
&queue,
&mut scene,
Vec3::new(0., -2., -10.),
Vec3::new(20., 1., 20.),
);
let mut frame = input(fog);
if local {
scene
.add_light(
&device,
&queue,
Light {
position: Vec3::new(0., 3., -8.),
shape: LightShape::Spot {
direction: Vec3::NEG_Y,
inner_angle: 0.5,
outer_angle: 0.8,
radius: LightShape::DEFAULT_RADIUS,
},
intensity: 60.,
range: 12.,
casts_shadow: true,
fog_energy,
..Light::default()
},
)
.unwrap();
} else {
frame.directional_lights[0] = Some(DirectionalLight {
direction: Vec3::new(0.2, -1., 0.1),
illuminance: 3.,
shadow: Some(DirectionalShadow {
distance: 30.,
cascades: 2,
}),
fog_energy,
..DirectionalLight::default()
});
}
let fogged = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let in_scatter: Vec<[f32; 3]> = texels(&read(&device, &queue, fogged.fog_volumes()[0]))
.into_iter()
.map(|froxel| [froxel[0], froxel[1], froxel[2]])
.collect();
let unfogged = render(&device, &queue, &mut scene, &frame, &settings(false), 1);
let surfaces = read(&device, &queue, &unfogged.targets().composite);
(in_scatter, surfaces)
};
let (single, surfaces) = observe(1.);
let lit = single
.iter()
.filter(|froxel| froxel.iter().any(|&channel| channel > 1e-3))
.count();
assert!(lit > 100, "{label}: {lit} froxels carry measurable light");
let (double, _) = observe(2.);
for (index, (twice, once)) in double.iter().zip(&single).enumerate() {
for channel in 0..3 {
let expected = 2. * once[channel];
assert!(
(twice[channel] - expected).abs() <= 1e-3 * expected + 1e-6,
"{label}: froxel {index} channel {channel} holds {} at fog energy 2, twice {} is {expected}",
twice[channel],
once[channel]
);
}
}
let (none, surfaces_at_zero) = observe(0.);
assert!(
none.iter().flatten().all(|&channel| channel == 0.),
"{label}: the medium scattered light at fog energy 0"
);
assert!(
texels(&surfaces)
.iter()
.any(|texel| texel[..3].iter().any(|&channel| channel > 0.)),
"{label}: the light lit no surface"
);
assert!(
surfaces_at_zero == surfaces,
"{label}: fog energy 0 changed the surfaces' light"
);
}
}
#[test]
fn fog_volumes_add_their_medium_to_every_froxel_they_reach() {
let Some((device, queue)) = test_support::device() else {
return;
};
let turn = Quat::from_rotation_y(0.7);
let world_from_camera = Mat4::from_rotation_translation(turn, Vec3::new(12., 1.5, -40.));
let volume = |center: Vec3, rotation: Quat, size: Vec3, density: f32, albedo: [f32; 3]| {
crate::FogVolume {
center: world_from_camera.transform_point3(center),
rotation: turn * rotation,
size,
density,
albedo,
edge_fade: 0.,
}
};
let volumes = [
volume(
Vec3::new(0., 0., 6.),
Quat::IDENTITY,
Vec3::splat(3.),
0.5,
[1., 0., 0.],
),
volume(
Vec3::new(-30., 0., -8.),
Quat::IDENTITY,
Vec3::splat(2.),
0.5,
[0., 1., 0.],
),
volume(
Vec3::new(0., 0., -30.),
Quat::IDENTITY,
Vec3::splat(4.),
0.5,
[0., 0., 1.],
),
volume(
Vec3::new(1.5, -1., 0.),
Quat::IDENTITY,
Vec3::new(1., 1., 12.),
0.3,
[0.2, 0.9, 0.5],
),
volume(
Vec3::new(0., 0., -4.),
Quat::from_rotation_y(0.1),
Vec3::new(6., 4., 20.),
0.05,
[0.5, 0.5, 1.],
),
volume(
Vec3::new(-7.5, 0.5, -8.),
Quat::from_rotation_y(0.4),
Vec3::new(3., 2., 3.),
0.2,
[0.9, 0.3, 0.6],
),
volume(
Vec3::new(1., 1., -19.5),
Quat::IDENTITY,
Vec3::new(2., 2., 3.),
0.15,
[0.4, 0.8, 0.2],
),
volume(
Vec3::new(0.5, 0., -9.),
Quat::from_rotation_y(0.6) * Quat::from_rotation_x(0.3),
Vec3::new(4., 3., 5.),
0.2,
[1., 0.5, 0.25],
),
volume(
Vec3::new(1.8, 0.6, -10.5),
Quat::IDENTITY,
Vec3::splat(3.),
0.1,
[0.2, 0.9, 0.6],
),
];
let mut scene = Scene::new(&device, &queue);
scene.update_fog_volumes(&device, &queue, &volumes).unwrap();
let fog = Fog {
density: 0.01,
albedo: [1., 0.7, 0.4],
anisotropy: 0.,
ambient: 0.,
length: 20.,
..Fog::default()
};
let mut frame = input(fog);
let mut projection = projection();
projection.z_axis.x = 0.1;
projection.z_axis.y = -0.05;
frame.camera = Camera {
view: world_from_camera.inverse(),
projection,
eye: world_from_camera.w_axis.truncate(),
};
frame.directional_lights[0] = Some(DirectionalLight {
direction: Vec3::new(0.3, -1., -0.4),
color: [1.; 3],
illuminance: 4. * std::f32::consts::PI,
shadow: None,
..Default::default()
});
let renderer = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let size = froxels(QUALITY, SIZE, device.limits().max_texture_dimension_3d);
let froxels = texels(&read(&device, &queue, renderer.fog_volumes()[0]));
let local_from_world = volumes
.map(|volume| Mat4::from_rotation_translation(volume.rotation, volume.center).inverse());
let world_from_view = frame.camera.view.inverse();
let mut reached = [0; 9];
for z in 0..size[2] {
for y in 0..size[1] {
for x in 0..size[0] {
let point =
world_from_view.transform_point3(froxel_center(&frame, size, [x, y, z]));
let mut density = fog.density;
let mut scattering = Vec3::from(fog.albedo) * fog.density;
for (index, volume) in volumes.iter().enumerate() {
let local = local_from_world[index].transform_point3(point);
let added = volume.density * box_density(local, volume.size * 0.5);
density += added;
scattering += Vec3::from(volume.albedo) * added;
reached[index] += usize::from(added > 0.);
}
let froxel = froxels[((z * size[1] + y) * size[0] + x) as usize];
assert!(
(froxel[3] - density).abs() <= 1e-3 * density + 1e-4,
"{point}: extinction {} against the boxes' {density}",
froxel[3]
);
for channel in 0..3 {
assert!(
(froxel[channel] - scattering[channel]).abs()
<= 2e-3 * scattering[channel] + 1e-4,
"{point} channel {channel}: scattering {} against the boxes' {}",
froxel[channel],
scattering[channel]
);
}
}
}
}
assert!(
reached[3..].iter().all(|&count| count > 50),
"froxels inside each box: {reached:?}"
);
}
fn box_density(local: Vec3, half_size: Vec3) -> f32 {
let q = local.abs() - half_size;
let distance = q.max(Vec3::ZERO).length() + q.max_element().min(0.);
let t = ((distance + 0.1) / 0.1).clamp(0., 1.);
1. - t * t * (3. - 2. * t)
}
#[test]
fn a_blended_surface_is_fogged_at_its_depth() {
let Some((device, queue)) = test_support::device() else {
return;
};
let depth = 30.;
let mut quad = test_support::cube();
quad.meshes[0] = crate::asset::CpuMesh {
vertices: [(-1., -1.), (1., -1.), (1., 1.), (-1., 1.)]
.map(|(x, y)| crate::asset::Vertex {
tangent: [0.; 4],
lightmap_bounds: [0., 0., 1., 1.],
lightmap_uv: [0.; 2],
position: [x * 4., y * 4., -depth],
normal: [0., 0., 1.],
uv: [(x + 1.) / 2., (1. - y) / 2.],
color: [1.; 4],
})
.to_vec(),
indices: vec![0, 1, 2, 0, 2, 3],
material: 0,
deformation: Default::default(),
};
quad.materials[0].unlit = true;
quad.materials[0].base = [1., 0.6, 0.3, 1.];
quad.materials[0].alpha = crate::AlphaMode::Blend {
receives_screen_space_reflections: false,
keeps_specular: false,
};
let mut scene = Scene::new(&device, &queue);
test_support::add_static(&device, &queue, &mut scene, quad);
let fog = Fog {
density: 0.02,
length: 60.,
..Fog::default()
};
let frame = input(fog);
let centre = |atmosphere: bool| {
let renderer = render(
&device,
&queue,
&mut scene,
&frame,
&settings(atmosphere),
1,
);
let composite = texels(&read(&device, &queue, &renderer.targets().composite));
composite[(SIZE[1] / 2 * SIZE[0] + SIZE[0] / 2) as usize]
};
let [clear, fogged] = [false, true].map(centre);
let (ndc, _) = froxel_ray(&frame, [SIZE[0], SIZE[1], 1], [SIZE[0] / 2, SIZE[1] / 2], 0);
let transmittance = (-fog.density * depth * view_ray(&frame, ndc).length()).exp();
for channel in 0..3 {
let share = fogged[channel] / clear[channel];
assert!(
(share - transmittance).abs() < 5e-3,
"channel {channel}: {} of the quad's colour against Beer-Lambert's {transmittance}",
share
);
}
}
#[test]
fn a_blended_surface_covers_its_fog_by_its_alpha() {
let Some((device, queue)) = test_support::device() else {
return;
};
let depth = 30.;
let mut quad = test_support::cube();
quad.meshes[0] = crate::asset::CpuMesh {
vertices: [(-1., -1.), (1., -1.), (1., 1.), (-1., 1.)]
.map(|(x, y)| crate::asset::Vertex {
tangent: [0.; 4],
lightmap_bounds: [0., 0., 1., 1.],
lightmap_uv: [0.; 2],
position: [x * 4., y * 4., -depth],
normal: [0., 0., 1.],
uv: [(x + 1.) / 2., (1. - y) / 2.],
color: [1.; 4],
})
.to_vec(),
indices: vec![0, 1, 2, 0, 2, 3],
material: 0,
deformation: Default::default(),
};
quad.materials[0].unlit = true;
quad.materials[0].base = [1., 0.6, 0.3, 1.];
quad.materials[0].alpha = crate::AlphaMode::Blend {
receives_screen_space_reflections: false,
keeps_specular: false,
};
let mut scene = Scene::new(&device, &queue);
let (ids, instance) = test_support::add_static(&device, &queue, &mut scene, quad);
let fog = Fog {
density: 0.02,
length: 60.,
ambient: 1.,
..Fog::default()
};
let mut frame = input(fog);
frame.hemisphere_light = HemisphereLight {
sky_color: [0.4, 0.5, 0.7],
ground_color: [0.4, 0.5, 0.7],
intensity: 1.,
};
let mut centre = |alpha: Option<f32>| {
let mut values = scene.material(ids.materials[0]).unwrap();
values.base[3] = alpha.unwrap_or(1.);
scene
.set_material(&queue, ids.materials[0], values)
.unwrap();
let mut state = *scene.instance(instance).unwrap();
state.visible = alpha.is_some();
scene.set_instance(&queue, instance, state).unwrap();
let renderer = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let composite = texels(&read(&device, &queue, &renderer.targets().composite));
composite[(SIZE[1] / 2 * SIZE[0] + SIZE[0] / 2) as usize]
};
let [whole, half, behind] = [Some(1.), Some(0.5), None].map(&mut centre);
let (ndc, _) = froxel_ray(&frame, [SIZE[0], SIZE[1], 1], [SIZE[0] / 2, SIZE[1] / 2], 0);
let transmittance = (-fog.density * depth * view_ray(&frame, ndc).length()).exp();
for channel in 0..3 {
let in_scatter = whole[channel] - [1., 0.6, 0.3][channel] * transmittance;
assert!(
in_scatter > 0.02 && behind[channel] > 0.02,
"channel {channel}: too little in-scatter ({in_scatter}) or fogged sky ({}) to tell \
a share of it",
behind[channel]
);
let expected = 0.5 * whole[channel] + 0.5 * behind[channel];
assert!(
(half[channel] - expected).abs() <= 5e-3 * expected + 1e-3,
"channel {channel}: {} at alpha 0.5, against Porter and Duff's over {expected} \
of {} at alpha 1 and {} behind",
half[channel],
whole[channel],
behind[channel]
);
}
}
#[test]
fn glow_adds_its_light_through_the_fog_and_none_of_its_in_scatter() {
let Some((device, queue)) = test_support::device() else {
return;
};
let depth = 30.;
let fog = Fog {
density: 0.02,
length: 60.,
ambient: 1.,
..Fog::default()
};
let mut frame = input(fog);
frame.hemisphere_light = HemisphereLight {
sky_color: [0.4, 0.5, 0.7],
ground_color: [0.4, 0.5, 0.7],
intensity: 1.,
};
let mut scene = Scene::new(&device, &queue);
let mut centre = |color: Option<[f32; 3]>| {
let vertices = match color {
Some([r, g, b]) => [
[-200., -200., -depth],
[600., -200., -depth],
[-200., 600., -depth],
]
.map(|position| crate::effects::Glow {
position,
color: [r, g, b, 1.],
kind: crate::effects::GlowKind::Uniform,
soft_distance: 0.,
})
.to_vec(),
None => Vec::new(),
};
scene.update_effects(&device, &queue, &vertices).unwrap();
let renderer = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let composite = texels(&read(&device, &queue, &renderer.targets().composite));
composite[(SIZE[1] / 2 * SIZE[0] + SIZE[0] / 2) as usize]
};
let behind = centre(None);
let (ndc, _) = froxel_ray(&frame, [SIZE[0], SIZE[1], 1], [SIZE[0] / 2, SIZE[1] / 2], 0);
let transmittance = (-fog.density * depth * view_ray(&frame, ndc).length()).exp();
for color in [[0.; 3], [1., 0.6, 0.3]] {
let glowing = centre(Some(color));
for channel in 0..3 {
assert!(
behind[channel] > 0.02,
"channel {channel}: too little fog ({}) to tell its in-scatter",
behind[channel]
);
let added = glowing[channel] - behind[channel];
let expected = color[channel] * transmittance;
assert!(
(added - expected).abs() <= 5e-3 * expected + 1e-3,
"glow {color:?} channel {channel}: added {added} over {} behind, against its \
light through Beer-Lambert's {transmittance}, {expected}",
behind[channel]
);
}
}
}
#[test]
fn the_sky_takes_its_sky_affect_of_the_fog() {
let Some((device, queue)) = test_support::device() else {
return;
};
let mut scene = Scene::new(&device, &queue);
add_box(
&device,
&queue,
&mut scene,
Vec3::new(0., -1., -6.),
Vec3::new(4., 1., 3.),
);
let mut frame = input(Fog {
density: 0.05,
length: 30.,
ambient: 1.,
..Fog::default()
});
frame.hemisphere_light = HemisphereLight {
sky_color: [0.4, 0.5, 0.7],
ground_color: [0.1, 0.1, 0.1],
intensity: 1.,
};
frame.backdrop = Backdrop::Color([0.2, 0.3, 0.45]);
let mut composite = |frame: &FrameInput, atmosphere: bool| {
let renderer = render(&device, &queue, &mut scene, frame, &settings(atmosphere), 1);
texels(&read(&device, &queue, &renderer.targets().composite))
};
let clear = composite(&frame, false);
let whole = composite(&frame, true);
frame.fog.sky_affect = 0.;
let none = composite(&frame, true);
frame.fog.sky_affect = 0.5;
let half = composite(&frame, true);
let sky_colour = clear[0];
let sky: Vec<_> = (0..clear.len())
.filter(|&texel| clear[texel] == sky_colour)
.collect();
assert!(
sky.len() < clear.len(),
"the frame holds no surface: {sky_colour:?}"
);
assert!(whole[0] != clear[0], "the whole fog left the sky clear");
for texel in 0..clear.len() {
if sky.contains(&texel) {
assert_eq!(
none[texel], clear[texel],
"texel {texel}: no sky affect fogged the sky"
);
for channel in 0..3 {
let midway = (clear[texel][channel] + whole[texel][channel]) / 2.;
assert!(
(half[texel][channel] - midway).abs() < 2e-3,
"texel {texel} channel {channel}: half the sky affect gave {} against {midway}",
half[texel][channel]
);
}
} else {
assert_eq!(
none[texel], whole[texel],
"texel {texel}: the sky affect fogged a surface"
);
}
}
}
#[test]
fn shadow_opacity_blends_a_lights_shadow_on_surfaces_and_in_the_medium() {
let Some((device, queue)) = test_support::device() else {
return;
};
let fog = Fog {
density: 0.05,
anisotropy: 0.3,
length: 20.,
..Fog::default()
};
for (label, local) in [("scene light", true), ("directional light", false)] {
let observe = |opacity: Option<f32>| {
let mut scene = Scene::new(&device, &queue);
add_box(
&device,
&queue,
&mut scene,
Vec3::new(0., -2., -10.),
Vec3::new(20., 1., 20.),
);
add_box(
&device,
&queue,
&mut scene,
Vec3::new(0., 1., -8.),
Vec3::new(3., 0.2, 3.),
);
let mut frame = input(fog);
if local {
scene
.add_light(
&device,
&queue,
Light {
position: Vec3::new(0., 3., -8.),
shape: LightShape::Spot {
direction: Vec3::NEG_Y,
inner_angle: 0.6,
outer_angle: 0.9,
radius: LightShape::DEFAULT_RADIUS,
},
intensity: 60.,
range: 12.,
casts_shadow: opacity.is_some(),
shadow_opacity: opacity.unwrap_or(1.),
..Light::default()
},
)
.unwrap();
} else {
frame.directional_lights[0] = Some(DirectionalLight {
direction: Vec3::new(0.2, -1., 0.1),
illuminance: 3.,
shadow: opacity.map(|_| DirectionalShadow {
distance: 30.,
cascades: 2,
}),
shadow_opacity: opacity.unwrap_or(1.),
..DirectionalLight::default()
});
}
let fogged = render(&device, &queue, &mut scene, &frame, &settings(true), 1);
let medium: Vec<f32> = texels(&read(&device, &queue, fogged.fog_volumes()[0]))
.into_iter()
.flat_map(|froxel| [froxel[0], froxel[1], froxel[2]])
.collect();
let unfogged = render(&device, &queue, &mut scene, &frame, &settings(false), 1);
let surfaces: Vec<f32> = texels(&read(&device, &queue, &unfogged.targets().composite))
.into_iter()
.flat_map(|texel| [texel[0], texel[1], texel[2]])
.collect();
[medium, surfaces]
};
let unshadowed = observe(None);
let shadowed = observe(Some(1.));
let half = observe(Some(0.5));
let clear = observe(Some(0.));
for (part, receiver) in ["medium", "surfaces"].into_iter().enumerate() {
let (unshadowed, shadowed, half) = (&unshadowed[part], &shadowed[part], &half[part]);
let darkened = unshadowed
.iter()
.zip(shadowed)
.filter(|(lit, dark)| *lit - *dark > 1e-2 * *lit + 1e-4)
.count();
assert!(
darkened > 100,
"{label}: the slab shadowed {darkened} values of the {receiver}"
);
for (index, ((lit, dark), blended)) in
unshadowed.iter().zip(shadowed).zip(half).enumerate()
{
let expected = (lit + dark) / 2.;
assert!(
(blended - expected).abs() <= 2e-3 * lit.abs() + 1e-4,
"{label}: {receiver} value {index} is {blended} at shadow opacity 0.5, halfway from {dark} to {lit} is {expected}"
);
}
assert!(
clear[part] == *unshadowed,
"{label}: shadow opacity 0 drew a shadow on the {receiver}"
);
}
}
}
#[test]
fn a_submitted_filtered_frame_is_not_reprojected_as_previous_on_retry() {
let Some((device, queue)) = test_support::device() else {
return;
};
let settings = Settings {
fog_filter: true,
..settings(true)
};
let mut scene = Scene::new(&device, &queue);
let mut frame = input(Fog {
density: 0.05,
length: 10.,
albedo: [0.; 3],
ambient: 1.,
..Default::default()
});
frame.hemisphere_light = HemisphereLight {
sky_color: [1.; 3],
ground_color: [1.; 3],
intensity: 1.,
};
let mut renderer = Renderer::for_test(&device, &queue, SIZE, &settings);
let output = crate::view::targets::target(&device, "fog retry", SIZE, gbuffer::COLOR);
for step in 0..3 {
frame.fog.albedo = if step == 1 { [1.; 3] } else { [0.; 3] };
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
&device,
&queue,
&mut encoder,
&mut scene,
&frame,
&settings,
&output,
None,
);
queue.submit([encoder.finish()]);
if step != 1 {
renderer.finish_frame(&mut scene);
}
let froxels = texels(&read(&device, &queue, renderer.fog_volumes()[1]));
let light = froxels
.iter()
.flat_map(|texel| &texel[..3])
.copied()
.fold(0f32, f32::max);
if step == 1 {
assert!(
light > 0.,
"the submitted volume must hold light to expose stale reprojection"
);
} else {
assert_eq!(
light, 0.,
"step {step}: black albedo cannot scatter prior illumination"
);
}
}
}