From 01675a0475b56a903f8d351c850321eb1653e788 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Wed, 26 Jul 2023 18:22:57 +0200
Subject: [PATCH] many_cubes: Add stats overlay UI and make prepass and shadows
 toggleable

---
 examples/stress_tests/many_cubes.rs | 175 ++++++++++++++++++++++------
 1 file changed, 141 insertions(+), 34 deletions(-)

diff --git a/examples/stress_tests/many_cubes.rs b/examples/stress_tests/many_cubes.rs
index 41507dcd54bfa..b131053f06ee8 100644
--- a/examples/stress_tests/many_cubes.rs
+++ b/examples/stress_tests/many_cubes.rs
@@ -13,7 +13,8 @@
 use std::f64::consts::PI;
 
 use bevy::{
-    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    core_pipeline::prepass::DepthPrepass,
+    diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin},
     math::{DVec2, DVec3},
     pbr::NotShadowCaster,
     prelude::*,
@@ -32,10 +33,9 @@ fn main() {
                 ..default()
             }),
             FrameTimeDiagnosticsPlugin,
-            LogDiagnosticsPlugin::default(),
         ))
         .add_systems(Startup, setup)
-        .add_systems(Update, (toggle_shadows, move_camera, print_mesh_count))
+        .add_systems(Update, (move_camera, update_state))
         .run();
 }
 
@@ -54,6 +54,9 @@ fn setup(
         ..default()
     });
 
+    // Initialized below
+    let camera_entity;
+
     match std::env::args().nth(1).as_deref() {
         Some("cube") => {
             // NOTE: This pattern is good for demonstrating that frustum culling is working correctly
@@ -96,10 +99,12 @@ fn setup(
                 }
             }
             // camera
-            commands.spawn(Camera3dBundle {
-                transform: Transform::from_xyz(WIDTH as f32, HEIGHT as f32, WIDTH as f32),
-                ..default()
-            });
+            camera_entity = commands
+                .spawn(Camera3dBundle {
+                    transform: Transform::from_xyz(WIDTH as f32, HEIGHT as f32, WIDTH as f32),
+                    ..default()
+                })
+                .id();
         }
         _ => {
             // NOTE: This pattern is good for testing performance of culling as it provides roughly
@@ -121,10 +126,15 @@ fn setup(
             }
 
             // camera
-            commands.spawn(Camera3dBundle::default());
+            camera_entity = commands.spawn(Camera3dBundle::default()).id();
         }
     }
 
+    let depth_prepass_enabled = std::env::args().nth(2).as_deref() == Some("prepass-enabled");
+    if depth_prepass_enabled {
+        commands.entity(camera_entity).insert(DepthPrepass);
+    }
+
     commands.spawn((
         PbrBundle {
             mesh: mesh.clone_weak(),
@@ -157,7 +167,73 @@ fn setup(
         ..default()
     });
 
-    commands.spawn(DirectionalLightBundle { ..default() });
+    let directional_light_shadows_enabled =
+        std::env::args().nth(3).as_deref() == Some("shadows-enabled");
+    commands.spawn(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            shadows_enabled: directional_light_shadows_enabled,
+            ..default()
+        },
+        ..default()
+    });
+
+    let style = TextStyle {
+        font_size: 32.0,
+        ..default()
+    };
+    commands.spawn((
+        TextBundle::from_sections([
+            TextSection::new(depth_prepass_string(depth_prepass_enabled), style.clone()),
+            TextSection::new(
+                directional_light_shadows_string(directional_light_shadows_enabled),
+                style.clone(),
+            ),
+            TextSection::new(mesh_stats_string(0, 0), style.clone()),
+            TextSection::new(frame_stats_string(0.0, 0.0), style),
+        ]),
+        UiState,
+    ));
+}
+
+#[derive(Component)]
+struct UiState;
+
+fn toggle_state_string(v: bool) -> &'static str {
+    if v {
+        "enabled"
+    } else {
+        "disabled"
+    }
+}
+
+fn depth_prepass_string(depth_prepass_enabled: bool) -> String {
+    format!(
+        "Depth prepass: {}               (toggle by pressing 'p')\n",
+        toggle_state_string(depth_prepass_enabled)
+    )
+}
+
+fn directional_light_shadows_string(directional_light_shadows_enabled: bool) -> String {
+    format!(
+        "Directional light shadows: {}   (toggle by pressing 's')\n",
+        toggle_state_string(directional_light_shadows_enabled)
+    )
+}
+
+fn mesh_stats_string(total_meshes: usize, visible_meshes: usize) -> String {
+    format!(
+        "Meshes: {}\nVisible Meshes {} ({:5.1}%)\n",
+        total_meshes,
+        visible_meshes,
+        100.0 * (visible_meshes as f32 / total_meshes as f32),
+    )
+}
+
+fn frame_stats_string(fps: f32, frame_time_ms: f32) -> String {
+    format!(
+        "Frame rate: {:>6.1} fps\nFrame time: {:>6.3} ms\n",
+        fps, frame_time_ms
+    )
 }
 
 // NOTE: This epsilon value is apparently optimal for optimizing for the average
