pub(crate) mod denoise;
pub(crate) mod slots;
use crate::settings::RayTracedShadowQuality;
use crate::shading::RayQueryForm;
use crate::shading::{self, shadow_mask};
use crate::view::cached_group::CachedGroup;
use crate::view::frame::{FrameContext, ShadowMask};
use crate::view::trace_paths::{TracePath, TracePaths};
use std::collections::HashMap;
const DOWNSAMPLE: u32 = 2;
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Params {
inverse_view_projection: [[f32; 4]; 4],
view: [[f32; 4]; 4],
previous_view: [[f32; 4]; 4],
full: [f32; 4],
reduced: [f32; 4],
eye: [f32; 4],
frame: u32,
seed: u32,
denoised: u32,
padding: u32,
}
static COMMON: shading::Module = shading::Module {
name: "traced_shadows_common",
source: include_str!("traced/traced_common.wgsl"),
deps: &[&shading::SHADOW_MASK_SLOTS],
};
pub(crate) static TRACE: shading::Module = shading::Module {
name: "traced_shadows_trace",
source: include_str!("traced/traced_trace.wgsl"),
deps: &[
&shading::BIND_LIT,
&shading::GBUFFER,
&shading::LIGHT_REACH,
&shading::LIGHT_SURFACE,
&shading::HASH,
&shading::SHADOW_MASK_SLOT_KEY,
&shading::SCENE_RAYS_PREDICATE,
&COMMON,
],
};
pub(crate) const TRACE_ENTRY: &str = "traced_shadow_rays";
pub(crate) const TEMPORAL_ENTRY: &str = "traced_shadow_temporal";
pub(crate) const UPSAMPLE_ENTRY: &str = "traced_shadow_upsample";
pub(crate) static TEMPORAL: shading::Module = shading::Module {
name: "traced_shadows_temporal",
source: include_str!("traced/traced_temporal.wgsl"),
deps: &[&shading::SHADOW_MASK_SLOTS, &COMMON],
};
pub(crate) static UPSAMPLE: shading::Module = shading::Module {
name: "traced_shadows_upsample",
source: include_str!("traced/traced_upsample.wgsl"),
deps: &[&shading::SHADOW_MASK_SLOTS, &COMMON],
};
fn texture(
device: &wgpu::Device,
label: &str,
[width, height]: [u32; 2],
layers: u32,
format: wgpu::TextureFormat,
) -> wgpu::TextureView {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: layers,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::STORAGE_BINDING
| wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
texture.create_view(&wgpu::TextureViewDescriptor {
dimension: (layers > 1).then_some(wgpu::TextureViewDimension::D2Array),
..Default::default()
})
}
struct Targets {
full: [u32; 2],
reduced: [u32; 2],
raw: wgpu::TextureView,
depth: [wgpu::TextureView; 2],
temporal: [wgpu::TextureView; 2],
mask: wgpu::TextureView,
denoise: denoise::Targets,
}
impl Targets {
fn new(device: &wgpu::Device, full: [u32; 2]) -> Self {
let reduced = full.map(|side| side.div_ceil(DOWNSAMPLE).max(1));
let words = wgpu::TextureFormat::Rgba32Uint;
let half = |label, format| texture(device, label, reduced, 1, format);
Self {
full,
reduced,
raw: half("ray-traced shadow rays", words),
depth: [0, 1].map(|_| half("ray-traced shadow depth", wgpu::TextureFormat::R32Float)),
temporal: [0, 1].map(|_| half("ray-traced shadow temporal", words)),
mask: texture(
device,
"ray-traced shadow mask",
full,
shadow_mask::LAYERS,
shadow_mask::FORMAT,
),
denoise: denoise::Targets::new(device, reduced),
}
}
}
struct Pass {
pipeline: wgpu::ComputePipeline,
groups: [CachedGroup; 2],
}
impl Pass {
fn new(
device: &wgpu::Device,
module: &'static shading::Module,
entry: &str,
constants: &[(&str, f64)],
) -> Self {
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(entry),
source: wgpu::ShaderSource::Wgsl(shading::compose(&[module]).into()),
});
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(entry),
layout: None,
module: &shader,
entry_point: Some(entry),
compilation_options: wgpu::PipelineCompilationOptions {
constants,
..Default::default()
},
cache: None,
});
let group = || CachedGroup::new(pipeline.get_bind_group_layout(0));
Self {
groups: [group(), group()],
pipeline,
}
}
}
pub(crate) struct TracedShadows {
paths: TracePaths,
trace: HashMap<((), Option<RayQueryForm>), wgpu::ComputePipeline>,
temporal: Pass,
upsample: Pass,
denoiser: denoise::Denoiser,
quality: Option<RayTracedShadowQuality>,
params: wgpu::Buffer,
slot_table: wgpu::Buffer,
slots: slots::Slots,
table: shadow_mask::ShadowMaskSlots,
ran: bool,
targets: Option<Targets>,
frame: u32,
seed: u32,
previous_frame: Option<u32>,
}
impl TracedShadows {
pub fn new(
device: &wgpu::Device,
lit: &wgpu::BindGroupLayout,
scene: &wgpu::BindGroupLayout,
) -> Self {
let entry = |binding, ty| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty,
count: None,
};
let sampled = |sample_type| wgpu::BindingType::Texture {
sample_type,
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
};
let uniform = wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
};
let storage = |format| wgpu::BindingType::StorageTexture {
access: wgpu::StorageTextureAccess::WriteOnly,
format,
view_dimension: wgpu::TextureViewDimension::D2,
};
let unfilterable = wgpu::TextureSampleType::Float { filterable: false };
let entries = [
entry(0, sampled(wgpu::TextureSampleType::Depth)),
entry(1, sampled(unfilterable)),
entry(2, sampled(unfilterable)),
entry(3, uniform),
entry(4, uniform),
entry(5, storage(wgpu::TextureFormat::Rgba32Uint)),
entry(6, storage(wgpu::TextureFormat::R32Float)),
entry(7, storage(wgpu::TextureFormat::Rgba32Uint)),
entry(8, storage(denoise::NORMAL_FORMAT)),
];
let uniform_buffer = |label, size| {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some(label),
size,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
)
};
Self {
paths: TracePaths::new("ray-traced shadow rays", &TRACE, &entries, [lit, scene]),
trace: HashMap::new(),
temporal: Pass::new(device, &TEMPORAL, TEMPORAL_ENTRY, &[]),
upsample: Pass::new(device, &UPSAMPLE, UPSAMPLE_ENTRY, &[]),
denoiser: denoise::Denoiser::default(),
quality: None,
params: uniform_buffer(
"ray-traced shadow parameters",
std::mem::size_of::<Params>() as u64,
),
slot_table: uniform_buffer(
"ray-traced shadow slots",
std::mem::size_of::<shadow_mask::ShadowMaskSlots>() as u64,
),
slots: slots::Slots::default(),
table: shadow_mask::ShadowMaskSlots::new(
[shadow_mask::SHADOW_MASK_EMPTY; shadow_mask::RT_SHADOW_LIGHTS],
0,
0,
),
ran: false,
targets: None,
frame: 0,
seed: 0,
previous_frame: None,
}
}
pub fn encode<'s>(
&'s mut self,
ctx: &mut FrameContext<'_>,
lights: &slots::SlotLights,
) -> Option<ShadowMask<'s>> {
self.ran = false;
let hardware = ctx
.hardware_rays
.filter(|_| ctx.effective.ray_traced_shadows)?;
let size = ctx.sizes.render;
let resized = self.targets.as_ref().is_none_or(|t| t.full != size);
if resized {
self.targets = Some(Targets::new(ctx.device, size));
self.denoiser.forget_groups();
}
let history = ctx.history;
let continuous = history.valid
&& self
.previous_frame
.is_some_and(|previous| history.frames == previous.wrapping_add(1));
let quality = ctx.effective.ray_traced_shadow_quality;
if resized || !continuous || self.quality != Some(quality) {
self.frame = 0;
}
self.quality = Some(quality);
self.previous_frame = Some(history.frames);
let table = self.slots.assign(lights.directional, &lights.local);
self.table = table;
self.denoiser.prepare(ctx.device, quality);
let shape = denoise::Shape::of(quality, table.lights[0]);
crate::counters::write_buffer(ctx.queue, &self.slot_table, 0, bytemuck::bytes_of(&table));
let targets = self.targets.as_ref().unwrap();
let [width, height] = targets.full.map(|side| side as f32);
let [reduced_width, reduced_height] = targets.reduced.map(|side| side as f32);
let view = &ctx.values.view;
let previous_view = history
.previous_camera
.map_or(history.camera.view, |previous| previous.view);
let eye = ctx.input.camera.eye;
crate::counters::write_buffer(
ctx.queue,
&self.params,
0,
bytemuck::bytes_of(&Params {
inverse_view_projection: view.inverse_view_projection,
view: view.view,
previous_view: previous_view.to_cols_array_2d(),
full: [width, height, 1. / width, 1. / height],
reduced: [
reduced_width,
reduced_height,
1. / reduced_width,
1. / reduced_height,
],
eye: [eye.x, eye.y, eye.z, 1.],
frame: self.frame,
seed: self.seed,
denoised: shape.lanes.slots(),
padding: 0,
}),
);
self.seed = self.seed.wrapping_add(1);
let current = (self.frame % 2) as usize;
let previous = 1 - current;
let shared = ctx.targets;
let resource = wgpu::BindingResource::TextureView;
let device = ctx.device;
let form = self.paths.pipeline(
device,
Some(hardware),
(&mut self.trace, ()),
|TracePath { shader, layout, .. }| {
device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("ray-traced shadow rays"),
layout: Some(layout),
module: shader,
entry_point: Some(TRACE_ENTRY),
compilation_options: Default::default(),
cache: None,
})
},
);
let trace_group = self.paths.group(
ctx.device,
Some(hardware),
&[
(0, resource(&shared.depth)),
(1, resource(&shared.normal)),
(2, resource(&shared.f0)),
(3, self.params.as_entire_binding()),
(4, self.slot_table.as_entire_binding()),
(5, resource(&targets.raw)),
(6, resource(&targets.depth[current])),
(7, resource(&targets.denoise.tiles)),
(8, resource(&targets.denoise.normal)),
],
);
{
let mut pass = ctx
.encoder
.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("ray-traced shadow rays"),
timestamp_writes: ctx
.timing
.and_then(|t| t.compute_pass("ray-traced shadow rays")),
});
pass.set_pipeline(&self.trace[&((), form)]);
pass.set_bind_group(0, ctx.bindings.camera_lit(), &[]);
pass.set_bind_group(1, &ctx.scene.scene_group, &[]);
pass.set_bind_group(3, trace_group, &[]);
pass.dispatch_workgroups(
targets.reduced[0].div_ceil(8),
targets.reduced[1].div_ceil(4),
1,
);
}
if shape.runs(table.lights[0]) {
self.denoiser.encode(
ctx.device,
ctx.encoder,
ctx.timing,
shape,
&targets.denoise,
denoise::Inputs {
depth: &shared.depth,
motion: &shared.motion,
half_depth: &targets.depth[current],
previous_depth: &targets.depth[previous],
params: &self.params,
slot_table: &self.slot_table,
reduced: targets.reduced,
current,
},
);
}
let temporal_group = self.temporal.groups[current].get(
ctx.device,
"ray-traced shadow temporal",
&[
(0, resource(&targets.raw)),
(1, resource(&targets.temporal[previous])),
(2, resource(&targets.depth[current])),
(3, resource(&targets.depth[previous])),
(4, resource(&shared.motion)),
(5, self.params.as_entire_binding()),
(6, self.slot_table.as_entire_binding()),
(7, resource(&targets.temporal[current])),
(8, targets.denoise.denoised.as_entire_binding()),
],
);
{
let mut pass = ctx
.encoder
.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("ray-traced shadow temporal"),
timestamp_writes: ctx
.timing
.and_then(|t| t.compute_pass("ray-traced shadow temporal")),
});
pass.set_pipeline(&self.temporal.pipeline);
pass.set_bind_group(0, temporal_group, &[]);
pass.dispatch_workgroups(
targets.reduced[0].div_ceil(8),
targets.reduced[1].div_ceil(8),
1,
);
}
let upsample_group = self.upsample.groups[current].get(
ctx.device,
"ray-traced shadow upsample",
&[
(0, resource(&targets.temporal[current])),
(1, resource(&targets.depth[current])),
(2, resource(&shared.depth)),
(3, self.params.as_entire_binding()),
(4, resource(&targets.mask)),
(5, self.slot_table.as_entire_binding()),
],
);
{
let mut pass = ctx
.encoder
.begin_compute_pass(&wgpu::ComputePassDescriptor {
label: Some("ray-traced shadow upsample"),
timestamp_writes: ctx
.timing
.and_then(|t| t.compute_pass("ray-traced shadow upsample")),
});
pass.set_pipeline(&self.upsample.pipeline);
pass.set_bind_group(0, upsample_group, &[]);
pass.dispatch_workgroups(targets.full[0].div_ceil(8), targets.full[1].div_ceil(8), 1);
}
self.frame = self.frame.wrapping_add(1).max(1);
self.ran = true;
Some(ShadowMask {
mask: &targets.mask,
slots: &self.slot_table,
})
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
impl TracedShadows {
pub fn last(&self) -> Option<(&wgpu::TextureView, shadow_mask::ShadowMaskSlots)> {
let targets = self.targets.as_ref().filter(|_| self.ran)?;
Some((&targets.mask, self.table))
}
}
#[cfg(test)]
pub(crate) fn mirrors() -> [crate::shading::layout_tests::Mirror; 1] {
[crate::shading::layout_tests::mirror!(
"traced_shadows_temporal",
"TracedParams",
Params,
[
inverse_view_projection,
view,
previous_view,
full,
reduced,
eye,
frame,
seed,
denoised
]
)]
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;