#[cfg(feature = "diagnostics")]
use super::Renderer;
use super::{View, frame};
#[cfg(feature = "diagnostics")]
use crate::{ModelId, Scene, SceneError};
impl View {
pub fn diagnostic_target(
&self,
target: crate::diagnostics::DiagnosticTarget,
) -> Option<&wgpu::TextureView> {
use crate::diagnostics::DiagnosticTarget;
let targets = &self.targets;
Some(match target {
DiagnosticTarget::Depth => &targets.depth,
DiagnosticTarget::Normal => &targets.normal,
DiagnosticTarget::Motion => &targets.motion,
DiagnosticTarget::SourceId => &targets.source_id,
DiagnosticTarget::Composite => &targets.composite,
DiagnosticTarget::AmbientOcclusion => return self.opaque.visibility(),
DiagnosticTarget::ToneMapped => return self.post.captured_tone_mapped(),
DiagnosticTarget::Exposure => self.exposure.view(),
DiagnosticTarget::Antialiased => {
frame::completed(self.completed?, &self.post_fx, &self.antialiasing, targets)
}
})
}
pub fn diagnostic_draws(&self) -> crate::diagnostics::ViewDraws {
let views = &self.views;
crate::diagnostics::ViewDraws {
camera: views.camera.list.draws(),
blended: views.blended.draws(),
cascades: views.cascades[..views.cascade_count]
.iter()
.map(|cascade| cascade.list.draws())
.collect(),
}
}
#[cfg(feature = "diagnostics")]
pub fn diagnostic_view_times(&self) -> crate::diagnostics::ViewTimes {
let views = &self.views;
crate::diagnostics::ViewTimes {
camera: views.camera.cpu_ms(),
cascades: views.cascades[..views.cascade_count]
.iter()
.map(crate::view::ViewSlot::cpu_ms)
.collect(),
}
}
#[cfg(feature = "diagnostics")]
pub fn geometry_stats_by_model(
&mut self,
device: &wgpu::Device,
) -> Option<crate::diagnostics::ModelGeometryStats<'_>> {
self.settle(false);
self.statistics.poll(device);
self.statistics
.latest_by_model()
.map(|by_model| crate::diagnostics::ModelGeometryStats { by_model })
}
#[cfg(feature = "diagnostics")]
pub fn geometry_stats_for_model(
&mut self,
device: &wgpu::Device,
scene: &Scene,
model: ModelId,
) -> Result<Option<(usize, u64)>, SceneError> {
scene.models.get(model)?;
Ok(self
.geometry_stats_by_model(device)
.map(|report| report.for_model(model)))
}
#[cfg(feature = "diagnostics")]
pub fn take_frame_probe_reports(&mut self, device: &wgpu::Device) -> Vec<serde_json::Value> {
self.settle(false);
self.probe
.as_mut()
.map_or_else(Vec::new, |probe| probe.take_reports(device))
}
}
#[cfg(feature = "diagnostics")]
impl Renderer {
pub fn take_dynamic_gi_reports(
&mut self,
device: &wgpu::Device,
) -> Vec<crate::diagnostics::DynamicGiReport> {
self.shared
.dynamic_gi
.as_mut()
.map_or_else(Vec::new, |dynamic_gi| dynamic_gi.take_reports(device))
}
}
#[cfg(all(test, feature = "diagnostics", not(target_arch = "wasm32")))]
mod tests {
use crate::{
Camera, FrameInput, InstanceState, Mobility, Scene, TestRenderer,
glam::{Mat4, Vec3},
settings::{RenderPreset, Settings},
test_support,
};
#[test]
fn model_geometry_snapshot_follows_the_completed_camera_view() {
let Some((device, queue)) = test_support::device() else {
return;
};
let size = [16, 16];
let format = crate::shading::gbuffer::COLOR;
let settings = Settings {
preset: RenderPreset::Low,
..Settings::default()
};
let output = crate::view::targets::target(&device, "geometry snapshot", size, format);
let mut scene = Scene::new(&device, &queue);
let mut renderer = TestRenderer::new(&device, &queue, format, size, 1., &settings).unwrap();
let positions = [-3., 3.].map(|x| Vec3::new(x, 0., 0.));
let models = positions.map(|position| {
let model = scene
.add_asset(&device, &queue, test_support::cube())
.unwrap()
.model;
let mut instance = InstanceState::new(model);
instance.pose = Mat4::from_translation(position);
scene
.add_instance(&device, &queue, instance, Mobility::Static)
.unwrap();
model
});
assert!(renderer.view.geometry_stats_by_model(&device).is_none());
for (visible, position) in positions.into_iter().enumerate() {
let eye = position + Vec3::Z * 3.;
let input = FrameInput::new(Camera {
eye,
view: crate::glam::camera::rh::view::look_at_mat4(eye, position, Vec3::Y),
projection: crate::perspective(0.8, 1., 0.1),
});
let mut encoder = device.create_command_encoder(&Default::default());
renderer.render(
&device,
&queue,
&mut encoder,
&mut scene,
&input,
&settings,
&output,
None,
);
queue.submit([encoder.finish()]);
renderer.finish_frame(&mut scene);
renderer.view.geometry_stats_by_model(&device);
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let report = renderer.view.geometry_stats_by_model(&device).unwrap();
assert_eq!(report.for_model(models[visible]).1, 12);
assert_eq!(report.for_model(models[1 - visible]), (0, 0));
}
}
}