use crate::settings::Fsr2Quality;
use sp_fidelity::fsr2::{
FFX_FSR2_ENABLE_DEPTH_INFINITE, FFX_FSR2_ENABLE_DEPTH_INVERTED,
FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE, FfxFsr2Context, FfxFsr2ContextDescription,
FfxFsr2DispatchDescription, FfxFsr2QualityMode, ffx_fsr2_context_create,
ffx_fsr2_context_destroy, ffx_fsr2_context_dispatch, ffx_fsr2_get_jitter_offset,
ffx_fsr2_get_jitter_phase_count, ffx_fsr2_get_render_resolution_from_quality_mode,
};
use sp_fidelity::types::{
FFX_RESOURCE_STATE_COMPUTE_READ, FFX_RESOURCE_STATE_UNORDERED_ACCESS, FfxDimensions2D,
FfxFloatCoords2D,
};
use sp_fidelity_wgpu::{FfxWgpuBackend, FfxWgpuPassTimestamps, ffx_get_interface_wgpu};
use std::cell::{Cell, RefCell};
use std::rc::Rc;
fn required_features() -> wgpu::Features {
sp_fidelity_wgpu::required_features()
}
pub(crate) fn features(adapter: &wgpu::Adapter) -> wgpu::Features {
let available = adapter.features();
if available.contains(required_features()) {
required_features() | (available & sp_fidelity_wgpu::optional_features())
} else {
wgpu::Features::empty()
}
}
fn quality_mode(quality: Fsr2Quality) -> Option<FfxFsr2QualityMode> {
match quality {
Fsr2Quality::NativeAa => None,
Fsr2Quality::Quality => Some(FfxFsr2QualityMode::Quality),
Fsr2Quality::Balanced => Some(FfxFsr2QualityMode::Balanced),
Fsr2Quality::Performance => Some(FfxFsr2QualityMode::Performance),
Fsr2Quality::UltraPerformance => Some(FfxFsr2QualityMode::UltraPerformance),
}
}
pub(crate) fn render_size(display: [u32; 2], quality: Fsr2Quality) -> [u32; 2] {
let Some(mode) = quality_mode(quality) else {
return display;
};
let (width, height) =
ffx_fsr2_get_render_resolution_from_quality_mode(display[0], display[1], mode)
.expect("every FfxFsr2QualityMode is in range");
[width.max(1), height.max(1)]
}
pub(crate) fn mip_bias(render: [u32; 2], display: [u32; 2]) -> f32 {
(render[0] as f32 / display[0] as f32).log2() - 1.
}
const MAX_TIMED_PASSES: u32 = 24;
fn validation_error(scope: wgpu::ErrorScopeGuard) -> Option<wgpu::Error> {
let mut future = std::pin::pin!(scope.pop());
match future
.as_mut()
.poll(&mut std::task::Context::from_waker(std::task::Waker::noop()))
{
std::task::Poll::Ready(error) => error,
std::task::Poll::Pending => None,
}
}
struct History {
frames: u32,
render_size: [u32; 2],
}
pub(crate) struct Inputs<'a> {
pub color: &'a wgpu::TextureView,
pub depth: &'a wgpu::TextureView,
pub motion: &'a wgpu::TextureView,
pub masks: &'a [wgpu::TextureView; 2],
pub projection: glam::Mat4,
pub frame_time_ms: f32,
pub exposure: &'a wgpu::Texture,
pub sharpness: Option<f32>,
}
pub(crate) struct Fsr2 {
backend: Rc<RefCell<FfxWgpuBackend>>,
context: FfxFsr2Context,
display_size: [u32; 2],
output: wgpu::TextureView,
jitter_index: i32,
jitter: [f32; 2],
render_size: [u32; 2],
reset: bool,
history: Option<History>,
}
impl Fsr2 {
pub fn new(device: &wgpu::Device, display_size: [u32; 2]) -> Result<Self, String> {
if !device.features().contains(required_features()) {
return Err(format!(
"the device lacks FSR2's features {:?}",
required_features() - device.features()
));
}
let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
let (backend, interface) = ffx_get_interface_wgpu(device);
let size = FfxDimensions2D {
width: display_size[0],
height: display_size[1],
};
let mut context = FfxFsr2Context::default();
let created = ffx_fsr2_context_create(
&mut context,
&FfxFsr2ContextDescription {
flags: FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE
| FFX_FSR2_ENABLE_DEPTH_INVERTED
| FFX_FSR2_ENABLE_DEPTH_INFINITE,
max_render_size: size,
display_size: size,
fp_message: None,
backend_interface: interface,
},
);
let texture = |label, size: [u32; 2], format, usage| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: size[0],
height: size[1],
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | usage,
view_formats: &[],
})
};
let output = texture(
"FSR2 output",
display_size,
crate::shading::gbuffer::COLOR,
wgpu::TextureUsages::STORAGE_BINDING
| wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::COPY_SRC,
)
.create_view(&Default::default());
let error = validation_error(scope);
let fsr2 = Self {
backend,
context,
display_size,
output,
jitter_index: 0,
jitter: [0.; 2],
render_size: display_size,
reset: true,
history: None,
};
match (created, error) {
(Ok(()), None) => Ok(fsr2),
(Err(code), _) => Err(format!("FSR2 context creation failed ({code:#x})")),
(Ok(()), Some(error)) => Err(format!("FSR2 context creation failed: {error}")),
}
}
pub fn display_size(&self) -> [u32; 2] {
self.display_size
}
pub fn output(&self) -> &wgpu::TextureView {
&self.output
}
pub fn forget_history(&mut self) {
self.history = None;
}
pub fn prepare(&mut self, render_size: [u32; 2], frames: u32, history_valid: bool) -> [f32; 2] {
self.reset = !history_valid
|| self.history.as_ref().is_none_or(|history| {
frames != history.frames.wrapping_add(1) || history.render_size != render_size
});
self.history = Some(History {
frames,
render_size,
});
self.render_size = render_size;
let [width, height] = render_size.map(|v| i32::try_from(v).unwrap_or(i32::MAX));
let phases = ffx_fsr2_get_jitter_phase_count(
width,
i32::try_from(self.display_size[0]).unwrap_or(i32::MAX),
);
let (x, y) = ffx_fsr2_get_jitter_offset(self.jitter_index, phases)
.expect("ffxFsr2GetJitterPhaseCount is positive");
self.jitter_index = self.jitter_index.wrapping_add(1).max(0);
self.jitter = [x, y];
[2. * x / width as f32, -2. * y / height as f32]
}
pub fn dispatch(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
inputs: &Inputs<'_>,
timing: Option<&crate::timing::GpuTiming>,
) -> Result<(), String> {
let projection = inputs.projection;
let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
let recorded = std::mem::replace(
encoder,
device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("frame after FSR2"),
}),
);
let mut description = FfxFsr2DispatchDescription {
jitter_offset: FfxFloatCoords2D {
x: self.jitter[0],
y: self.jitter[1],
},
motion_vector_scale: FfxFloatCoords2D {
x: -(self.render_size[0] as f32),
y: -(self.render_size[1] as f32),
},
render_size: FfxDimensions2D {
width: self.render_size[0],
height: self.render_size[1],
},
enable_sharpening: inputs.sharpness.is_some(),
sharpness: inputs.sharpness.unwrap_or_default(),
frame_time_delta: inputs.frame_time_ms,
pre_exposure: 1.,
reset: self.reset,
camera_near: f32::MAX,
camera_far: projection.w_axis.z,
camera_fov_angle_vertical: 2. * projection.y_axis.y.recip().atan(),
view_space_to_meters_factor: 1.,
..Default::default()
};
{
let mut backend = self.backend.borrow_mut();
backend.set_pass_timestamps(
timing
.and_then(|t| t.reserve_compute_passes("FSR2", MAX_TIMED_PASSES))
.map(|(query_set, first, count)| FfxWgpuPassTimestamps {
query_set,
first,
count,
used: Cell::new(0),
}),
);
let read = FFX_RESOURCE_STATE_COMPUTE_READ;
description.command_list = backend.ffx_get_command_list_wgpu(recorded);
description.color =
backend.ffx_get_resource_wgpu(inputs.color.texture(), "FSR2_InputColor", read);
description.depth =
backend.ffx_get_resource_wgpu(inputs.depth.texture(), "FSR2_InputDepth", read);
description.motion_vectors = backend.ffx_get_resource_wgpu(
inputs.motion.texture(),
"FSR2_InputMotionVectors",
read,
);
description.exposure =
backend.ffx_get_resource_wgpu(inputs.exposure, "FSR2_InputExposure", read);
let [reactive, composition] = inputs.masks;
description.reactive =
backend.ffx_get_resource_wgpu(reactive.texture(), "FSR2_InputReactiveMap", read);
description.transparency_and_composition = backend.ffx_get_resource_wgpu(
composition.texture(),
"FSR2_TransparencyAndCompositionMap",
read,
);
description.output = backend.ffx_get_resource_wgpu(
self.output.texture(),
"FSR2_OutputUpscaledColor",
FFX_RESOURCE_STATE_UNORDERED_ACCESS,
);
}
let result = ffx_fsr2_context_dispatch(&mut self.context, &description);
let mut backend = self.backend.borrow_mut();
if let (Some(timing), Some(pool)) = (timing, backend.set_pass_timestamps(None)) {
timing.release_unused(pool.count - pool.used.get());
}
*encoder = backend
.ffx_take_command_list_wgpu(description.command_list)
.expect("the FSR2 command list");
let job_error = backend.take_job_error();
drop(backend);
let error = validation_error(scope);
match (result, job_error, error) {
(Ok(()), None, None) => Ok(()),
(Err(code), _, _) => Err(format!("FSR2 dispatch failed ({code:#x})")),
(Ok(()), Some(job), _) => Err(format!("FSR2 dispatch failed: {job}")),
(Ok(()), None, Some(error)) => Err(format!("FSR2 dispatch failed: {error}")),
}
}
}
impl Drop for Fsr2 {
fn drop(&mut self) {
let _ = ffx_fsr2_context_destroy(&mut self.context);
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;