pub(crate) mod fsr;
pub(crate) mod reach;
use crate::settings::{FsrQuality, FsrVersion};
use crate::view::Jitter;
use crate::view::effective::Effective;
use crate::view::frame::{Completed, FrameContext};
use crate::view::history::HistoryFrame;
use crate::view::post_fx::{PostFx, Responsive, TAA_MIP_BIAS};
use crate::view::targets::Sizes;
#[derive(Default)]
pub(crate) struct Antialiasing {
fsr: Option<fsr::Fsr>,
errors: [Option<String>; 2],
selected: Option<FsrVersion>,
failed: bool,
reach: Option<reach::Reach>,
}
impl Antialiasing {
pub fn fsr_running(&self) -> Option<FsrVersion> {
self.fsr.as_ref().map(|fsr| fsr.version())
}
pub fn error(&self) -> Option<&str> {
self.selected
.and_then(|version| self.errors[version.index()].as_deref())
}
pub fn resize(
&mut self,
device: &wgpu::Device,
scene_size: [u32; 2],
selection: Option<(FsrVersion, FsrQuality)>,
) -> ([u32; 2], bool) {
self.selected = selection.map(|(version, _)| version);
let Some((version, quality)) =
selection.filter(|(version, _)| self.errors[version.index()].is_none())
else {
let dropped = self.fsr.take().is_some();
return (scene_size, dropped);
};
let mut restarted = false;
if self
.fsr
.as_ref()
.is_none_or(|fsr| fsr.display_size() != scene_size || fsr.version() != version)
{
self.fsr = None;
restarted = true;
match fsr::Fsr::new(device, scene_size, version) {
Ok(fsr) => self.fsr = Some(fsr),
Err(error) => {
self.errors[version.index()] = Some(error);
return (scene_size, restarted);
}
}
}
(fsr::render_size(scene_size, quality, version), restarted)
}
pub fn prepare(
&mut self,
effective: &Effective,
sizes: Sizes,
history: HistoryFrame,
post_fx: Option<&mut PostFx>,
context_jitter: Option<[f32; 2]>,
) -> Option<Jitter> {
if !history.valid
&& let Some(upscaler) = self.fsr.as_mut()
{
upscaler.forget_history();
}
if effective.taa {
Some(Jitter {
ndc: context_jitter.expect("TAA runs in the post-effect context"),
mip_bias: TAA_MIP_BIAS,
})
} else if effective.fsr {
let upscaler = self.fsr.as_mut().unwrap();
let jitter = Jitter {
ndc: upscaler.prepare(sizes.render, history.frames, history.valid),
mip_bias: fsr::mip_bias(sizes.render, sizes.scene),
};
if let Some(post_fx) = post_fx {
post_fx.set_jitter(jitter.ndc);
}
Some(jitter)
} else {
None
}
}
pub fn encode(
&mut self,
ctx: &mut FrameContext<'_>,
post_fx: Option<&mut PostFx>,
exposure: &wgpu::Texture,
) -> Completed {
let color = &ctx.targets.composite;
if !ctx.effective.taa {
self.reach = None;
}
if ctx.effective.taa {
let post_fx = post_fx.unwrap();
let reach = self
.reach
.get_or_insert_with(|| reach::Reach::new(ctx.device))
.encode(ctx);
post_fx.temporal_anti_aliasing(
ctx.device,
ctx.queue,
ctx.encoder,
color,
ctx.scene.rigid_objects_changed() || ctx.history.visibility_changed,
Responsive {
masks: ctx.targets.temporal_masks.as_ref(),
reach: &reach,
},
ctx.timing,
);
Completed::Taa
} else if ctx.effective.fsr {
let upscaler = self.fsr.as_mut().unwrap();
let inputs = fsr::Inputs {
color,
depth: ctx.surface.depth,
motion: &ctx.targets.motion,
masks: ctx
.targets
.temporal_masks
.as_ref()
.expect("FSR frame masks"),
projection: glam::Mat4::from_cols_array_2d(&ctx.values.view.projection),
frame_time_ms: ctx.input.frame_time_ms,
exposure,
sharpness: ctx.effective.fsr_sharpness,
};
match upscaler.dispatch(ctx.device, ctx.encoder, &inputs, ctx.timing) {
Ok(()) => Completed::Fsr,
Err(error) => {
self.errors[upscaler.version().index()] = Some(error);
self.fsr = None;
self.failed = true;
Completed::Composite
}
}
} else {
Completed::Composite
}
}
pub fn forget_inputs(&mut self) {
if let Some(reach) = self.reach.as_mut() {
reach.forget_inputs();
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn reach_groups(&self) -> Option<usize> {
self.reach.as_ref().map(reach::Reach::cached_groups)
}
pub fn take_failure(&mut self) -> bool {
std::mem::take(&mut self.failed)
}
pub fn output(&self) -> &wgpu::TextureView {
self.fsr.as_ref().expect("FSR ran").output()
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn fsr(&self) -> Option<&fsr::Fsr> {
self.fsr.as_ref()
}
}