use super::*;
use crate::{CameraAttribs, post_fx_context::FrameDesc};
pub(super) const SIZE: [u32; 2] = [64, 48];
pub(super) fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
let required = std::env::var("SGL_REQUIRE_GPU").is_ok_and(|v| !v.is_empty() && v != "0");
match pollster::block_on(wgpu::Instance::default().request_adapter(&Default::default())) {
Ok(adapter) => {
Some(pollster::block_on(adapter.request_device(&Default::default())).unwrap())
}
Err(error) => {
assert!(
!required,
"SGL_REQUIRE_GPU is set but no adapter exists: {error}"
);
None
}
}
}
pub(super) fn texture(
device: &wgpu::Device,
queue: &wgpu::Queue,
format: wgpu::TextureFormat,
texel: &[u8],
) -> wgpu::TextureView {
let data: Vec<u8> = texel
.iter()
.copied()
.cycle()
.take(texel.len() * (SIZE[0] * SIZE[1]) as usize)
.collect();
texels(device, queue, format, &data)
}
pub(super) fn texels(
device: &wgpu::Device,
queue: &wgpu::Queue,
format: wgpu::TextureFormat,
data: &[u8],
) -> wgpu::TextureView {
use wgpu::util::DeviceExt;
device
.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width: SIZE[0],
height: SIZE[1],
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
data,
)
.create_view(&Default::default())
}
pub(super) fn depth(
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
depth: f32,
) -> wgpu::TextureView {
let view = device
.create_texture(&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width: SIZE[0],
height: SIZE[1],
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Depth32Float,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
})
.create_view(&Default::default());
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(depth),
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
..Default::default()
});
view
}
pub(super) fn half(values: &[f32]) -> Vec<u8> {
values
.iter()
.flat_map(|v| {
let bits = v.to_bits();
let sign = ((bits >> 16) & 0x8000) as u16;
let exponent = ((bits >> 23) & 0xff) as i32 - 127 + 15;
let mantissa = ((bits >> 13) & 0x3ff) as u16;
let h = if *v == 0.0 {
sign
} else {
sign | ((exponent as u16) << 10) | mantissa
};
h.to_le_bytes()
})
.collect()
}
fn camera(reversed: bool, frame_index: u32) -> CameraAttribs {
camera_with_near(reversed, frame_index, 0.1)
}
fn camera_with_near(reversed: bool, frame_index: u32, near: f32) -> CameraAttribs {
let far = 100.0f32;
let aspect = SIZE[0] as f32 / SIZE[1] as f32;
let y = 1.0 / (0.5f32).tan();
let (m22, m32) = if reversed {
(near / (near - far), -far * near / (near - far))
} else {
(far / (far - near), -far * near / (far - near))
};
let proj = [
y / aspect,
0.,
0.,
0.,
0.,
y,
0.,
0.,
0.,
0.,
m22,
1.,
0.,
0.,
m32,
0.,
];
let identity = [
1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,
];
let inverse = |m: [f32; 16]| {
let mut inv = [0.0f32; 16];
inv[0] = 1.0 / m[0];
inv[5] = 1.0 / m[5];
inv[11] = 1.0 / m[14];
inv[14] = 1.0;
inv[15] = -m[10] / m[14];
inv
};
let mut attribs = CameraAttribs {
f4_viewport_size: [
SIZE[0] as f32,
SIZE[1] as f32,
1.0 / SIZE[0] as f32,
1.0 / SIZE[1] as f32,
],
ui_frame_index: frame_index,
m_view: identity,
m_proj: proj,
m_view_proj: proj,
m_view_inv: identity,
m_proj_inv: inverse(proj),
m_view_proj_inv: inverse(proj),
..Default::default()
};
if reversed {
attribs.set_clip_planes(far, near);
} else {
attribs.set_clip_planes(near, far);
}
attribs
}
fn multiply(a: [f32; 16], b: [f32; 16]) -> [f32; 16] {
std::array::from_fn(|i| (0..4).map(|k| a[k * 4 + i % 4] * b[i / 4 * 4 + k]).sum())
}
fn rigid(yaw: f32, offset: [f32; 3]) -> [f32; 16] {
let (sin, cos) = yaw.sin_cos();
[
cos, 0., -sin, 0., 0., 1., 0., 0., sin, 0., cos, 0., offset[0], offset[1], offset[2], 1.,
]
}
#[derive(Clone, Copy)]
struct Previous {
eye: [f32; 3],
yaw: f32,
near: f32,
depth: f32,
motion: f32,
}
fn moved(camera: CameraAttribs, previous: Previous) -> CameraAttribs {
let world_from_view = rigid(previous.yaw, previous.eye);
let view_from_world = multiply(
rigid(-previous.yaw, [0.; 3]),
rigid(0., previous.eye.map(|c| -c)),
);
CameraAttribs {
f4_position: [previous.eye[0], previous.eye[1], previous.eye[2], 1.],
m_view: view_from_world,
m_view_inv: world_from_view,
m_view_proj: multiply(camera.m_proj, view_from_world),
m_view_proj_inv: multiply(world_from_view, camera.m_proj_inv),
..camera
}
}
pub(super) fn read_rgba16f(
device: &wgpu::Device,
queue: &wgpu::Queue,
view: &wgpu::TextureView,
) -> Vec<[f32; 4]> {
let texture = view.texture();
let stride = (texture.width() * 8).next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT);
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: u64::from(stride * texture.height()),
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&Default::default());
encoder.copy_texture_to_buffer(
texture.as_image_copy(),
wgpu::TexelCopyBufferInfo {
buffer: &buffer,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(stride),
rows_per_image: None,
},
},
texture.size(),
);
queue.submit([encoder.finish()]);
buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let bytes = buffer.get_mapped_range(..).unwrap();
let half = |h: u16| {
let sign = if h & 0x8000 != 0 { -1.0 } else { 1.0 };
let exponent = i32::from((h >> 10) & 0x1f);
let mantissa = f32::from(h & 0x3ff);
if exponent == 0 {
sign * mantissa * 2f32.powi(-24)
} else if exponent == 31 {
if mantissa == 0.0 {
sign * f32::INFINITY
} else {
f32::NAN
}
} else {
sign * (1.0 + mantissa / 1024.0) * 2f32.powi(exponent - 15)
}
};
(0..texture.height())
.flat_map(|y| (0..texture.width()).map(move |x| (y * stride + x * 8) as usize))
.map(|at| {
std::array::from_fn(|c| {
half(u16::from_le_bytes([
bytes[at + 2 * c],
bytes[at + 2 * c + 1],
]))
})
})
.collect()
}
pub(super) fn depth_values(
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
values: &[f32],
) -> wgpu::TextureView {
let bytes: Vec<u8> = values.iter().flat_map(|v| v.to_le_bytes()).collect();
let source = texels(device, queue, wgpu::TextureFormat::R32Float, &bytes);
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: None,
source: wgpu::ShaderSource::Wgsl(
"@group(0) @binding(0) var values: texture_2d<f32>;
@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
return vec4<f32>(p * 4.0 - 1.0, 0.0, 1.0);
}
@fragment fn fs(@builtin(position) p: vec4<f32>) -> @builtin(frag_depth) f32 {
return textureLoad(values, vec2<i32>(p.xy), 0).x;
}"
.into(),
),
});
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: false },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
}],
});
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: None,
layout: Some(
&device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
}),
),
vertex: wgpu::VertexState {
module: &module,
entry_point: Some("vs"),
compilation_options: Default::default(),
buffers: &[],
},
primitive: Default::default(),
depth_stencil: Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(true),
depth_compare: Some(wgpu::CompareFunction::Always),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some("fs"),
compilation_options: Default::default(),
targets: &[],
}),
multiview_mask: None,
cache: None,
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: None,
layout: &layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&source),
}],
});
let view = depth(device, encoder, 1.0);
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &view,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
..Default::default()
});
pass.set_pipeline(&pipeline);
pass.set_bind_group(0, &group, &[]);
pass.draw(0..3, 0..1);
drop(pass);
view
}
#[test]
fn departed_reflections_cannot_support_current_dark_history() {
let Some((device, queue)) = device() else {
return;
};
let normal = texture(
&device,
&queue,
wgpu::TextureFormat::Rgba16Float,
&half(&[0.0, 0.0, -1.0, 0.0]),
);
let motion = texture(
&device,
&queue,
wgpu::TextureFormat::Rg16Float,
&half(&[2.0 / 64.0, 0.0]),
);
let mut failures = Vec::new();
for background in [false, true] {
for flags in [FeatureFlags::NONE, FeatureFlags::HALF_RESOLUTION] {
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(&device, &queue, Default::default());
let mut previous_depth = {
let mut encoder = device.create_command_encoder(&Default::default());
let result = depth(&device, &mut encoder, 0.95);
queue.submit([encoder.finish()]);
result
};
for index in 0..7 {
let boundary = if index == 6 { 24 } else { 32 };
let departed = matches!(index, 0 | 4 | 6);
let bright = matches!(index, 1 | 2 | 5);
let supported_history = index == 3;
let mut encoder = device.create_command_encoder(&Default::default());
let scene_depth = depth_values(
&device,
&queue,
&mut encoder,
&(0..48)
.flat_map(|_| {
(0..64).map(|x| {
if background && departed && x >= boundary {
1.0
} else {
0.95
}
})
})
.collect::<Vec<_>>(),
);
let material = texels(
&device,
&queue,
wgpu::TextureFormat::R8Unorm,
&(0..48)
.flat_map(|_| {
(0..64).map(|x| {
if !background && departed && x >= boundary {
230
} else {
0
}
})
})
.collect::<Vec<_>>(),
);
context.prepare_resources(
&device,
&FrameDesc {
index,
width: 64,
height: 48,
output_width: 64,
output_height: 48,
},
post_fx_context::FeatureFlags::NONE,
);
ssr.prepare_resources(&device, &mut encoder, &mut context, flags);
ssr.prepare_shaders_and_pso(&device);
let current_camera = camera(false, index);
let previous_camera = camera(false, index.saturating_sub(1));
context.execute(&mut post_fx_context::RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
curr_depth_buffer_srv: &scene_depth,
prev_depth_buffer_srv: &previous_depth,
curr_camera: Some(¤t_camera),
prev_camera: Some(&previous_camera),
camera_attribs_cb: None,
pass_timestamps: None,
});
let ray_width = if flags == FeatureFlags::NONE { 64 } else { 32 };
let ray_height = if flags == FeatureFlags::NONE { 48 } else { 24 };
let input = (0..ray_height)
.flat_map(|_| {
(0..ray_width).flat_map(|x| {
let value =
if bright || (supported_history && x != (31 * ray_width / 64)) {
1.0
} else {
0.0
};
half(&[value, value, value, 1.0])
})
})
.collect::<Vec<_>>();
use wgpu::util::DeviceExt;
ssr.resources.as_mut().unwrap().radiance = device
.create_texture_with_data(
&queue,
&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width: ray_width,
height: ray_height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba16Float,
usage: wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&input,
)
.create_view(&Default::default());
let attribs = ScreenSpaceReflectionAttribs {
temporal_radiance_stability_factor: 0.95,
..Default::default()
};
let mut render = RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
post_fx_context: &mut context,
color_buffer_srv: &normal,
depth_buffer_srv: &scene_depth,
normal_buffer_srv: &normal,
material_buffer_srv: &material,
motion_vectors_srv: &motion,
ssr_attribs: &attribs,
pass_timestamps: None,
reset_accumulation: false,
frame_time: 1.0 / 60.0,
};
ssr.update_constant_buffer(&render, false);
ssr.compute_stencil_mask_and_extract_roughness(&mut render);
ssr.compute_downsampled_stencil_mask(&mut render);
ssr.classify_denoiser_tiles(&mut render);
ssr.compute_spatial_reconstruction(&mut render);
ssr.compute_temporal_accumulation(&mut render);
queue.submit([encoder.finish()]);
let resolved = read_rgba16f(&device, &queue, &ssr.resources().resolved_radiance);
let temporal = read_rgba16f(
&device,
&queue,
&ssr.resources().radiance_history[(index & 1) as usize],
);
let edge = (24 * 64 + boundary - 1) as usize;
println!(
"background={background} {flags:?} frame={index}: active resolved={} inactive neighbor={} temporal edge={}",
resolved[edge][0],
resolved[edge + 1][0],
temporal[edge][0]
);
if departed && temporal[edge][0].abs() > 0.001 {
failures.push(format!(
"{background} {flags:?} frame{index}: dark edge retains {}",
temporal[edge][0]
));
}
let history_pixel = if flags == FeatureFlags::HALF_RESOLUTION {
24 * 64 + 30
} else {
edge
};
if supported_history
&& temporal[history_pixel][0] <= resolved[history_pixel][0] + 0.01
{
failures.push(format!(
"valid moving history lost: resolved={} temporal={}",
resolved[history_pixel][0], temporal[history_pixel][0]
));
}
previous_depth = scene_depth;
}
}
}
assert!(failures.is_empty(), "{}", failures.join("\n"));
}
fn read_scalar(device: &wgpu::Device, queue: &wgpu::Queue, view: &wgpu::TextureView) -> Vec<f32> {
let texture = view.texture();
let texel_bytes = if texture.format() == wgpu::TextureFormat::R32Float {
4
} else {
2
};
let stride = (SIZE[0] * texel_bytes).next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT);
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: u64::from(stride * SIZE[1]),
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut encoder = device.create_command_encoder(&Default::default());
encoder.copy_texture_to_buffer(
texture.as_image_copy(),
wgpu::TexelCopyBufferInfo {
buffer: &buffer,
layout: wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(stride),
rows_per_image: None,
},
},
texture.size(),
);
queue.submit([encoder.finish()]);
buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let bytes = buffer.get_mapped_range(..).unwrap();
(0..SIZE[1])
.flat_map(|y| (0..SIZE[0]).map(move |x| (y * stride + x * texel_bytes) as usize))
.map(|at| {
if texel_bytes == 4 {
return f32::from_le_bytes(bytes[at..at + 4].try_into().unwrap());
}
let h = u16::from_le_bytes([bytes[at], bytes[at + 1]]);
let exponent = i32::from((h >> 10) & 0x1f);
let mantissa = f32::from(h & 0x3ff);
if exponent == 0 {
mantissa * 2f32.powi(-24)
} else {
(1.0 + mantissa / 1024.0) * 2f32.powi(exponent - 15)
}
})
.collect()
}
#[test]
fn resolved_depth_is_the_virtual_point_along_the_view_ray() {
let Some((device, queue)) = device() else {
return;
};
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(&device, &queue, Default::default());
for flags in [FeatureFlags::NONE, FeatureFlags::HALF_RESOLUTION] {
for (index, reversed) in [false, true, false].into_iter().enumerate() {
let (plane_z, hit_distance) = (50.0f32, 4.0f32);
let camera = camera(reversed, index as u32);
let proj = camera.m_proj;
let project = |v: [f32; 3]| -> f32 {
let clip = |row: usize| {
proj[row] * v[0] + proj[4 + row] * v[1] + proj[8 + row] * v[2] + proj[12 + row]
};
clip(2) / clip(3)
};
let pixel = [62u32, 46u32];
let ndc = [
2.0 * (pixel[0] as f32 + 0.5) / SIZE[0] as f32 - 1.0,
1.0 - 2.0 * (pixel[1] as f32 + 0.5) / SIZE[1] as f32,
];
let surface = [
ndc[0] * plane_z / proj[0],
ndc[1] * plane_z / proj[5],
plane_z,
];
let distance = surface.iter().map(|c| c * c).sum::<f32>().sqrt();
let virtual_point = surface.map(|c| c + hit_distance * c / distance);
let expected_z = virtual_point[2];
let mirror = [surface[0], surface[1], -surface[2]].map(|c| c / distance);
let normal = texture(
&device,
&queue,
wgpu::TextureFormat::Rgba16Float,
&half(&[0.0, 0.0, -1.0, 0.0]),
);
let motion = texture(
&device,
&queue,
wgpu::TextureFormat::Rg16Float,
&half(&[0.0, 0.0]),
);
let material = texture(&device, &queue, wgpu::TextureFormat::R8Unorm, &[26]);
let mut encoder = device.create_command_encoder(&Default::default());
let scene_depth = depth(&device, &mut encoder, project(surface));
context.prepare_resources(
&device,
&FrameDesc {
index: index as u32,
width: SIZE[0],
height: SIZE[1],
output_width: SIZE[0],
output_height: SIZE[1],
},
if reversed {
post_fx_context::FeatureFlags::REVERSED_DEPTH
} else {
post_fx_context::FeatureFlags::NONE
},
);
ssr.prepare_resources(&device, &mut encoder, &mut context, flags);
ssr.prepare_shaders_and_pso(&device);
context.execute(&mut post_fx_context::RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
curr_depth_buffer_srv: &scene_depth,
prev_depth_buffer_srv: &scene_depth,
curr_camera: Some(&camera),
prev_camera: Some(&camera),
camera_attribs_cb: None,
pass_timestamps: None,
});
ssr.resources.as_mut().unwrap().ray_direction_pdf = texture(
&device,
&queue,
wgpu::TextureFormat::Rgba16Float,
&half(&[
mirror[0] * hit_distance,
mirror[1] * hit_distance,
mirror[2] * hit_distance,
1.0,
]),
);
ssr.resources.as_mut().unwrap().radiance = texture(
&device,
&queue,
wgpu::TextureFormat::Rgba16Float,
&half(&[1.0, 1.0, 1.0, 1.0]),
);
let attribs = ScreenSpaceReflectionAttribs::default();
let mut render = RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
post_fx_context: &mut context,
color_buffer_srv: &normal,
depth_buffer_srv: &scene_depth,
normal_buffer_srv: &normal,
material_buffer_srv: &material,
motion_vectors_srv: &motion,
ssr_attribs: &attribs,
pass_timestamps: None,
reset_accumulation: false,
frame_time: 1.0 / 60.0,
};
ssr.update_constant_buffer(&render, false);
ssr.compute_stencil_mask_and_extract_roughness(&mut render);
ssr.compute_downsampled_stencil_mask(&mut render);
ssr.classify_denoiser_tiles(&mut render);
ssr.compute_spatial_reconstruction(&mut render);
ssr.compute_temporal_accumulation(&mut render);
queue.submit([encoder.finish()]);
let resolved = read_scalar(&device, &queue, &ssr.resources().resolved_depth)
[(pixel[1] * SIZE[0] + pixel[0]) as usize];
let resolved_z = f64::from(proj[14]) / (f64::from(resolved) - f64::from(proj[10]));
assert!(
(resolved_z - f64::from(expected_z)).abs() <= 0.1,
"{flags:?}, reversed={reversed}: resolved {resolved_z} m, virtual point {expected_z} m"
);
}
}
}
#[test]
fn missed_rays_do_not_move_the_reflections_virtual_point() {
use wgpu::util::DeviceExt;
let Some((device, queue)) = device() else {
return;
};
let camera = camera(true, 0);
let project = |point: [f32; 3]| {
let clip = |row: usize| {
camera.m_proj[row] * point[0]
+ camera.m_proj[4 + row] * point[1]
+ camera.m_proj[8 + row] * point[2]
+ camera.m_proj[12 + row]
};
clip(2) / clip(3)
};
let normal = texture(
&device,
&queue,
wgpu::TextureFormat::Rgba16Float,
&half(&[0., 0., -1., 0.]),
);
let material = texture(&device, &queue, wgpu::TextureFormat::R8Unorm, &[50]);
let motion = texture(
&device,
&queue,
wgpu::TextureFormat::Rg16Float,
&half(&[0., 0.]),
);
let reconstruct = |flags: FeatureFlags, confidence: f32, miss_distance: f32| {
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(&device, &queue, Default::default());
let mut encoder = device.create_command_encoder(&Default::default());
let scene_depth = depth(&device, &mut encoder, project([0., 0., 2.]));
context.prepare_resources(
&device,
&FrameDesc {
index: 0,
width: SIZE[0],
height: SIZE[1],
output_width: SIZE[0],
output_height: SIZE[1],
},
post_fx_context::FeatureFlags::REVERSED_DEPTH,
);
ssr.prepare_resources(&device, &mut encoder, &mut context, flags);
ssr.prepare_shaders_and_pso(&device);
context.execute(&mut post_fx_context::RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
curr_depth_buffer_srv: &scene_depth,
prev_depth_buffer_srv: &scene_depth,
curr_camera: Some(&camera),
prev_camera: Some(&camera),
camera_attribs_cb: None,
pass_timestamps: None,
});
let [width, height] = if flags.contains(FeatureFlags::HALF_RESOLUTION) {
[SIZE[0] / 2, SIZE[1] / 2]
} else {
SIZE
};
let rays = |radiance: bool| {
let data: Vec<u8> = (0..height)
.flat_map(|_| {
(0..width).flat_map(|x| {
let hit = x % 2 == 0 && confidence > 0.;
let value = if radiance {
if hit { [confidence; 4] } else { [0.; 4] }
} else {
[0., 0., -if hit { 3. } else { miss_distance }, 1.]
};
half(&value)
})
})
.collect();
device
.create_texture_with_data(
&queue,
&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba16Float,
usage: wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&data,
)
.create_view(&Default::default())
};
ssr.resources.as_mut().unwrap().ray_direction_pdf = rays(false);
ssr.resources.as_mut().unwrap().radiance = rays(true);
let attribs = ScreenSpaceReflectionAttribs::default();
let mut render = RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
post_fx_context: &mut context,
color_buffer_srv: &normal,
depth_buffer_srv: &scene_depth,
normal_buffer_srv: &normal,
material_buffer_srv: &material,
motion_vectors_srv: &motion,
ssr_attribs: &attribs,
pass_timestamps: None,
reset_accumulation: false,
frame_time: 1. / 60.,
};
ssr.update_constant_buffer(&render, false);
ssr.compute_stencil_mask_and_extract_roughness(&mut render);
ssr.compute_downsampled_stencil_mask(&mut render);
ssr.resources.as_mut().unwrap().denoiser_tiles =
texture(&device, &queue, wgpu::TextureFormat::R8Unorm, &[255]);
ssr.compute_spatial_reconstruction(&mut render);
queue.submit([encoder.finish()]);
(
read_scalar(&device, &queue, &ssr.resources().resolved_depth),
read_rgba16f(&device, &queue, &ssr.resources().resolved_radiance),
)
};
for flags in [FeatureFlags::NONE, FeatureFlags::HALF_RESOLUTION] {
for confidence in [1., 0.25] {
let (short_depth, short_radiance) = reconstruct(flags, confidence, 8.);
let (far_depth, far_radiance) = reconstruct(flags, confidence, 65504.);
let mut mixed = 0;
for y in 8..SIZE[1] - 8 {
for x in 8..SIZE[0] - 8 {
let at = (y * SIZE[0] + x) as usize;
let alpha = far_radiance[at][3];
if alpha <= 0.001 || alpha >= confidence - 0.001 {
continue;
}
mixed += 1;
let surface = [
(2. * (x as f32 + 0.5) / SIZE[0] as f32 - 1.) * 2. / camera.m_proj[0],
(1. - 2. * (y as f32 + 0.5) / SIZE[1] as f32) * 2. / camera.m_proj[5],
2.,
];
let distance = surface.iter().map(|c| c * c).sum::<f32>().sqrt();
let expected = project(surface.map(|c| c + 3. * c / distance));
for actual in [short_depth[at], far_depth[at]] {
assert!(
(actual - expected).abs() < 0.01 * expected,
"{flags:?}, confidence {confidence}, ({x}, {y}): depth {actual}, hit virtual point {expected}"
);
}
for channel in 0..4 {
assert!(
(short_radiance[at][channel] - far_radiance[at][channel]).abs() < 0.001,
"{flags:?}: changing a miss endpoint changed reflected radiance at ({x}, {y})"
);
}
for color in &far_radiance[at][..3] {
assert!(
(*color - alpha).abs() < 0.001,
"{flags:?}: reflected white light lost premultiplied confidence"
);
}
}
}
assert!(
mixed > 500,
"{flags:?}: only {mixed} mixed hit/miss pixels exercised"
);
}
let (no_hit_depth, no_hit_radiance) = reconstruct(flags, 0., 65504.);
for (depth, radiance) in no_hit_depth.iter().zip(no_hit_radiance) {
assert!(
(*depth - project([0., 0., 2.])).abs() < 0.001,
"{flags:?}: an all-miss kernel must reproject the surface, got {depth}"
);
assert!(
radiance.iter().all(|c| c.abs() < 0.001),
"{flags:?}: a miss supplied radiance"
);
}
}
}
struct Denoised {
output: Vec<[f32; 4]>,
resolved_radiance: Vec<[f32; 4]>,
radiance_history: Vec<[f32; 4]>,
variance_history: Vec<f32>,
}
#[allow(clippy::too_many_arguments)]
fn denoise_frame(
device: &wgpu::Device,
queue: &wgpu::Queue,
ssr: &mut ScreenSpaceReflection,
context: &mut PostFXContext,
flags: FeatureFlags,
filter: [f32; 2],
index: u32,
all_tiles: bool,
previous: Option<Previous>,
hit: impl Fn(u32, u32) -> bool,
) -> Denoised {
denoise_frame_over(
device,
queue,
ssr,
context,
flags,
filter,
index,
all_tiles,
previous,
hit,
|_, _| true,
)
}
#[allow(clippy::too_many_arguments)]
fn denoise_frame_over(
device: &wgpu::Device,
queue: &wgpu::Queue,
ssr: &mut ScreenSpaceReflection,
context: &mut PostFXContext,
flags: FeatureFlags,
filter: [f32; 2],
index: u32,
all_tiles: bool,
previous: Option<Previous>,
hit: impl Fn(u32, u32) -> bool,
glossy: impl Fn(u32, u32) -> bool,
) -> Denoised {
use wgpu::util::DeviceExt;
let mut encoder = device.create_command_encoder(&Default::default());
let scene_depth = depth(device, &mut encoder, 0.95);
let normal = texture(
device,
queue,
wgpu::TextureFormat::Rgba16Float,
&half(&[0.0, 0.0, -1.0, 0.0]),
);
let roughness: Vec<u8> = (0..SIZE[1])
.flat_map(|y| (0..SIZE[0]).map(move |x| (x, y)))
.map(|(x, y)| if glossy(x, y) { 50 } else { 255 })
.collect();
let material = texels(device, queue, wgpu::TextureFormat::R8Unorm, &roughness);
let motion = texture(
device,
queue,
wgpu::TextureFormat::Rg16Float,
&half(&[previous.map_or(0.0, |p| p.motion), 0.0]),
);
context.prepare_resources(
device,
&FrameDesc {
index,
width: SIZE[0],
height: SIZE[1],
output_width: SIZE[0],
output_height: SIZE[1],
},
post_fx_context::FeatureFlags::NONE,
);
ssr.prepare_resources(device, &mut encoder, context, flags);
ssr.prepare_shaders_and_pso(device);
let camera = camera(false, index);
let previous_depth = depth(device, &mut encoder, previous.map_or(0.95, |p| p.depth));
let previous = previous.map_or(camera, |previous| {
moved(camera_with_near(false, index, previous.near), previous)
});
context.execute(&mut post_fx_context::RenderAttributes {
device,
queue,
device_context: &mut encoder,
curr_depth_buffer_srv: &scene_depth,
prev_depth_buffer_srv: &previous_depth,
curr_camera: Some(&camera),
prev_camera: Some(&previous),
camera_attribs_cb: None,
pass_timestamps: None,
});
let [width, height] = if flags.contains(FeatureFlags::HALF_RESOLUTION) {
[SIZE[0] / 2, SIZE[1] / 2]
} else {
SIZE
};
let rays = |texel: &dyn Fn(u32, u32) -> [f32; 4]| {
let data: Vec<u8> = (0..height)
.flat_map(|y| (0..width).flat_map(move |x| half(&texel(x, y))))
.collect();
device
.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
label: None,
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba16Float,
usage: wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&data,
)
.create_view(&Default::default())
};
let resources = ssr.resources.as_mut().unwrap();
resources.ray_direction_pdf = rays(&|_, _| [0.0, 0.0, -1.0, 1.0]);
resources.radiance = rays(&|x, y| {
if hit(x, y) { [1.0; 4] } else { [0.0; 4] }
});
let attribs = ScreenSpaceReflectionAttribs {
temporal_radiance_stability_factor: 0.95,
spatial_reconstruction_radius: filter[0],
bilateral_cleanup_spatial_sigma_factor: filter[1],
..Default::default()
};
let mut render = RenderAttributes {
device,
queue,
device_context: &mut encoder,
post_fx_context: context,
color_buffer_srv: &normal,
depth_buffer_srv: &scene_depth,
normal_buffer_srv: &normal,
material_buffer_srv: &material,
motion_vectors_srv: &motion,
ssr_attribs: &attribs,
pass_timestamps: None,
reset_accumulation: false,
frame_time: 1.0 / 60.0,
};
ssr.update_constant_buffer(&render, false);
ssr.reset_history(&mut render);
ssr.compute_stencil_mask_and_extract_roughness(&mut render);
ssr.compute_downsampled_stencil_mask(&mut render);
if all_tiles {
ssr.resources.as_mut().unwrap().denoiser_tiles =
texture(device, queue, wgpu::TextureFormat::R8Unorm, &[255]);
} else {
ssr.classify_denoiser_tiles(&mut render);
}
ssr.compute_spatial_reconstruction(&mut render);
ssr.compute_temporal_accumulation(&mut render);
ssr.compute_bilateral_cleanup(&mut render);
queue.submit([encoder.finish()]);
let r = ssr.resources();
let current = (index & 1) as usize;
Denoised {
output: read_rgba16f(device, queue, &r.output),
resolved_radiance: read_rgba16f(device, queue, &r.resolved_radiance),
radiance_history: read_rgba16f(device, queue, &r.radiance_history[current]),
variance_history: read_scalar(device, queue, &r.variance_history[current]),
}
}
const DEFAULT_FILTER: [f32; 2] = [4.0, 0.9];
const WIDE_FILTER: [f32; 2] = [8.0, 2.0];
fn hit_columns(flags: FeatureFlags) -> impl Fn(u32, u32) -> bool {
let scale = if flags.contains(FeatureFlags::HALF_RESOLUTION) {
2
} else {
1
};
move |x, _| x == 16 / scale || x == 23 / scale
}
fn checkerboard(x: u32, y: u32) -> bool {
(x + y).is_multiple_of(2)
}
fn far_from_hit_columns() -> impl Iterator<Item = usize> {
(0..(SIZE[0] * SIZE[1]) as usize).filter(|pixel| pixel % SIZE[0] as usize / 8 >= 5)
}
#[test]
fn skipping_tiles_without_hits_changes_no_radiance() {
let Some((device, queue)) = device() else {
return;
};
for flags in [FeatureFlags::NONE, FeatureFlags::HALF_RESOLUTION] {
for filter in [DEFAULT_FILTER, WIDE_FILTER] {
let run = |all_tiles| {
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(
&device,
&queue,
post_fx_context::CreateInfo {
transition_duration: 0.0,
},
);
let columns = hit_columns(flags);
(0..3)
.map(|index| {
denoise_frame(
&device,
&queue,
&mut ssr,
&mut context,
flags,
filter,
index,
all_tiles,
None,
|x, y| {
if index < 2 {
checkerboard(x, y)
} else {
columns(x, y)
}
},
)
})
.last()
.unwrap()
};
let (skipped, reference) = (run(false), run(true));
assert_eq!(
skipped.output, reference.output,
"{flags:?} {filter:?}: skipping tiles changed the denoised radiance"
);
assert_eq!(
skipped.radiance_history, reference.radiance_history,
"{flags:?} {filter:?}: skipping tiles changed the radiance history"
);
let reach = if filter == WIDE_FILTER { 2 } else { 1 };
for tile in [2 - reach, 2 + reach] {
assert!(
(0..(SIZE[0] * SIZE[1]) as usize)
.filter(|pixel| pixel % SIZE[0] as usize / 8 == tile)
.any(|pixel| reference.output[pixel][3] > 0.0),
"{flags:?} {filter:?}: the hits must reach tile {tile} for this check to bite"
);
}
for pixel in far_from_hit_columns() {
assert_eq!(
skipped.variance_history[pixel], 1.0,
"{flags:?} {filter:?}: pixel {pixel} of a tile without hits was denoised"
);
}
}
}
}
#[test]
fn tiles_that_stop_hitting_keep_no_history() {
let Some((device, queue)) = device() else {
return;
};
for flags in [FeatureFlags::NONE, FeatureFlags::HALF_RESOLUTION] {
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(
&device,
&queue,
post_fx_context::CreateInfo {
transition_duration: 0.0,
},
);
let columns = hit_columns(flags);
for index in 0..4 {
let frame = denoise_frame(
&device,
&queue,
&mut ssr,
&mut context,
flags,
DEFAULT_FILTER,
index,
false,
None,
|x, y| index < 2 || columns(x, y),
);
for pixel in far_from_hit_columns() {
if index < 2 {
assert!(
frame.radiance_history[pixel][3] > 0.5,
"{flags:?} frame {index}: pixel {pixel} must accumulate the hits"
);
} else {
assert_eq!(
(
frame.radiance_history[pixel],
frame.variance_history[pixel],
frame.output[pixel]
),
([0.0; 4], 1.0, [0.0; 4]),
"{flags:?} frame {index}: pixel {pixel} kept an older reflection"
);
}
}
}
}
}
#[test]
fn pixels_returning_to_the_mask_keep_no_old_radiance() {
let Some((device, queue)) = device() else {
return;
};
let run = |hit_before_leaving: bool| {
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(
&device,
&queue,
post_fx_context::CreateInfo {
transition_duration: 0.0,
},
);
let mut frames = (0..6).map(|index| {
denoise_frame_over(
&device,
&queue,
&mut ssr,
&mut context,
FeatureFlags::NONE,
DEFAULT_FILTER,
index,
false,
None,
|x, y| match index {
0 | 1 => hit_before_leaving,
2..=4 => false,
_ => checkerboard(x, y),
},
|x, _| x < 32 || !(2..=4).contains(&index),
)
});
let before_leaving = frames.nth(1).unwrap();
(before_leaving, frames.last().unwrap())
};
let (white_before, white) = run(true);
let (black_before, black) = run(false);
let right = |pixel: &usize| pixel % SIZE[0] as usize >= 32;
for pixel in (0..(SIZE[0] * SIZE[1]) as usize).filter(right) {
assert!(
white_before.radiance_history[pixel][3] > black_before.radiance_history[pixel][3] + 0.5,
"pixel {pixel} must hold the white hits before leaving"
);
}
let differ = |a: &[[f32; 4]], b: &[[f32; 4]]| a.iter().zip(b).filter(|(a, b)| a != b).count();
let radiance = differ(&white.radiance_history, &black.radiance_history);
let output = differ(&white.output, &black.output);
assert_eq!(
(radiance, output),
(0, 0),
"the radiance from before leaving reached {radiance} history and {output} output pixels"
);
}
#[test]
fn a_reset_frame_takes_the_current_radiance() {
let Some((device, queue)) = device() else {
return;
};
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(
&device,
&queue,
post_fx_context::CreateInfo {
transition_duration: 0.0,
},
);
for (index, flags) in [
(0, FeatureFlags::NONE),
(1, FeatureFlags::NONE),
(3, FeatureFlags::NONE),
(4, FeatureFlags::HALF_RESOLUTION),
] {
let frame = denoise_frame(
&device,
&queue,
&mut ssr,
&mut context,
flags,
DEFAULT_FILTER,
index,
false,
None,
checkerboard,
);
let lit = frame
.resolved_radiance
.iter()
.filter(|r| r[3] > 0.0)
.count();
assert!(lit > 0, "frame {index}: the reconstruction found no hits");
let differ = frame
.radiance_history
.iter()
.zip(&frame.resolved_radiance)
.filter(|(history, current)| history != current)
.count();
if index == 1 {
assert!(differ > 0, "frame {index} took no history");
} else {
assert_eq!(
differ, 0,
"frame {index}: {differ} pixels differ from the current radiance"
);
let untaken = frame.variance_history.iter().filter(|v| **v != 1.0).count();
assert_eq!(
untaken, 0,
"frame {index}: {untaken} pixels' variance is not 1"
);
}
}
}
#[test]
fn reflection_hits_behind_the_previous_camera_take_no_history() {
let Some((device, queue)) = device() else {
return;
};
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(&device, &queue, Default::default());
for index in 0..2 {
let frame = denoise_frame(
&device,
&queue,
&mut ssr,
&mut context,
FeatureFlags::NONE,
DEFAULT_FILTER,
index,
false,
(index == 1).then_some(Previous {
eye: [0., 0., 2.5],
yaw: std::f32::consts::PI,
near: 0.1,
depth: 0.95,
motion: 4.0,
}),
|x, y| index == 0 || checkerboard(x, y),
);
if index == 1 {
for (pixel, variance) in frame.variance_history.iter().enumerate() {
assert_eq!(
*variance, 1.0,
"pixel {pixel} took history from behind the previous camera"
);
}
}
}
}
#[test]
fn surfaces_behind_the_previous_camera_take_no_history() {
let Some((device, queue)) = device() else {
return;
};
let proj = camera(false, 0).m_proj;
for previous_z in [1.96f32, 0.2] {
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(&device, &queue, Default::default());
for index in 0..2 {
let frame = denoise_frame(
&device,
&queue,
&mut ssr,
&mut context,
FeatureFlags::NONE,
DEFAULT_FILTER,
index,
false,
(index == 1).then_some(Previous {
eye: [0., 0., 2.5],
yaw: 15f32.to_radians(),
near: 0.1,
depth: proj[10] + proj[14] / previous_z,
motion: 4.0,
}),
|x, y| index == 0 || checkerboard(x, y),
);
if index == 1 {
for (pixel, variance) in frame.variance_history.iter().enumerate() {
assert_eq!(
*variance, 1.0,
"previous surfaces {previous_z} m away: pixel {pixel} took history"
);
}
}
}
}
}
#[test]
fn a_changed_near_plane_keeps_history() {
let Some((device, queue)) = device() else {
return;
};
let current = camera(false, 0).m_proj;
let z = current[14] / (0.95 - current[10]);
let mut histories = Vec::new();
for near in [0.1f32, 1.0] {
let previous = camera_with_near(false, 0, near).m_proj;
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(&device, &queue, Default::default());
for index in 0..2 {
let frame = denoise_frame(
&device,
&queue,
&mut ssr,
&mut context,
FeatureFlags::NONE,
DEFAULT_FILTER,
index,
false,
(index == 1).then_some(Previous {
eye: [0.; 3],
yaw: 0.,
near,
depth: previous[10] + previous[14] / z,
motion: 0.,
}),
|_, _| true,
);
if index == 1 {
histories.push(frame.variance_history);
}
}
}
let untaken = histories[0].iter().filter(|v| **v >= 1.0).count();
assert_eq!(
untaken, 0,
"{untaken} pixels took no history with the near plane unchanged"
);
let differ = histories[0]
.iter()
.zip(&histories[1])
.filter(|(a, b)| a != b)
.count();
assert_eq!(
differ, 0,
"{differ} pixels' history changed with the near plane"
);
}
#[test]
fn offscreen_candidates_cannot_discard_valid_reflection_history() {
let Some((device, queue)) = device() else {
return;
};
for candidate in ["behind-camera hit", "offscreen hit", "offscreen surface"] {
let behind = candidate == "behind-camera hit";
let offscreen_surface = candidate == "offscreen surface";
for flags in [FeatureFlags::NONE, FeatureFlags::HALF_RESOLUTION] {
let mut ssr = ScreenSpaceReflection::new(&device);
let mut context = PostFXContext::new(&device, &queue, Default::default());
let current = camera(false, 0);
let surface_z = current.m_proj[14] / (0.95 - current.m_proj[10]);
let previous = Previous {
eye: if behind {
[0., 0., 2.5]
} else if offscreen_surface {
[0.; 3]
} else {
[10., 0., 0.]
},
yaw: if behind {
std::f32::consts::PI
} else if offscreen_surface {
0.
} else {
-(10. / surface_z).atan()
},
near: 0.1,
depth: 0.95,
motion: 0.,
};
let previous_camera = moved(current, previous);
let previous_surface_z = if behind {
2.5 - surface_z
} else if offscreen_surface {
surface_z
} else {
(100. + surface_z * surface_z).sqrt()
};
let previous_depth_value = current.m_proj[10] + current.m_proj[14] / previous_surface_z;
let virtual_z = if behind {
4.
} else if offscreen_surface {
surface_z
} else {
20.
};
let virtual_depth = current.m_proj[10] + current.m_proj[14] / virtual_z;
for index in 0..2 {
let mut encoder = device.create_command_encoder(&Default::default());
let scene_depth = depth(&device, &mut encoder, 0.95);
let previous_depth = depth(&device, &mut encoder, previous_depth_value);
let normal = texture(
&device,
&queue,
wgpu::TextureFormat::Rgba16Float,
&half(&[0., 0., -1., 0.]),
);
let material = texture(&device, &queue, wgpu::TextureFormat::R8Unorm, &[0]);
let motion_data: Vec<u8> = (0..SIZE[1])
.flat_map(|y| {
(0..SIZE[0]).flat_map(move |x| {
if offscreen_surface {
return half(&[4., 0.]);
}
let ndc = [
2. * (x as f32 + 0.5) / SIZE[0] as f32 - 1.,
1. - 2. * (y as f32 + 0.5) / SIZE[1] as f32,
];
let point = [
ndc[0] * surface_z / current.m_proj[0],
ndc[1] * surface_z / current.m_proj[5],
surface_z,
1.,
];
let clip: [f32; 4] = std::array::from_fn(|row| {
(0..4)
.map(|column| {
previous_camera.m_view_proj[column * 4 + row]
* point[column]
})
.sum()
});
half(&[ndc[0] - clip[0] / clip[3], ndc[1] - clip[1] / clip[3]])
})
})
.collect();
let motion = texels(
&device,
&queue,
wgpu::TextureFormat::Rg16Float,
&motion_data,
);
context.prepare_resources(
&device,
&FrameDesc {
index,
width: SIZE[0],
height: SIZE[1],
output_width: SIZE[0],
output_height: SIZE[1],
},
post_fx_context::FeatureFlags::NONE,
);
ssr.prepare_resources(&device, &mut encoder, &mut context, flags);
ssr.prepare_shaders_and_pso(&device);
context.execute(&mut post_fx_context::RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
curr_depth_buffer_srv: &scene_depth,
prev_depth_buffer_srv: &previous_depth,
curr_camera: Some(¤t),
prev_camera: Some(&previous_camera),
camera_attribs_cb: None,
pass_timestamps: None,
});
let input: Vec<u8> = (0..SIZE[1])
.flat_map(|y| {
(0..SIZE[0]).flat_map(move |x| {
let value = if index == 0 {
if x == 0 || y == 0 || x + 1 == SIZE[0] || y + 1 == SIZE[1] {
0.5
} else {
0.75
}
} else if checkerboard(x, y) {
1.
} else {
0.
};
half(&[value, value, value, 1.])
})
})
.collect();
let resources = ssr.resources.as_mut().unwrap();
resources.resolved_radiance =
texels(&device, &queue, wgpu::TextureFormat::Rgba16Float, &input);
resources.resolved_variance = texture(
&device,
&queue,
wgpu::TextureFormat::R16Float,
&half(&[0.25]),
);
resources.resolved_depth = texture(
&device,
&queue,
wgpu::TextureFormat::R16Float,
&half(&[virtual_depth]),
);
resources.denoiser_tiles =
texture(&device, &queue, wgpu::TextureFormat::R8Unorm, &[255]);
let attribs = ScreenSpaceReflectionAttribs::default();
let mut render = RenderAttributes {
device: &device,
queue: &queue,
device_context: &mut encoder,
post_fx_context: &mut context,
color_buffer_srv: &normal,
depth_buffer_srv: &scene_depth,
normal_buffer_srv: &normal,
material_buffer_srv: &material,
motion_vectors_srv: &motion,
ssr_attribs: &attribs,
pass_timestamps: None,
reset_accumulation: false,
frame_time: 1. / 60.,
};
ssr.update_constant_buffer(&render, false);
ssr.reset_history(&mut render);
ssr.compute_stencil_mask_and_extract_roughness(&mut render);
ssr.compute_temporal_accumulation(&mut render);
queue.submit([encoder.finish()]);
if index == 1 {
let radiance =
read_rgba16f(&device, &queue, &ssr.resources().radiance_history[1]);
let variance =
read_scalar(&device, &queue, &ssr.resources().variance_history[1]);
for y in 23..25 {
for x in 31..33 {
let pixel = (y * SIZE[0] + x) as usize;
assert!(
variance[pixel] < 0.99,
"candidate={candidate}, flags={flags:?}, ({x},{y}) discarded valid surface history: {}",
variance[pixel]
);
assert!(
(0.5..0.9).contains(&radiance[pixel][0]),
"candidate={candidate}, flags={flags:?}, ({x},{y}) did not blend the interior history: {:?}",
radiance[pixel]
);
}
}
}
}
}
}
}