pub(crate) mod fsr2;
use crate::settings::Fsr2Quality;
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, TAA_MIP_BIAS};
use crate::view::targets::Sizes;
#[derive(Default)]
pub(crate) struct Antialiasing {
fsr2: Option<fsr2::Fsr2>,
fsr2_error: Option<String>,
failed: bool,
}
impl Antialiasing {
pub fn fsr2_running(&self) -> bool {
self.fsr2.is_some()
}
pub fn error(&self) -> Option<&str> {
self.fsr2_error.as_deref()
}
pub fn resize(
&mut self,
device: &wgpu::Device,
scene_size: [u32; 2],
fsr2: Option<Fsr2Quality>,
) -> ([u32; 2], bool) {
let Some(quality) = fsr2.filter(|_| self.fsr2_error.is_none()) else {
let dropped = self.fsr2.take().is_some();
return (scene_size, dropped);
};
let mut restarted = false;
if self
.fsr2
.as_ref()
.is_none_or(|fsr2| fsr2.display_size() != scene_size)
{
self.fsr2 = None;
restarted = true;
match fsr2::Fsr2::new(device, scene_size) {
Ok(fsr2) => self.fsr2 = Some(fsr2),
Err(error) => {
self.fsr2_error = Some(error);
return (scene_size, restarted);
}
}
}
(fsr2::render_size(scene_size, quality), 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.fsr2.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.fsr2 {
let upscaler = self.fsr2.as_mut().unwrap();
let jitter = Jitter {
ndc: upscaler.prepare(sizes.render, history.frames, history.valid),
mip_bias: fsr2::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 {
let post_fx = post_fx.unwrap();
post_fx.temporal_anti_aliasing(ctx.device, ctx.queue, ctx.encoder, color, ctx.timing);
Completed::Taa
} else if ctx.effective.fsr2 {
let upscaler = self.fsr2.as_mut().unwrap();
let inputs = fsr2::Inputs {
color,
depth: ctx.surface.depth,
motion: &ctx.targets.motion,
masks: &ctx.targets.fsr2_masks,
projection: glam::Mat4::from_cols_array_2d(&ctx.values.view.projection),
frame_time_ms: ctx.input.frame_time_ms,
exposure,
sharpness: ctx.effective.fsr2_sharpness,
};
match upscaler.dispatch(ctx.device, ctx.encoder, &inputs, ctx.timing) {
Ok(()) => Completed::Fsr2,
Err(error) => {
self.fsr2 = None;
self.fsr2_error = Some(error);
self.failed = true;
Completed::Composite
}
}
} else {
Completed::Composite
}
}
pub fn take_failure(&mut self) -> bool {
std::mem::take(&mut self.failed)
}
pub fn output(&self) -> &wgpu::TextureView {
self.fsr2.as_ref().expect("FSR2 ran").output()
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn fsr2(&self) -> Option<&fsr2::Fsr2> {
self.fsr2.as_ref()
}
}