pub(crate) mod bloom;
pub(crate) mod inputs;
pub(crate) mod smaa;
pub(crate) mod tone_map;
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,
}
pub(crate) struct Post {
inputs: inputs::Inputs,
bloom: bloom::Bloom,
smaa: smaa::Smaa,
antialiased: wgpu::TextureView,
tone_map: tone_map::ToneMap,
}
impl Post {
pub fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
format: wgpu::TextureFormat,
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,
)?,
antialiased: target(device, "antialiased HDR scene", sizes.scene, HDR),
tone_map: tone_map::ToneMap::new(device, &inputs, format, 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.antialiased = target(device, "antialiased HDR scene", sizes.scene, HDR);
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,
};
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 hdr = if let Some(quality) = presentation.smaa {
self.smaa.set_quality(device, quality);
self.smaa
.encode(device, encoder, combined, &self.antialiased, timing);
&self.antialiased
} else {
combined
};
self.tone_map.encode(
device,
queue,
encoder,
&self.inputs,
hdr,
self.bloom.halo(),
look.exposure,
look.grading,
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;