use crate::FrameInput;
use crate::settings::{
AmbientOcclusionQuality, Antialiasing, DynamicGiQuality, FogQuality, ReflectionMethod,
RenderPreset, SceneResolution, ScreenSpaceReflections, Settings, ShadowQuality,
WorldSpaceReflections,
};
use crate::shading::RayQueryForm;
use crate::shading::bind::BindingTier;
use crate::stages::reflections::velvet;
use crate::view::effective::{
AmbientOcclusion, Effective, HardwareRayTracing, ScreenSpace, ShadowFilter, Sizing,
};
use crate::view::pipelines::LayerConstants;
pub(super) fn traced_shadows(
effective: Effective,
hardware: bool,
lights: &crate::stages::shadows::traced::slots::SlotLights,
) -> Effective {
let ray_traced_shadows = effective.ray_traced_shadows && hardware && !lights.is_empty();
Effective {
ray_traced_shadows,
fused: effective.fused && !ray_traced_shadows,
..effective
}
}
pub(super) fn sizing(settings: &Settings) -> Sizing {
Sizing {
fsr2: (settings.antialiasing.resolve(settings.low()) == Antialiasing::Fsr2)
.then_some(settings.fsr2_quality),
bloom_targets: settings.preset == RenderPreset::High,
}
}
pub(super) fn scene_size(
size: [u32; 2],
preset: RenderPreset,
resolution: SceneResolution,
device_scale: f32,
) -> [u32; 2] {
let scale = match resolution {
SceneResolution::Preset => {
let cap = if preset == RenderPreset::Low {
1.
} else {
1.75
};
(cap / device_scale.max(1.)).min(1.)
}
SceneResolution::Hd => (1280. / size[0].max(1) as f32)
.min(720. / size[1].max(1) as f32)
.min(1.),
SceneResolution::FullHd => (1920. / size[0].max(1) as f32)
.min(1080. / size[1].max(1) as f32)
.min(1.),
SceneResolution::Full => 1.,
SceneResolution::ThreeQuarter => 0.75,
SceneResolution::Half => 0.5,
};
size.map(|x| ((x as f32 * scale).floor() as u32).max(1))
}
pub(super) fn antialiasing(settings: &Settings, fsr2_running: bool) -> Antialiasing {
match settings.antialiasing.resolve(settings.low()) {
Antialiasing::Fsr2 if !fsr2_running => Antialiasing::Taa,
other => other,
}
}
pub(super) fn atmosphere(settings: &Settings, input: &FrameInput) -> bool {
settings.atmosphere && input.atmosphere && !settings.diagnostics_in_effect().disable.atmosphere
}
fn fog(
settings: &Settings,
input: &FrameInput,
fog_volumes: bool,
perspective: bool,
) -> Option<FogQuality> {
let fog = input.fog;
let medium = fog.density > 0. || fog_volumes;
let volume = fog.length.is_finite() && fog.length > 0.;
(atmosphere(settings, input) && medium && volume && perspective).then_some(settings.fog_quality)
}
fn motion_blur(settings: &Settings, input: &FrameInput) -> Option<f32> {
let shutter = input.motion_blur.shutter_angle * settings.motion_blur.shutter_scale();
(shutter.is_finite() && shutter > 0.).then_some(shutter)
}
fn fsr2_sharpness(settings: &Settings, fsr2: bool) -> Option<f32> {
let sharpness = settings.fsr2_sharpness;
(fsr2 && settings.fsr2_sharpening).then(|| {
if sharpness.is_nan() {
0.
} else {
sharpness.clamp(0., 1.)
}
})
}
pub(super) fn first_frame(settings: &Settings, device: Device) -> Effective {
let camera = crate::Camera {
view: glam::Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: glam::Vec3::ZERO,
};
resolve(
settings,
&FrameInput::new(camera),
SceneContent::default(),
device,
)
}
#[derive(Clone, Copy)]
pub(super) struct Device {
pub fsr2_running: bool,
pub fused_supported: bool,
pub occlusion_supported: bool,
pub ray_queries: Option<RayQueryForm>,
pub tier: BindingTier,
}
pub(super) fn dynamic_gi(settings: &Settings, tier: BindingTier) -> DynamicGiQuality {
match tier {
BindingTier::Extended => settings.dynamic_gi,
BindingTier::Basic => DynamicGiQuality::Off,
}
}
pub(super) fn volume_paths(settings: &Settings, tier: BindingTier) -> bool {
settings.volume_paths && tier == BindingTier::Extended
}
#[derive(Clone, Copy, Default)]
pub(super) struct SceneContent {
pub fog_volumes: bool,
pub receivers: bool,
pub dynamic_gi_volume: bool,
}
impl SceneContent {
pub fn of(scene: &crate::Scene) -> Self {
Self {
fog_volumes: !scene.transient.fog_volume_corners.is_empty(),
receivers: scene.materials.holds_receivers(),
dynamic_gi_volume: scene.dynamic_gi.is_some(),
}
}
}
fn trace_cutoff(method: ReflectionMethod) -> (f32, f32) {
match method {
ReflectionMethod::Crystal => (
crate::view::post_fx::ssr_attribs().roughness_threshold,
0.05,
),
ReflectionMethod::Velvet => (velvet::ROUGHNESS_CUTOFF, velvet::ROUGHNESS_FADE),
}
}
pub(super) fn resolve(
settings: &Settings,
input: &FrameInput,
content: SceneContent,
device: Device,
) -> Effective {
let Device {
fsr2_running,
fused_supported,
occlusion_supported,
ray_queries,
tier,
} = device;
let low = settings.low();
let diagnostics = settings.diagnostics_in_effect();
let disable = diagnostics.disable;
let p = input.camera.projection.to_cols_array_2d();
let ambient_occlusion = (settings.ambient_occlusion != AmbientOcclusionQuality::Off
&& p[3][3] == 0.
&& p[2][3] == -1.
&& p[2][0] == 0.
&& p[2][1] == 0.
&& p[2][2] >= 0.
&& p[3][2] > 0.)
.then_some(AmbientOcclusion {
quality: settings.ambient_occlusion,
radius: input.ambient_occlusion_radius,
});
let post_fx_camera = p[3][3] == 0. && p[2][3] == -1. && p[2][2] == 0. && p[3][2] > 0.;
let antialiasing = antialiasing(settings, fsr2_running);
let taa = antialiasing == Antialiasing::Taa && !disable.taa && post_fx_camera;
let fsr2 = antialiasing == Antialiasing::Fsr2 && !disable.fsr2 && post_fx_camera;
let screen_space = match settings.screen_space_reflections {
_ if !post_fx_camera => None,
ScreenSpaceReflections::Off => None,
ScreenSpaceReflections::Half => Some(true),
ScreenSpaceReflections::Full => Some(false),
}
.map(|half_resolution| {
let (cutoff, fade) = trace_cutoff(settings.reflection_method);
ScreenSpace {
method: settings.reflection_method,
half_resolution,
cutoff,
fade,
}
});
let crystal = screen_space.is_some_and(|ssr| ssr.method == ReflectionMethod::Crystal);
let shadow_filter = match settings.shadow_quality {
ShadowQuality::Low => ShadowFilter::Hardware,
ShadowQuality::High if taa || fsr2 => ShadowFilter::Temporal,
ShadowQuality::High => ShadowFilter::Gaussian,
};
let motion_blur = motion_blur(settings, input).filter(|_| post_fx_camera);
let hardware_ray_tracing = match (settings.hardware_ray_tracing, ray_queries) {
(false, _) => HardwareRayTracing::Off,
(true, None) => HardwareRayTracing::Unsupported,
(true, Some(form)) => HardwareRayTracing::On(form),
};
let ray_traced_shadows =
settings.ray_traced_shadows && matches!(hardware_ray_tracing, HardwareRayTracing::On(_));
let occlusion_culling = settings.occlusion_culling && occlusion_supported && !disable.culling;
Effective {
antialiasing,
taa,
fsr2,
fsr2_sharpness: fsr2_sharpness(settings, fsr2),
post_fx: taa || crystal,
shadow_quality: settings.shadow_quality,
shadow_filter,
ambient_occlusion,
screen_space,
world_space: if screen_space.is_some() {
settings.world_space_reflections
} else {
WorldSpaceReflections::Off
},
hardware_ray_tracing,
ray_traced_shadows,
ray_traced_shadow_quality: settings.ray_traced_shadow_quality.resolve(low),
receivers: content.receivers
&& (screen_space.is_some() || taa || fsr2 || motion_blur.is_some()),
fused: fused_supported && !disable.fused_opaque && !occlusion_culling,
occlusion_culling,
local_lights: !disable.local_lights,
atmosphere: atmosphere(settings, input),
fog: fog(
settings,
input,
content.fog_volumes,
p[3][3] == 0. && p[2][3] == -1.,
),
fog_filter: settings.fog_filter,
dynamic_gi: dynamic_gi(settings, tier)
.rays()
.filter(|_| content.dynamic_gi_volume),
volume_paths: volume_paths(settings, tier),
bloom: settings.bloom.enabled(low) && !disable.bloom,
motion_blur,
heat: settings.heat_distortion,
effects: !disable.effects,
culling: !disable.culling,
smaa: !disable.smaa,
smaa_quality: settings.smaa_quality,
tone_mapping: settings.tone_mapping,
anisotropy: settings.anisotropic_filtering.clamp(),
layers: LayerConstants::new(&disable),
source_environment: !disable.source_environment,
#[cfg(feature = "diagnostics")]
frame_probe: diagnostics.frame_probe,
#[cfg(feature = "diagnostics")]
dynamic_gi_observation: diagnostics.dynamic_gi,
capture_tone_target: diagnostics.frame_probe || diagnostics.capture_tone_target,
}
}