use crate::FrameInput;
use crate::scene::RayData;
use crate::settings::{
AmbientOcclusionQuality, Antialiasing, DynamicGiQuality, FogQuality, FsrVersion,
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::CompositeDraws;
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 {
fsr: settings
.antialiasing
.resolve(settings.low())
.fsr()
.map(|version| (version, settings.fsr_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, fsr_running: Option<FsrVersion>) -> Antialiasing {
match settings.antialiasing.resolve(settings.low()) {
choice if choice.fsr().is_some() && choice.fsr() != fsr_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 fsr_sharpness(settings: &Settings, fsr: bool) -> Option<f32> {
let sharpness = settings.fsr_sharpness;
(fsr && settings.fsr_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 fsr_running: Option<FsrVersion>,
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,
ray_data: RayData,
) -> DynamicGiQuality {
if ray_data == RayData::Disabled {
return DynamicGiQuality::Off;
}
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 ray_data: RayData,
pub fog_volumes: bool,
pub receivers: bool,
pub dynamic_gi_volume: bool,
pub blended: bool,
pub moving_surfaces: bool,
pub glow: bool,
pub mist: bool,
pub heat: bool,
}
impl SceneContent {
pub fn of(scene: &crate::Scene) -> Self {
Self {
ray_data: scene.ray_data(),
fog_volumes: !scene.transient.fog_volume_corners.is_empty(),
receivers: scene.materials.holds_receivers(),
dynamic_gi_volume: scene.dynamic_gi.is_some(),
blended: scene.materials.holds_blended() || scene.materials.holds_transmissive(),
moving_surfaces: scene.materials.holds_moving_surfaces(),
glow: scene.transient.glow_count > 0,
mist: !scene.transient.mist_positions.is_empty(),
heat: scene.transient.heat_count > 0,
}
}
}
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 {
fsr_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, fsr_running);
let taa = antialiasing == Antialiasing::Taa && !disable.taa && post_fx_camera;
let fsr = antialiasing.fsr().is_some() && !disable.fsr && 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 || fsr => ShadowFilter::Temporal,
ShadowQuality::High => ShadowFilter::Gaussian,
};
let motion_blur = motion_blur(settings, input).filter(|_| post_fx_camera);
let composite = CompositeDraws {
blended: content.blended,
moving_surfaces: content.moving_surfaces,
glow: content.glow && !disable.effects,
mist: content.mist && atmosphere(settings, input),
heat: content.heat && settings.heat_distortion,
};
let temporal_masks = fsr || taa && composite.any();
let hardware_ray_tracing = match (settings.hardware_ray_tracing, content.ray_data, ray_queries)
{
(false, _, _) => HardwareRayTracing::Off,
(true, RayData::Disabled, _) => HardwareRayTracing::DisabledByScene,
(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,
fsr,
temporal_masks,
fsr_sharpness: fsr_sharpness(settings, fsr),
post_fx: taa || crystal,
shadow_quality: settings.shadow_quality,
shadow_filter,
ambient_occlusion,
screen_space,
world_space: world_space(settings, content.ray_data, screen_space.is_some()),
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 || fsr || motion_blur.is_some()),
fused: fused_supported && !disable.fused_opaque && !occlusion_culling,
occlusion_culling,
local_lights: !disable.local_lights,
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, content.ray_data)
.rays()
.filter(|_| content.dynamic_gi_volume),
volume_paths: volume_paths(settings, tier),
bloom: settings.bloom.enabled(low) && !disable.bloom,
motion_blur,
composite,
culling: !disable.culling,
smaa: !disable.smaa,
smaa_quality: settings.smaa_quality,
tone_mapping: settings.tone_mapping,
upscaling: settings.upscaling,
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,
}
}
pub(super) fn world_space(
settings: &Settings,
ray_data: RayData,
screen_space: bool,
) -> WorldSpaceReflections {
if ray_data == RayData::Enabled && screen_space {
settings.world_space_reflections
} else {
WorldSpaceReflections::Off
}
}
#[cfg(test)]
mod ray_data_tests {
use super::*;
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn disabled_scene_gates_rays_without_changing_requested_settings() {
let settings = Settings {
screen_space_reflections: ScreenSpaceReflections::Full,
world_space_reflections: WorldSpaceReflections::Moving,
hardware_ray_tracing: true,
ray_traced_shadows: true,
dynamic_gi: DynamicGiQuality::High,
volume_paths: true,
..Settings::default()
};
let requested = settings;
let camera = crate::Camera {
view: glam::Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: glam::Vec3::ZERO,
};
let input = FrameInput::new(camera);
let device = Device {
fsr_running: None,
fused_supported: true,
occlusion_supported: true,
ray_queries: Some(RayQueryForm::Baseline),
tier: BindingTier::Extended,
};
let content = SceneContent {
dynamic_gi_volume: true,
..SceneContent::default()
};
let enabled = resolve(&settings, &input, content, device);
assert!(enabled.dynamic_gi.is_some());
assert_eq!(enabled.world_space, WorldSpaceReflections::Moving);
assert!(enabled.ray_traced_shadows);
let disabled = resolve(
&settings,
&input,
SceneContent {
ray_data: RayData::Disabled,
..content
},
device,
);
assert!(disabled.dynamic_gi.is_none());
assert_eq!(disabled.world_space, WorldSpaceReflections::Off);
assert_eq!(
disabled.hardware_ray_tracing,
HardwareRayTracing::DisabledByScene
);
assert!(!disabled.ray_traced_shadows);
assert_eq!(enabled.screen_space, disabled.screen_space);
assert!(disabled.volume_paths);
assert_eq!(enabled.shadow_quality, disabled.shadow_quality);
assert_eq!(enabled.ambient_occlusion, disabled.ambient_occlusion);
assert_eq!(settings, requested);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn enabled_scene_without_ray_consumers_clears_previous_disabled_reason() {
use crate::view::history::{CameraFrame, CameraHistory};
use crate::{Renderer, Scene, SceneOptions, test_support};
let Some((device, queue)) = test_support::device() else {
return;
};
let settings = Settings {
hardware_ray_tracing: true,
dynamic_gi: DynamicGiQuality::Off,
..Settings::default()
};
let mut renderer = Renderer::for_test(&device, &queue, [16; 2], &settings);
let input = FrameInput::new(crate::Camera {
view: glam::Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: glam::Vec3::ZERO,
});
let synthetic = Device {
fsr_running: None,
fused_supported: true,
occlusion_supported: true,
ray_queries: Some(RayQueryForm::Baseline),
tier: renderer.binding_tier(),
};
for mode in [RayData::Disabled, RayData::Enabled] {
let mut scene = Scene::with_options(&device, &queue, SceneOptions { ray_data: mode });
let effective = resolve(&settings, &input, SceneContent::of(&scene), synthetic);
let history = CameraHistory::default().begin(
CameraFrame {
view: input.camera.view,
projection: input.camera.projection,
jitter: [0.; 2],
},
true,
glam::DVec3::ZERO,
0.,
input.visibility_mask,
);
let before = crate::counters::snapshot();
renderer.prepare.run(
&device,
&queue,
&mut scene,
&input,
history,
&effective,
None,
[16; 2],
&mut renderer.views,
&renderer.bindings.frame,
);
assert_eq!(
renderer.ray_tracing_error().is_some(),
mode == RayData::Disabled
);
if mode == RayData::Enabled {
assert_eq!(
effective.hardware_ray_tracing,
HardwareRayTracing::On(RayQueryForm::Baseline)
);
let delta = crate::counters::snapshot().since(&before);
assert_eq!(delta.blas_builds + delta.tlas_builds, 0);
}
}
}
}
#[cfg(all(test, feature = "diagnostics"))]
mod temporal_mask_tests {
use super::*;
use crate::settings::{Antialiasing, FsrVersion};
use wasm_bindgen_test::wasm_bindgen_test;
#[wasm_bindgen_test(unsupported = test)]
fn the_temporal_masks_are_held_exactly_while_a_writer_can_mark_them() {
let camera = crate::Camera {
view: glam::Mat4::IDENTITY,
projection: crate::perspective(1., 1., 0.1),
eye: glam::Vec3::ZERO,
};
let mut input = FrameInput::new(camera);
input.atmosphere = true;
let device = Device {
fsr_running: Some(FsrVersion::Fsr2),
fused_supported: true,
occlusion_supported: true,
ray_queries: None,
tier: BindingTier::Extended,
};
let taa = Settings {
antialiasing: Antialiasing::Taa,
atmosphere: true,
heat_distortion: true,
..Settings::default()
};
let none = SceneContent::default();
let alone = [
SceneContent {
blended: true,
..none
},
SceneContent {
moving_surfaces: true,
..none
},
SceneContent { glow: true, ..none },
SceneContent { mist: true, ..none },
SceneContent { heat: true, ..none },
];
let held = |settings: &Settings, content| {
resolve(settings, &input, content, device).temporal_masks
};
assert!(!held(&taa, none), "a TAA frame nothing can mark");
for content in alone {
assert!(held(&taa, content), "one writer alone");
}
let mut no_effects = taa;
no_effects.diagnostics.disable.effects = true;
assert!(!held(&no_effects, alone[2]), "glow with effects disabled");
let no_atmosphere = Settings {
atmosphere: false,
..taa
};
assert!(!held(&no_atmosphere, alone[3]), "mist without atmosphere");
let no_heat = Settings {
heat_distortion: false,
..taa
};
assert!(!held(&no_heat, alone[4]), "heat with the setting off");
let fsr = Settings {
antialiasing: Antialiasing::Fsr2,
..taa
};
assert!(held(&fsr, none), "an FSR frame, whose dispatch binds them");
let off = Settings {
antialiasing: Antialiasing::Off,
..taa
};
for content in alone {
assert!(!held(&off, content), "no temporal antialiasing");
}
}
}