#[cfg(any(test, feature = "diagnostics"))]
mod diagnostics;
pub(crate) mod effective;
pub(crate) mod frame;
pub(crate) mod probe_capture;
mod shared;
#[cfg(all(test, not(target_arch = "wasm32")))]
pub(crate) mod test_frame;
mod view;
#[cfg(all(test, feature = "diagnostics", not(target_arch = "wasm32")))]
mod diagnostics_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod floor_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod shader_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod size_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod view_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod volume_path_tests;
use crate::Scene;
use crate::scene::rays::acceleration::RayTracingStats;
use crate::settings::{DynamicGiQuality, Settings};
use crate::shading::bind::BindingTier;
use shared::Shared;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
pub use view::{View, ViewError, ViewFrame};
pub struct Renderer {
shared: Shared,
rendered: Option<(u64, Arc<AtomicBool>)>,
pub(crate) id: u64,
}
impl Renderer {
pub fn new(device: &wgpu::Device) -> Self {
Self {
shared: Shared::new(device),
rendered: None,
id: crate::scene::next_generation(),
}
}
pub fn render(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
scene: &mut Scene,
views: &mut [ViewFrame<'_>],
) {
if views.is_empty() {
return;
}
assert!(
views.iter().all(|frame| frame.view.renderer == self.id),
"every view rendered by a renderer is created from it (`View::new`)"
);
let finished = Arc::new(AtomicBool::new(false));
let attempt = frame::render(
&mut self.shared,
(device, queue, encoder),
scene,
views,
&finished,
);
self.rendered = Some((attempt, finished));
}
pub fn finish_frame(&mut self, scene: &mut Scene) {
let Some((attempt, _)) = self.rendered else {
return;
};
if scene.finish_frame(attempt) {
let Some((_, finished)) = self.rendered.take() else {
return;
};
if let Some(dynamic_gi) = &mut self.shared.dynamic_gi {
dynamic_gi.finish_frame();
}
finished.store(true, Ordering::Release);
}
}
pub fn binding_tier(&self) -> BindingTier {
self.shared.pipelines.tier
}
pub fn dynamic_gi_in_effect(&self, settings: &Settings, scene: &Scene) -> DynamicGiQuality {
effective::dynamic_gi(settings, self.binding_tier(), scene.ray_data())
}
pub fn world_space_reflections_in_effect(
&self,
settings: &Settings,
scene: &Scene,
) -> crate::settings::WorldSpaceReflections {
effective::world_space(
settings,
scene.ray_data(),
settings.screen_space_reflections != crate::settings::ScreenSpaceReflections::Off,
)
}
pub fn volume_paths_in_effect(&self, settings: &Settings) -> bool {
effective::volume_paths(settings, self.binding_tier())
}
pub fn ray_tracing_stats(&self) -> RayTracingStats {
self.shared.prepare.ray_tracing_stats()
}
pub fn ray_tracing_in_effect(&self, settings: &Settings, scene: &Scene) -> bool {
scene.ray_data() == crate::RayData::Enabled
&& settings.hardware_ray_tracing
&& self.shared.ray_form.is_some()
&& self.shared.prepare.ray_tracing_error().is_none()
}
pub fn ray_traced_shadows_in_effect(
&self,
settings: &Settings,
primary: &Settings,
scene: &Scene,
) -> bool {
settings.ray_traced_shadows && self.ray_tracing_in_effect(primary, scene)
}
pub fn ray_tracing_error(&self) -> Option<&str> {
let shared = &self.shared;
shared.prepare.ray_tracing_error().or_else(|| {
shared
.prepare
.hardware_requested()
.then(|| shared.ray_form.as_ref()?.failure())
.flatten()
})
}
}