use super::Renderer;
use super::effective;
use super::shared::Shared;
use crate::settings::{Antialiasing, Settings};
use crate::stages::shadows::local::LocalShadowStats;
use crate::stages::{
antialiasing, cull::Cull, exposure::Exposure, fog::VolumetricFog, motion_blur::MotionBlur,
opaque::Opaque, post::Post, reflections::Reflections, shadows::Shadows,
shadows::contact::ContactShadowStage, shadows::traced::TracedShadows, sky::Sky,
transparent::Transparent,
};
use crate::view::FrameViews;
use crate::view::bindings::FrameBindings;
use crate::view::draw_list::GeometryStats;
use crate::view::draw_list::readback::StatisticsReadback;
use crate::view::effective::Effective;
use crate::view::history::{CameraFrame, CameraHistory, HistoryFrame};
use crate::view::post_fx::PostFx;
use crate::view::targets::{SharedTargets, Sizes};
use crate::{FrameInput, Scene};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
pub struct ViewFrame<'a> {
pub view: &'a mut View,
pub input: &'a FrameInput,
pub settings: &'a Settings,
pub output: &'a wgpu::TextureView,
pub timing: Option<&'a crate::timing::GpuTiming>,
}
#[derive(Debug)]
pub enum ViewError {
LookupTextures(image::ImageError),
UnsupportedSurfaceOutput {
format: wgpu::TextureFormat,
color_space: wgpu::SurfaceColorSpace,
},
}
impl std::fmt::Display for ViewError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::LookupTextures(error) => write!(f, "SMAA lookup textures: {error}"),
Self::UnsupportedSurfaceOutput {
format,
color_space,
} => {
write!(
f,
"unsupported SGL3D surface output: {format:?} in {color_space:?}"
)
}
}
}
}
impl std::error::Error for ViewError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::LookupTextures(error) => Some(error),
Self::UnsupportedSurfaceOutput { .. } => None,
}
}
}
pub struct View {
pub(crate) output_encodes_srgb: bool,
pub(crate) sizes: Sizes,
pub(crate) bloom_targets: bool,
pub(crate) targets: SharedTargets,
pub(crate) views: Box<FrameViews>,
pub(crate) bindings: FrameBindings,
pub(crate) post_fx: Option<Box<PostFx>>,
pub(crate) cull: Cull,
pub(crate) sky: Sky,
pub(crate) statistics: StatisticsReadback,
pub(crate) shadows: Shadows,
pub(crate) traced_shadows: Box<TracedShadows>,
pub(crate) contact_shadows: Box<ContactShadowStage>,
pub(crate) fog: VolumetricFog,
pub(crate) opaque: Opaque,
pub(crate) reflections: Box<Reflections>,
pub(crate) transparent: Transparent,
pub(crate) exposure: Exposure,
pub(crate) antialiasing: antialiasing::Antialiasing,
pub(crate) motion_blur: MotionBlur,
pub(crate) post: Box<Post>,
pub(crate) history: CameraHistory,
pub(crate) pending_reset: bool,
pub(crate) targets_generation: u64,
pub(crate) finished: Option<u64>,
pub(crate) rendered: Option<Pending>,
pub(crate) renderer: u64,
#[cfg(feature = "diagnostics")]
pub(crate) probe: Option<crate::stages::frame_probe::FrameProbe>,
#[cfg(any(test, feature = "diagnostics"))]
pub(crate) completed: Option<crate::view::frame::Completed>,
}
pub(crate) struct Pending {
pub attempt: u64,
pub finished: Arc<AtomicBool>,
pub history: HistoryFrame,
pub generation: u64,
}
impl View {
pub fn new(
renderer: &Renderer,
device: &wgpu::Device,
queue: &wgpu::Queue,
output_format: wgpu::TextureFormat,
output_size: [u32; 2],
device_scale: f32,
settings: &Settings,
) -> Result<Self, ViewError> {
Self::with_output(
renderer,
(device, queue),
crate::stages::post::Output::texture(output_format),
output_size,
device_scale,
settings,
)
}
pub fn new_surface(
renderer: &Renderer,
device: &wgpu::Device,
queue: &wgpu::Queue,
config: &wgpu::SurfaceConfiguration,
capabilities: &wgpu::SurfaceCapabilities,
device_scale: f32,
settings: &Settings,
) -> Result<Self, ViewError> {
let output = crate::stages::post::Output::surface(
config,
capabilities,
device.adapter_info().backend,
)
.ok_or(ViewError::UnsupportedSurfaceOutput {
format: config.format,
color_space: config.color_space,
})?;
Self::with_output(
renderer,
(device, queue),
output,
[config.width, config.height],
device_scale,
settings,
)
}
fn with_output(
renderer: &Renderer,
(device, queue): (&wgpu::Device, &wgpu::Queue),
output: crate::stages::post::Output,
output_size: [u32; 2],
device_scale: f32,
settings: &Settings,
) -> Result<Self, ViewError> {
let shared = &renderer.shared;
let scene = effective::scene_size(
output_size,
settings.preset,
settings.scene_resolution,
device_scale,
);
let sizing = effective::sizing(settings);
let mut antialiasing = antialiasing::Antialiasing::default();
let (render, _) = antialiasing.resize(device, scene, sizing.fsr);
let sizes = Sizes {
render,
scene,
output: output_size,
};
let layouts = &shared.layouts;
let views = Box::new(FrameViews::new(device));
let shadows = Shadows::new(device, settings.shadow_quality);
let fog = VolumetricFog::new(device);
let bindings = FrameBindings::new(
device,
layouts,
&views,
shadows.maps(),
fog.volume(),
shared
.dynamic_gi
.as_ref()
.map(crate::stages::dynamic_gi::DynamicGi::probes),
);
let targets = SharedTargets::new(device, render, false);
let cull = Cull::new(device);
let exposure = Exposure::new(device);
let first_frame = effective::first_frame(
settings,
shared.device(antialiasing.fsr_running(), cull.occlusion_supported()),
);
Ok(Self {
output_encodes_srgb: output.encodes_srgb,
opaque: Opaque::new(
device,
&bindings.unlit,
[
&bindings.shadow_mask,
&bindings.contact_shadow,
&bindings.screen_indirect,
&bindings.shadow_mask_screen_indirect,
&bindings.contact_shadow_screen_indirect,
],
),
traced_shadows: Box::new(TracedShadows::new(device, &bindings.lit, &bindings.scene)),
contact_shadows: Box::new(ContactShadowStage::new(device)),
reflections: Box::new(Reflections::new(device, queue, render, &first_frame)),
transparent: Transparent::new(
device,
&bindings.unlit,
&bindings.blended,
&targets,
exposure.view(),
bindings.lit.tier,
),
exposure,
antialiasing,
motion_blur: MotionBlur::new(device),
post: Box::new(
Post::new(
device,
queue,
output,
sizes,
sizing.bloom_targets,
settings.smaa_quality,
)
.map_err(ViewError::LookupTextures)?,
),
cull,
sky: Sky::default(),
statistics: StatisticsReadback::default(),
sizes,
bloom_targets: sizing.bloom_targets,
targets,
views,
bindings,
post_fx: None,
shadows,
fog,
history: CameraHistory::default(),
pending_reset: false,
targets_generation: 0,
finished: None,
rendered: None,
renderer: renderer.id,
#[cfg(feature = "diagnostics")]
probe: None,
#[cfg(any(test, feature = "diagnostics"))]
completed: None,
})
}
pub fn resize(
&mut self,
device: &wgpu::Device,
output_size: [u32; 2],
device_scale: f32,
settings: &Settings,
) {
self.settle(false);
let scene = effective::scene_size(
output_size,
settings.preset,
settings.scene_resolution,
device_scale,
);
let sizing = effective::sizing(settings);
let (render, restarted) = self.antialiasing.resize(device, scene, sizing.fsr);
if restarted {
self.pending_reset = true;
self.targets_generation = self.targets_generation.wrapping_add(1);
self.post.forget_inputs();
self.motion_blur.forget_inputs();
self.antialiasing.forget_inputs();
}
let sizes = Sizes {
render,
scene,
output: output_size,
};
if self.sizes == sizes && self.bloom_targets == sizing.bloom_targets {
return;
}
self.targets = SharedTargets::new(device, render, self.targets.surface.is_some());
self.exposure.forget_inputs();
self.motion_blur.forget_inputs();
self.antialiasing.forget_inputs();
self.post.resize(device, sizes, sizing.bloom_targets);
self.transparent
.resize(device, &self.targets, self.exposure.view());
self.reflections.resize(device, render);
self.sizes = sizes;
self.bloom_targets = sizing.bloom_targets;
self.pending_reset = true;
self.targets_generation = self.targets_generation.wrapping_add(1);
}
pub fn output_encodes_srgb(&self) -> bool {
self.output_encodes_srgb
}
pub fn antialiasing_in_effect(&self, settings: &Settings) -> Antialiasing {
effective::antialiasing(settings, self.antialiasing.fsr_running())
}
pub fn fsr_error(&self) -> Option<&str> {
self.antialiasing.error()
}
pub fn render_size(&self) -> [u32; 2] {
self.sizes.render
}
pub fn scene_size(&self) -> [u32; 2] {
self.sizes.scene
}
pub fn geometry_stats(&mut self, device: &wgpu::Device) -> Option<GeometryStats> {
self.settle(false);
self.statistics.poll(device);
self.statistics.latest()
}
pub fn local_shadow_stats(&self) -> LocalShadowStats {
self.shadows.local.stats()
}
pub fn occlusion_culling_in_effect(&self, settings: &Settings) -> bool {
settings.occlusion_culling
&& self.cull.occlusion_supported()
&& !settings.diagnostics_in_effect().disable.culling
}
pub(super) fn begin(
&mut self,
device: &wgpu::Device,
shared: &Shared,
scene: &Scene,
input: &FrameInput,
settings: &Settings,
) -> (HistoryFrame, Effective) {
self.settle(true);
let history = self.begin_history(scene, input);
if scene.materials.holds_receivers() {
self.targets.hold_surface(device);
}
let effective = effective::resolve(
settings,
input,
effective::SceneContent::of(scene),
shared.device(
self.antialiasing.fsr_running(),
self.cull.occlusion_supported(),
),
);
self.targets
.set_temporal_masks(device, effective.temporal_masks);
(history, effective)
}
pub(crate) fn begin_history(&self, scene: &Scene, input: &FrameInput) -> HistoryFrame {
let reset = input.camera_cut
|| self.pending_reset
|| self.finished.is_none()
|| self.finished != scene.last_finished();
let camera = CameraFrame {
view: input.camera.view,
projection: input.camera.projection,
jitter: [0.; 2],
};
let mut frame = self.history.begin(
camera,
reset,
scene.origin(),
input.elapsed_seconds,
input.visibility_mask,
);
self.history
.set_backdrop(&mut frame, crate::view::backdrop_yaw(input));
frame
}
pub(crate) fn settle(&mut self, again: bool) {
let Some(pending) = &self.rendered else {
return;
};
let finished = pending.finished.load(Ordering::Acquire);
if !finished && !again {
return;
}
let Some(Pending {
attempt,
history,
generation,
..
}) = self.rendered.take()
else {
return;
};
if !finished && !history.valid {
self.pending_reset = true;
}
if finished {
self.history.finish(history);
if generation == self.targets_generation {
self.pending_reset = false;
}
self.finished = Some(attempt);
self.shadows.local.finish_frame();
self.cull.finish_frame();
self.exposure.finish_frame();
self.statistics.submitted();
#[cfg(feature = "diagnostics")]
if let Some(probe) = &mut self.probe {
probe.submitted();
}
}
if let Some(post_fx) = &mut self.post_fx {
post_fx.settle(finished);
}
self.antialiasing.settle(finished);
self.sky.settle(finished);
self.reflections.settle(finished);
self.opaque.settle(finished);
self.traced_shadows.settle(finished);
}
}