pub(crate) mod bloom;
pub(crate) mod inputs;
mod output;
pub(crate) mod smaa;
pub(crate) mod tone_map;
pub(crate) use output::Output;
use crate::settings::{Antialiasing, SmaaQuality};
use crate::shading::gbuffer::COLOR as HDR;
use crate::view::effective::Effective;
use crate::view::frame::{Completed, FrameContext};
use crate::view::targets::{Sizes, target};
#[derive(Clone, Copy, Debug)]
struct Presentation {
bloom: bool,
smaa: Option<SmaaQuality>,
capture: bool,
}
#[derive(Clone, Copy)]
struct Look<'a> {
exposure: &'a wgpu::TextureView,
stops: f32,
bloom: &'a crate::BloomParameters,
grading: &'a crate::ColorGrading,
tone_mapping: crate::settings::ToneMapping,
}
struct SmaaTargets {
tone_mapped: wgpu::TextureView,
antialiased: wgpu::TextureView,
}
impl SmaaTargets {
fn new(device: &wgpu::Device, scene: [u32; 2]) -> Self {
Self {
tone_mapped: target(device, "tone-mapped scene", scene, HDR),
antialiased: target(device, "antialiased scene", scene, HDR),
}
}
}
pub(crate) struct Post {
inputs: inputs::Inputs,
bloom: bloom::Bloom,
smaa: smaa::Smaa,
scene_size: [u32; 2],
smaa_targets: Option<SmaaTargets>,
tone_map: tone_map::ToneMap,
}
impl Post {
pub fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
output: Output,
sizes: Sizes,
bloom_targets: bool,
smaa_quality: SmaaQuality,
) -> Result<Self, image::ImageError> {
let inputs = inputs::Inputs::new(device);
Ok(Self {
bloom: bloom::Bloom::new(device, &inputs, sizes.scene, bloom_targets),
smaa: smaa::Smaa::new(
device,
queue,
sizes.scene[0],
sizes.scene[1],
HDR,
smaa_quality,
)?,
scene_size: sizes.scene,
smaa_targets: None,
tone_map: tone_map::ToneMap::new(device, &inputs, output, sizes.output),
inputs,
})
}
pub fn resize(&mut self, device: &wgpu::Device, sizes: Sizes, bloom_targets: bool) {
self.inputs.forget();
self.bloom.resize(device, sizes.scene, bloom_targets);
self.scene_size = sizes.scene;
self.smaa_targets = None;
self.tone_map.resize(device, sizes.output);
self.smaa.resize(device, sizes.scene[0], sizes.scene[1]);
}
pub fn forget_inputs(&mut self) {
self.inputs.forget();
}
#[cfg(any(test, feature = "diagnostics"))]
pub fn tone_mapped(&self) -> &wgpu::TextureView {
self.tone_map.tone_mapped()
}
#[cfg(any(test, feature = "diagnostics"))]
pub fn captured_tone_mapped(&self) -> Option<&wgpu::TextureView> {
self.tone_map.captured()
}
pub fn encode(
&mut self,
ctx: &mut FrameContext<'_>,
completed: &wgpu::TextureView,
kind: Completed,
exposure: &wgpu::TextureView,
output: &wgpu::TextureView,
) {
let presentation = Presentation {
bloom: ctx.effective.bloom,
smaa: smaa_resolves(ctx.effective, ctx.sizes, kind)
.then_some(ctx.effective.smaa_quality),
capture: ctx.effective.capture_tone_target,
};
let look = Look {
exposure,
stops: ctx.input.exposure.stops,
bloom: &ctx.input.bloom,
grading: &ctx.input.color_grading,
tone_mapping: ctx.effective.tone_mapping,
};
self.present(
ctx.device,
ctx.queue,
ctx.encoder,
completed,
presentation,
look,
output,
ctx.timing,
);
}
#[allow(clippy::too_many_arguments)]
fn present(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
completed: &wgpu::TextureView,
presentation: Presentation,
look: Look<'_>,
output: &wgpu::TextureView,
timing: Option<&crate::timing::GpuTiming>,
) {
if self.bloom.prepare(device, presentation.bloom) {
self.inputs.forget();
}
let combined = if presentation.bloom && look.bloom.intensity != 0. {
crate::counters::write_buffer(
queue,
&self.inputs.settings,
0,
bytemuck::bytes_of(&bloom::settings(look.bloom, look.stops)),
);
self.bloom
.encode(device, encoder, &self.inputs, completed, look.bloom, timing)
} else {
completed
};
let Some(quality) = presentation.smaa else {
self.tone_map.encode(
device,
queue,
encoder,
&self.inputs,
combined,
self.bloom.halo(),
look.exposure,
look.grading,
look.tone_mapping,
tone_map::Destination::Output {
capture: presentation.capture,
output,
},
timing,
);
return;
};
let scene_size = self.scene_size;
let targets = self
.smaa_targets
.get_or_insert_with(|| SmaaTargets::new(device, scene_size));
self.tone_map.encode(
device,
queue,
encoder,
&self.inputs,
combined,
self.bloom.halo(),
look.exposure,
look.grading,
look.tone_mapping,
tone_map::Destination::Scene(&targets.tone_mapped),
timing,
);
self.smaa.set_quality(device, quality);
self.smaa.encode(
device,
encoder,
&targets.tone_mapped,
&targets.antialiased,
timing,
);
self.tone_map.resample(
device,
encoder,
&self.inputs,
&targets.antialiased,
self.bloom.halo(),
presentation.capture,
output,
timing,
);
}
}
fn smaa_resolves(effective: &Effective, sizes: Sizes, completed: Completed) -> bool {
let antialiasing = match effective.antialiasing {
Antialiasing::Smaa => true,
Antialiasing::Taa => completed != Completed::Taa,
Antialiasing::Fsr2 => effective.fsr2 && completed != Completed::Fsr2,
_ => false,
};
antialiasing && effective.smaa && sizes.render == sizes.scene
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;