use crate::settings::{FsrQuality, FsrVersion};
use crate::view::history::Kept;
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::fsr3upscaler::*;
use sp_fidelity::types::{
FFX_RESOURCE_STATE_COMPUTE_READ, FFX_RESOURCE_STATE_UNORDERED_ACCESS, FfxCommandList,
FfxDimensions2D, FfxFloatCoords2D, FfxResource,
};
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: FsrQuality) -> Option<FfxFsr2QualityMode> {
match quality {
FsrQuality::NativeAa => None,
FsrQuality::Quality => Some(FfxFsr2QualityMode::Quality),
FsrQuality::Balanced => Some(FfxFsr2QualityMode::Balanced),
FsrQuality::Performance => Some(FfxFsr2QualityMode::Performance),
FsrQuality::UltraPerformance => Some(FfxFsr2QualityMode::UltraPerformance),
}
}
pub(crate) fn render_size(display: [u32; 2], quality: FsrQuality, version: FsrVersion) -> [u32; 2] {
if version == FsrVersion::Fsr3 {
let mode = match quality {
FsrQuality::NativeAa => FfxFsr3UpscalerQualityMode::NativeAa,
FsrQuality::Quality => FfxFsr3UpscalerQualityMode::Quality,
FsrQuality::Balanced => FfxFsr3UpscalerQualityMode::Balanced,
FsrQuality::Performance => FfxFsr3UpscalerQualityMode::Performance,
FsrQuality::UltraPerformance => FfxFsr3UpscalerQualityMode::UltraPerformance,
};
let (width, height) =
ffx_fsr3_upscaler_get_render_resolution_from_quality_mode(display[0], display[1], mode)
.expect("valid FSR3 quality mode");
return [width.max(1), height.max(1)];
}
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 FsrRun {
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(crate) struct Fsr {
backend: Rc<RefCell<FfxWgpuBackend>>,
context: Context,
display_size: [u32; 2],
output: wgpu::TextureView,
jitter_index: i32,
jitter: [f32; 2],
render_size: [u32; 2],
reset: bool,
history: Kept<FsrRun>,
}
impl Fsr {
pub fn new(
device: &wgpu::Device,
display_size: [u32; 2],
version: FsrVersion,
) -> Result<Self, String> {
if !device.features().contains(required_features()) {
return Err(format!(
"the device lacks {}'s features {:?}",
version.label(),
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 (context, created) = match version {
FsrVersion::Fsr2 => {
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,
},
);
(Context::Fsr2(context), created)
}
FsrVersion::Fsr3 => {
let mut context = FfxFsr3UpscalerContext::default();
let mut created = ffx_fsr3_upscaler_context_create(
&mut context,
&FfxFsr3UpscalerContextDescription {
flags: FFX_FSR3UPSCALER_ENABLE_HIGH_DYNAMIC_RANGE
| FFX_FSR3UPSCALER_ENABLE_DEPTH_INVERTED
| FFX_FSR3UPSCALER_ENABLE_DEPTH_INFINITE,
max_render_size: size,
max_upscale_size: size,
fp_message: None,
backend_interface: interface,
},
);
let shared = if created.is_ok() {
ffx_fsr3_upscaler_get_shared_resource_descriptions(&context)
.inspect_err(|&error| {
created = Err(error);
})
.ok()
.map(|descs| {
let texture =
|desc: sp_fidelity::types::FfxCreateResourceDescription<'_>,
format,
atomic| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some(desc.name),
size: wgpu::Extent3d {
width: desc.resource_description.width,
height: desc.resource_description.height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::STORAGE_BINDING
| wgpu::TextureUsages::COPY_DST
| atomic,
view_formats: &[],
})
};
Shared {
depth: texture(
descs.dilated_depth,
wgpu::TextureFormat::R32Float,
wgpu::TextureUsages::empty(),
),
motion: texture(
descs.dilated_motion_vectors,
wgpu::TextureFormat::Rg16Float,
wgpu::TextureUsages::empty(),
),
previous_depth: texture(
descs.reconstructed_prev_nearest_depth,
wgpu::TextureFormat::R32Uint,
wgpu::TextureUsages::STORAGE_ATOMIC,
),
}
})
} else {
None
};
(
Context::Fsr3 {
context,
shared: shared.map(Box::new),
},
created,
)
}
};
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(
version.label(),
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 fsr = Self {
backend,
context,
display_size,
output,
jitter_index: 0,
jitter: [0.; 2],
render_size: display_size,
reset: true,
history: Kept::default(),
};
match (created, error) {
(Ok(()), None) => Ok(fsr),
(Err(code), _) => Err(format!(
"{} context creation failed ({code:#x})",
version.label()
)),
(Ok(()), Some(error)) => Err(format!(
"{} context creation failed: {error}",
version.label()
)),
}
}
pub fn version(&self) -> FsrVersion {
match self.context {
Context::Fsr2(_) => FsrVersion::Fsr2,
Context::Fsr3 { .. } => FsrVersion::Fsr3,
}
}
pub fn display_size(&self) -> [u32; 2] {
self.display_size
}
pub fn output(&self) -> &wgpu::TextureView {
&self.output
}
pub fn settle(&mut self, finished: bool) {
let ran = self.history.left().is_some();
self.history.settle(finished);
if ran && !finished {
self.history.forget();
}
}
pub fn prepare(&mut self, render_size: [u32; 2], history_valid: bool) -> [f32; 2] {
self.reset = !history_valid
|| self
.history
.last()
.is_none_or(|history| history.render_size != render_size);
self.history.leave(FsrRun { render_size });
self.render_size = render_size;
let [width, height] = render_size.map(|v| i32::try_from(v).unwrap_or(i32::MAX));
let display_width = i32::try_from(self.display_size[0]).unwrap_or(i32::MAX);
let (x, y) = match self.version() {
FsrVersion::Fsr2 => ffx_fsr2_get_jitter_offset(
self.jitter_index,
ffx_fsr2_get_jitter_phase_count(width, display_width),
),
FsrVersion::Fsr3 => ffx_fsr3_upscaler_get_jitter_offset(
self.jitter_index,
ffx_fsr3_upscaler_get_jitter_phase_count(width, display_width),
),
}
.expect("the SDK's jitter phase count 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 label = self.version().label();
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 FSR"),
}),
);
let mut description = Dispatch {
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],
},
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(label, 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(), "FSR_InputColor", read);
description.depth =
backend.ffx_get_resource_wgpu(inputs.depth.texture(), "FSR_InputDepth", read);
description.motion_vectors = backend.ffx_get_resource_wgpu(
inputs.motion.texture(),
"FSR_InputMotionVectors",
read,
);
description.exposure =
backend.ffx_get_resource_wgpu(inputs.exposure, "FSR_InputExposure", read);
let [reactive, composition] = inputs.masks;
description.reactive =
backend.ffx_get_resource_wgpu(reactive.texture(), "FSR_InputReactiveMap", read);
description.transparency_and_composition = backend.ffx_get_resource_wgpu(
composition.texture(),
"FSR_TransparencyAndCompositionMap",
read,
);
description.output = backend.ffx_get_resource_wgpu(
self.output.texture(),
"FSR_OutputUpscaledColor",
FFX_RESOURCE_STATE_UNORDERED_ACCESS,
);
}
let result = self
.context
.dispatch(&description, &self.backend, self.display_size);
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 FSR 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!("{label} dispatch failed ({code:#x})")),
(Ok(()), Some(job), _) => Err(format!("{label} dispatch failed: {job}")),
(Ok(()), None, Some(error)) => Err(format!("{label} dispatch failed: {error}")),
}
}
}
impl Drop for Fsr {
fn drop(&mut self) {
match &mut self.context {
Context::Fsr2(context) => {
let _ = ffx_fsr2_context_destroy(context);
}
Context::Fsr3 { context, .. } => {
let _ = ffx_fsr3_upscaler_context_destroy(context);
}
}
}
}
struct Shared {
depth: wgpu::Texture,
motion: wgpu::Texture,
previous_depth: wgpu::Texture,
}
enum Context {
Fsr2(FfxFsr2Context),
Fsr3 {
context: FfxFsr3UpscalerContext,
shared: Option<Box<Shared>>,
},
}
#[derive(Default)]
struct Dispatch {
command_list: FfxCommandList,
color: FfxResource,
depth: FfxResource,
motion_vectors: FfxResource,
exposure: FfxResource,
reactive: FfxResource,
transparency_and_composition: FfxResource,
output: FfxResource,
jitter_offset: FfxFloatCoords2D,
motion_vector_scale: FfxFloatCoords2D,
render_size: FfxDimensions2D,
frame_time_delta: f32,
pre_exposure: f32,
reset: bool,
camera_near: f32,
camera_far: f32,
camera_fov_angle_vertical: f32,
view_space_to_meters_factor: f32,
}
impl Context {
fn dispatch(
&mut self,
frame: &Dispatch,
backend: &Rc<RefCell<FfxWgpuBackend>>,
display: [u32; 2],
) -> Result<(), sp_fidelity::error::FfxErrorCode> {
match self {
Self::Fsr2(context) => ffx_fsr2_context_dispatch(
context,
&FfxFsr2DispatchDescription {
command_list: frame.command_list,
color: frame.color.clone(),
depth: frame.depth.clone(),
motion_vectors: frame.motion_vectors.clone(),
exposure: frame.exposure.clone(),
reactive: frame.reactive.clone(),
transparency_and_composition: frame.transparency_and_composition.clone(),
output: frame.output.clone(),
jitter_offset: frame.jitter_offset,
motion_vector_scale: frame.motion_vector_scale,
render_size: frame.render_size,
enable_sharpening: false,
frame_time_delta: frame.frame_time_delta,
pre_exposure: frame.pre_exposure,
reset: frame.reset,
camera_near: frame.camera_near,
camera_far: frame.camera_far,
camera_fov_angle_vertical: frame.camera_fov_angle_vertical,
view_space_to_meters_factor: frame.view_space_to_meters_factor,
..Default::default()
},
),
Self::Fsr3 { context, shared } => {
let shared = shared.as_ref().expect("created FSR3 shared resources");
let write = FFX_RESOURCE_STATE_UNORDERED_ACCESS;
let (depth, motion, previous_depth) = {
let mut backend = backend.borrow_mut();
(
backend.ffx_get_resource_wgpu(&shared.depth, "FSR3 dilated depth", write),
backend.ffx_get_resource_wgpu(&shared.motion, "FSR3 dilated motion", write),
backend.ffx_get_resource_wgpu(
&shared.previous_depth,
"FSR3 previous depth",
write,
),
)
};
ffx_fsr3_upscaler_context_dispatch(
context,
&FfxFsr3UpscalerDispatchDescription {
command_list: frame.command_list,
color: frame.color.clone(),
depth: frame.depth.clone(),
motion_vectors: frame.motion_vectors.clone(),
exposure: frame.exposure.clone(),
reactive: frame.reactive.clone(),
transparency_and_composition: frame.transparency_and_composition.clone(),
output: frame.output.clone(),
jitter_offset: frame.jitter_offset,
motion_vector_scale: frame.motion_vector_scale,
render_size: frame.render_size,
enable_sharpening: false,
frame_time_delta: frame.frame_time_delta,
pre_exposure: frame.pre_exposure,
reset: frame.reset,
camera_near: frame.camera_near,
camera_far: frame.camera_far,
camera_fov_angle_vertical: frame.camera_fov_angle_vertical,
view_space_to_meters_factor: frame.view_space_to_meters_factor,
upscale_size: FfxDimensions2D {
width: display[0],
height: display[1],
},
dilated_depth: depth,
dilated_motion_vectors: motion,
reconstructed_prev_nearest_depth: previous_depth,
..Default::default()
},
)
}
}
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;