@@ -187,36 +263,67 @@ fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Cam
     camera_transform.rotate_x(delta);
 }
 
-// System for printing the number of meshes on every tick of the timer
-fn print_mesh_count(
-    time: Res<Time>,
-    mut timer: Local<PrintingTimer>,
-    sprites: Query<(&Handle<Mesh>, &ComputedVisibility)>,
+fn update_state(
+    mut commands: Commands,
+    keys: Res<Input<KeyCode>>,
+    mut directional_lights: Query<&mut DirectionalLight>,
+    cameras_no_prepass: Query<Entity, (With<Camera>, Without<DepthPrepass>)>,
+    cameras_prepass: Query<Entity, (With<Camera>, With<DepthPrepass>)>,
+    diagnostics: Res<DiagnosticsStore>,
+    mut query: Query<&mut Text, With<UiState>>,
+    meshes: Query<(&Handle<Mesh>, &ComputedVisibility)>,
 ) {
-    timer.tick(time.delta());
-
-    if timer.just_finished() {
-        info!(
-            "Meshes: {} - Visible Meshes {}",
-            sprites.iter().len(),
-            sprites.iter().filter(|(_, cv)| cv.is_visible()).count(),
-        );
+    // Update directional light shadow state
+    let mut shadows_string = None;
+    if keys.just_pressed(KeyCode::S) {
+        let mut directional_light_shadows_enabled = false;
+        for mut light in &mut directional_lights {
+            light.shadows_enabled = !light.shadows_enabled;
+            directional_light_shadows_enabled = light.shadows_enabled;
+        }
+        shadows_string = Some(directional_light_shadows_string(
+            directional_light_shadows_enabled,
+        ));
     }
-}
-
-#[derive(Deref, DerefMut)]
-struct PrintingTimer(Timer);
 
-impl Default for PrintingTimer {
-    fn default() -> Self {
-        Self(Timer::from_seconds(1.0, TimerMode::Repeating))
+    // Update depth prepass state
+    let mut prepass_string = None;
+    if keys.just_pressed(KeyCode::P) {
+        let mut depth_prepass_enabled = false;
+        for entity in &cameras_no_prepass {
+            commands.entity(entity).insert(DepthPrepass);
+            depth_prepass_enabled = true;
+        }
+        for entity in &cameras_prepass {
+            commands.entity(entity).remove::<DepthPrepass>();
+            depth_prepass_enabled = false;
+        }
+        prepass_string = Some(depth_prepass_string(depth_prepass_enabled));
     }
-}
 
-fn toggle_shadows(keys: Res<Input<KeyCode>>, mut directional_lights: Query<&mut DirectionalLight>) {
-    if keys.just_pressed(KeyCode::S) {
-        for mut light in &mut directional_lights {
-            light.shadows_enabled = !light.shadows_enabled;
+    // Update the UI
+    let fps = diagnostics
+        .get(FrameTimeDiagnosticsPlugin::FPS)
+        .and_then(|fps| fps.smoothed())
+        .unwrap_or_default() as f32;
+    let frame_time_ms = diagnostics
+        .get(FrameTimeDiagnosticsPlugin::FRAME_TIME)
+        .and_then(|frame_time_ms| frame_time_ms.smoothed())
+        .unwrap_or_default() as f32;
+    let frame_stats_string = frame_stats_string(fps, frame_time_ms);
+
+    let total_meshes = meshes.iter().len();
+    let visible_meshes = meshes.iter().filter(|(_, cv)| cv.is_visible()).count();
+    let mesh_stats_string = mesh_stats_string(total_meshes, visible_meshes);
+
+    for mut text in &mut query {
+        if let Some(shadows_string) = shadows_string.as_ref() {
+            text.sections[0].value = shadows_string.clone();
+        }
+        if let Some(prepass_string) = prepass_string.as_ref() {
+            text.sections[1].value = prepass_string.clone();
         }
+        text.sections[2].value = mesh_stats_string.clone();
+        text.sections[3].value = frame_stats_string.clone();
     }
 }