pub(crate) mod atlas;
mod cache;
mod plan;
mod shape;
use crate::Scene;
use crate::shading::lights::LocalShadowRecord;
use crate::timing::GpuTiming;
use crate::view::bindings::FrameBindings;
use crate::view::draw_list::DrawInstances;
use crate::view::frame::FrameContext;
use crate::view::pipelines::{GeometryPass, GeometryPipelines};
use glam::{Mat4, Vec3};
pub(crate) use plan::ShadowFrame;
use plan::{Face, Work};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct LocalShadowStats {
pub shadowed: usize,
pub unshadowed: usize,
pub layers_drawn: usize,
pub faces_drawn: usize,
pub draws: usize,
}
struct FaceView {
buffer: wgpu::Buffer,
group: wgpu::BindGroup,
}
pub(crate) struct CaptureShadows {
pub records: wgpu::Buffer,
groups: Vec<wgpu::BindGroup>,
}
pub(crate) struct Local {
frame: Atlas,
layers: Atlas,
pub records: wgpu::Buffer,
written: Vec<LocalShadowRecord>,
clear: wgpu::RenderPipeline,
copy: wgpu::RenderPipeline,
copy_group: wgpu::BindGroup,
plan: plan::Plan,
views: Vec<FaceView>,
}
struct Atlas {
target: wgpu::TextureView,
sampled: wgpu::TextureView,
}
impl Atlas {
fn new(device: &wgpu::Device, label: &str, size: u32) -> Self {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: size,
height: size,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: crate::shading::gbuffer::DEPTH,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
});
Self {
target: texture.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2),
..Default::default()
}),
sampled: texture.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::D2Array),
..Default::default()
}),
}
}
}
pub(crate) static COPY: crate::shading::Module = crate::shading::Module {
name: "local_shadow_copy",
source: include_str!("local/copy.wgsl"),
deps: &[&crate::shading::FULLSCREEN_VS],
};
pub(crate) const COPY_FS_ENTRY: &str = "copy_fs";
fn records_buffer(device: &wgpu::Device, count: usize) -> wgpu::Buffer {
crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some("local light shadow records"),
size: (count.max(1) * std::mem::size_of::<LocalShadowRecord>()) as u64,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
)
}
fn face_pipeline(
device: &wgpu::Device,
label: &str,
module: &wgpu::ShaderModule,
layout: &wgpu::PipelineLayout,
fragment: Option<&str>,
) -> wgpu::RenderPipeline {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(layout),
vertex: wgpu::VertexState {
module,
entry_point: Some(crate::shading::FULLSCREEN_VS_ENTRY),
compilation_options: Default::default(),
buffers: &[],
},
fragment: fragment.map(|entry_point| wgpu::FragmentState {
module,
entry_point: Some(entry_point),
compilation_options: Default::default(),
targets: &[],
}),
primitive: Default::default(),
depth_stencil: Some(wgpu::DepthStencilState {
format: crate::shading::gbuffer::DEPTH,
depth_write_enabled: Some(true),
depth_compare: Some(wgpu::CompareFunction::Always),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
multiview_mask: None,
cache: None,
})
}
fn copy_group(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
layers: &Atlas,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("local light shadow static layers"),
layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&layers.target),
}],
})
}
impl Local {
pub fn new(device: &wgpu::Device, size: u32) -> Self {
let layers = Atlas::new(device, "local light shadow static layers", size);
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("local light shadow copy"),
source: wgpu::ShaderSource::Wgsl(crate::shading::compose(&[©]).into()),
});
let copy_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("local light shadow static layers"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Depth,
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
}],
});
let pipeline_layout = |label, groups: &[Option<&wgpu::BindGroupLayout>]| {
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some(label),
bind_group_layouts: groups,
immediate_size: 0,
})
};
let clear = face_pipeline(
device,
"local light shadow face clear",
&module,
&pipeline_layout("local light shadow face clear", &[]),
None,
);
let copy = face_pipeline(
device,
"local light shadow layer copy",
&module,
&pipeline_layout("local light shadow layer copy", &[Some(©_layout)]),
Some(COPY_FS_ENTRY),
);
Self {
frame: Atlas::new(device, "local light shadow atlas", size),
copy_group: copy_group(device, ©_layout, &layers),
layers,
records: records_buffer(device, 1),
written: vec![LocalShadowRecord::NONE],
clear,
copy,
plan: plan::Plan::new(size),
views: Vec::new(),
}
}
pub fn resize(&mut self, device: &wgpu::Device, size: u32) {
if self.frame.target.texture().width() == size {
return;
}
self.frame = Atlas::new(device, "local light shadow atlas", size);
self.layers = Atlas::new(device, "local light shadow static layers", size);
self.copy_group = copy_group(device, &self.copy.get_bind_group_layout(0), &self.layers);
self.plan = plan::Plan::new(size);
}
pub fn atlas(&self) -> &wgpu::TextureView {
&self.frame.sampled
}
pub fn layers(&self) -> &wgpu::TextureView {
&self.layers.sampled
}
pub fn stats(&self) -> LocalShadowStats {
self.plan.stats
}
pub fn ranking(&self) -> &[crate::content::identity::LightId] {
self.plan.ranking()
}
#[allow(clippy::too_many_arguments)]
pub fn prepare(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
bindings: &FrameBindings,
(scene, drawn): (&Scene, &mut DrawInstances),
camera: (Mat4, Mat4),
frame: ShadowFrame,
enabled: bool,
) {
self.plan.prepare(drawn, scene, camera, frame, enabled);
self.upload_views(device, queue, bindings);
let records = self.plan.records();
if self.written.len() < records.len() {
self.records = records_buffer(device, records.len());
self.written = vec![LocalShadowRecord::NONE; records.len()];
}
write_changed(queue, &self.records, &mut self.written, records);
}
#[allow(clippy::too_many_arguments)]
pub fn plan_capture(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
bindings: &FrameBindings,
(scene, drawn): (&Scene, &mut DrawInstances),
(center, uniform): (Vec3, &wgpu::Buffer),
frame: ShadowFrame,
enabled: bool,
) -> CaptureShadows {
self.plan
.prepare_capture(drawn, scene, center, frame, enabled);
self.upload_views(device, queue, bindings);
let faces = self.plan.faces().len();
CaptureShadows {
records: crate::scene::buffer(
device,
"probe capture local light shadow records",
bytemuck::cast_slice(self.plan.records()),
wgpu::BufferUsages::STORAGE,
),
groups: self.views[..faces]
.iter()
.map(|view| bindings.shadow_group(device, &view.buffer, uniform))
.collect(),
}
}
pub fn encode_capture(
&self,
encoder: &mut wgpu::CommandEncoder,
capture: &CaptureShadows,
(scene, pipelines): (&Scene, &GeometryPipelines),
drawn: &DrawInstances,
) {
self.encode_layers(
encoder,
None,
|index| &capture.groups[index],
(scene, pipelines, drawn),
);
}
pub fn finish_capture(&mut self) {
self.plan.finish();
}
fn upload_views(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
bindings: &FrameBindings,
) {
for (index, face) in self.plan.faces().iter().enumerate() {
let uniform = bytemuck::bytes_of(&face.view.uniform);
if let Some(view) = self.views.get(index) {
crate::counters::write_buffer(queue, &view.buffer, 0, uniform);
} else {
let buffer = crate::scene::buffer(
device,
"local light shadow face",
uniform,
wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
);
let group = bindings.shadow_group(device, &buffer, &bindings.frame);
self.views.push(FaceView { buffer, group });
}
}
}
pub fn encode(&mut self, ctx: &mut FrameContext<'_>) {
let (scene, pipelines, drawn) = (ctx.scene, ctx.pipelines, &ctx.views.instances);
let mut draws = self.encode_layers(
ctx.encoder,
ctx.timing,
|index| &self.views[index].group,
(scene, pipelines, drawn),
);
let faces = self.plan.faces();
if !faces.is_empty() {
let mut pass = begin(ctx.encoder, ctx.timing, &self.frame.target, "local shadows");
for (index, face) in faces.iter().enumerate() {
limit(&mut pass, face);
let casters = if face.work == Work::Full {
pass.set_pipeline(&self.clear);
&face.casters
} else {
pass.set_pipeline(&self.copy);
pass.set_bind_group(0, &self.copy_group, &[]);
&face.moving
};
pass.draw(0..3, 0..1);
pass.set_bind_group(0, &self.views[index].group, &[]);
draws += 1 + casters.draw(
scene,
pipelines,
drawn,
&mut pass,
GeometryPass::LocalShadow,
);
}
}
self.plan.stats.draws = draws;
}
fn encode_layers<'a>(
&self,
encoder: &mut wgpu::CommandEncoder,
timing: Option<&GpuTiming>,
group: impl Fn(usize) -> &'a wgpu::BindGroup,
(scene, pipelines, drawn): (&Scene, &GeometryPipelines, &DrawInstances),
) -> usize {
let mut layers = self
.plan
.faces()
.iter()
.enumerate()
.filter(|(_, face)| face.work == Work::Layer)
.peekable();
if layers.peek().is_none() {
return 0;
}
let mut draws = 0;
let mut pass = begin(encoder, timing, &self.layers.target, "local shadow layers");
for (index, face) in layers {
limit(&mut pass, face);
pass.set_pipeline(&self.clear);
pass.draw(0..3, 0..1);
pass.set_bind_group(0, group(index), &[]);
draws += 1 + face.casters.draw(
scene,
pipelines,
drawn,
&mut pass,
GeometryPass::LocalShadow,
);
}
draws
}
pub fn finish_frame(&mut self) {
self.plan.finish();
}
}
fn write_changed(
queue: &wgpu::Queue,
buffer: &wgpu::Buffer,
written: &mut [LocalShadowRecord],
records: &[LocalShadowRecord],
) {
let changed = |written: &[LocalShadowRecord], index: usize| {
bytemuck::bytes_of(&records[index]) != bytemuck::bytes_of(&written[index])
};
let mut index = 0;
while index < records.len() {
if !changed(written, index) {
index += 1;
continue;
}
let start = index;
while index < records.len() && changed(written, index) {
index += 1;
}
written[start..index].copy_from_slice(&records[start..index]);
crate::counters::write_buffer(
queue,
buffer,
(start * std::mem::size_of::<LocalShadowRecord>()) as u64,
bytemuck::cast_slice(&records[start..index]),
);
}
}
fn begin<'a>(
encoder: &'a mut wgpu::CommandEncoder,
timing: Option<&GpuTiming>,
target: &wgpu::TextureView,
label: &'static str,
) -> wgpu::RenderPass<'a> {
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some(label),
color_attachments: &[],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: target,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
timestamp_writes: timing.and_then(|timing| timing.render_pass(label)),
..Default::default()
})
}
fn limit(pass: &mut wgpu::RenderPass<'_>, face: &Face) {
let [x, y] = face.origin;
let size = face.size as f32;
pass.set_viewport(x as f32, y as f32, size, size, 0., 1.);
pass.set_scissor_rect(x, y, face.size, face.size);
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;