Print diagnostics plugin

crates/bevy_diagnostic/src/diagnostics.rs

@@ -1,79 +0,0 @@
-use super::{Diagnostic, DiagnosticId, Diagnostics};
-use bevy_core::time::Time;
-use legion::prelude::*;
-use std::time::Duration;
-
-pub struct PrintDiagnosticsState {
-    elapsed: f64,
-    wait_seconds: f64,
-    filter: Option<Vec<DiagnosticId>>,
-}
-
-impl PrintDiagnosticsState {
-    pub fn new(wait: Duration) -> Self {
-        PrintDiagnosticsState {
-            elapsed: 0.,
-            wait_seconds: wait.as_secs_f64(),
-            filter: None,
-        }
-    }
-
-    pub fn new_filtered(wait: Duration, filter: Vec<DiagnosticId>) -> Self {
-        PrintDiagnosticsState {
-            elapsed: 0.,
-            wait_seconds: wait.as_secs_f64(),
-            filter: Some(filter),
-        }
-    }
-}
-
-fn print_diagnostic(diagnostic: &Diagnostic) {
-    if let Some(value) = diagnostic.value() {
-        print!("{:<20}: {:<19.6}", diagnostic.name, value);
-        if let Some(average) = diagnostic.average() {
-            print!("  (avg {:.6})", average);
-        }
-
-        println!("\n");
-    }
-}
-
-pub fn print_diagnostics_system(
-    mut state: ResourceMut<PrintDiagnosticsState>,
-    time: Resource<Time>,
-    diagnostics: Resource<Diagnostics>,
-) {
-    state.elapsed += time.delta_seconds_f64;
-    if state.elapsed >= state.wait_seconds {
-        state.elapsed = 0.0;
-        if let Some(ref filter) = state.filter {
-            for diagnostic in filter.iter().map(|id| diagnostics.get(*id).unwrap()) {
-                print_diagnostic(diagnostic);
-            }
-        } else {
-            for diagnostic in diagnostics.iter() {
-                print_diagnostic(diagnostic);
-            }
-        }
-    }
-}
-
-pub fn print_diagnostics_debug_system(
-    mut state: ResourceMut<PrintDiagnosticsState>,
-    time: Resource<Time>,
-    diagnostics: Resource<Diagnostics>,
-) {
-    state.elapsed += time.delta_seconds_f64;
-    if state.elapsed >= state.wait_seconds {
-        state.elapsed = 0.0;
-        if let Some(ref filter) = state.filter {
-            for diagnostic in filter.iter().map(|id| diagnostics.get(*id).unwrap()) {
-                println!("{:#?}\n", diagnostic);
-            }
-        } else {
-            for diagnostic in diagnostics.iter() {
-                println!("{:#?}\n", diagnostic);
-            }
-        }
-    }
-}

crates/bevy_diagnostic/src/lib.rs

@@ -1,40 +1,20 @@
 mod diagnostic;
-pub mod diagnostics;
+mod print_diagnostics_plugin;
 mod frame_time_diagnostics_plugin;
 pub use diagnostic::*;
+pub use diagnostic::*;
 pub use frame_time_diagnostics_plugin::FrameTimeDiagnosticsPlugin;
+pub use print_diagnostics_plugin::PrintDiagnosticsPlugin;
 
 use bevy_app::{AppBuilder, AppPlugin};
-use diagnostics::{print_diagnostics_system, PrintDiagnosticsState};
-use legion::prelude::IntoSystem;
-use std::time::Duration;
 
-pub struct PrintDiagnostics {
+pub struct PrintDiagnostics {}
-    pub wait_duration: Duration,
-    pub filter: Option<Vec<DiagnosticId>>,
-}
 
-pub struct DiagnosticsPlugin {
+#[derive(Default)]
-    pub print_diagnostics: Option<PrintDiagnostics>,
+pub struct DiagnosticsPlugin;
-}
-
-impl Default for DiagnosticsPlugin {
-    fn default() -> Self {
-        DiagnosticsPlugin {
-            print_diagnostics: Some(PrintDiagnostics {
-                wait_duration: Duration::from_secs_f64(1.0),
-                filter: None,
-            }),
-        }
-    }
-}
 
 impl AppPlugin for DiagnosticsPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.init_resource::<Diagnostics>();
-        if let Some(ref print_diagnostics) = self.print_diagnostics {
-            app.add_resource(PrintDiagnosticsState::new(print_diagnostics.wait_duration))
-                .add_system(print_diagnostics_system.system());
-        }
     }
 }

crates/bevy_diagnostic/src/print_diagnostics_plugin.rs

@@ -0,0 +1,110 @@
+use super::{Diagnostic, DiagnosticId, Diagnostics};
+use bevy_app::{stage, AppPlugin};
+use bevy_core::time::Time;
+use legion::prelude::*;
+use std::time::Duration;
+
+pub struct PrintDiagnosticsPlugin {
+    pub debug: bool,
+    pub wait_duration: Duration,
+    pub filter: Option<Vec<DiagnosticId>>,
+}
+
+pub struct PrintDiagnosticsState {
+    elapsed: f64,
+    wait_seconds: f64,
+    filter: Option<Vec<DiagnosticId>>,
+}
+
+impl Default for PrintDiagnosticsPlugin {
+    fn default() -> Self {
+        PrintDiagnosticsPlugin {
+            debug: false,
+            wait_duration: Duration::from_secs(1),
+            filter: None,
+        }
+    }
+}
+
+impl AppPlugin for PrintDiagnosticsPlugin {
+    fn build(&self, app: &mut bevy_app::AppBuilder) {
+        app.add_resource(PrintDiagnosticsState {
+            elapsed: 0.0,
+            wait_seconds: self.wait_duration.as_secs_f64(),
+            filter: self.filter.clone(),
+        });
+
+        if self.debug {
+            app.add_system_to_stage(
+                stage::POST_UPDATE,
+                Self::print_diagnostics_debug_system.system(),
+            );
+        } else {
+            app.add_system_to_stage(stage::POST_UPDATE, Self::print_diagnostics_system.system());
+        }
+    }
+}
+
+impl PrintDiagnosticsPlugin {
+    pub fn filtered(filter: Vec<DiagnosticId>) -> Self {
+        PrintDiagnosticsPlugin {
+            filter: Some(filter),
+            ..Default::default()
+        }
+    }
+
+    fn print_diagnostic(diagnostic: &Diagnostic) {
+        if let Some(value) = diagnostic.value() {
+            print!("{:<20}: {:<19.6}", diagnostic.name, value);
+            if let Some(average) = diagnostic.average() {
+                print!("  (avg {:.6})", average);
+            }
+
+            println!("\n");
+        }
+    }
+
+    pub fn print_diagnostics_system(
+        mut state: ResourceMut<PrintDiagnosticsState>,
+        time: Resource<Time>,
+        diagnostics: Resource<Diagnostics>,
+    ) {
+        state.elapsed += time.delta_seconds_f64;
+        if state.elapsed >= state.wait_seconds {
+            state.elapsed = 0.0;
+            println!("Diagnostics:");
+            println!("{}", "-".repeat(50));
+            if let Some(ref filter) = state.filter {
+                for diagnostic in filter.iter().map(|id| diagnostics.get(*id).unwrap()) {
+                    Self::print_diagnostic(diagnostic);
+                }
+            } else {
+                for diagnostic in diagnostics.iter() {
+                    Self::print_diagnostic(diagnostic);
+                }
+            }
+        }
+    }
+
+    pub fn print_diagnostics_debug_system(
+        mut state: ResourceMut<PrintDiagnosticsState>,
+        time: Resource<Time>,
+        diagnostics: Resource<Diagnostics>,
+    ) {
+        state.elapsed += time.delta_seconds_f64;
+        if state.elapsed >= state.wait_seconds {
+            state.elapsed = 0.0;
+            println!("Diagnostics (Debug):");
+            println!("{}", "-".repeat(30));
+            if let Some(ref filter) = state.filter {
+                for diagnostic in filter.iter().map(|id| diagnostics.get(*id).unwrap()) {
+                    println!("{:#?}\n", diagnostic);
+                }
+            } else {
+                for diagnostic in diagnostics.iter() {
+                    println!("{:#?}\n", diagnostic);
+                }
+            }
+        }
+    }
+}

crates/bevy_wgpu/src/diagnostic/mod.rs

@@ -1,2 +1,2 @@
-mod wgpu_resource;
+mod wgpu_resource_diagnostics_plugin;
-pub use wgpu_resource::WgpuResourceDiagnosticPlugin;
+pub use wgpu_resource_diagnostics_plugin::WgpuResourceDiagnosticsPlugin;

crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs

@@ -5,16 +5,16 @@ use bevy_render::renderer::GlobalRenderResourceContext;
 use legion::prelude::{IntoSystem, Resource, ResourceMut};
 
 #[derive(Default)]
-pub struct WgpuResourceDiagnosticPlugin;
+pub struct WgpuResourceDiagnosticsPlugin;
 
-impl AppPlugin for WgpuResourceDiagnosticPlugin {
+impl AppPlugin for WgpuResourceDiagnosticsPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_startup_system(Self::setup_system.system())
             .add_system(Self::diagnostic_system.system());
     }
 }
 
-impl WgpuResourceDiagnosticPlugin {
+impl WgpuResourceDiagnosticsPlugin {
     pub const WINDOW_SURFACES: DiagnosticId =
         DiagnosticId::from_u128(108237028251680341878766034324149135605);
 

examples/3d/spawner.rs

@@ -1,11 +1,14 @@
-use bevy::{diagnostic::FrameTimeDiagnosticsPlugin, prelude::*};
+use bevy::{
+    diagnostic::{FrameTimeDiagnosticsPlugin, PrintDiagnosticsPlugin},
+    prelude::*,
+};
 use rand::{rngs::StdRng, Rng, SeedableRng};
 
 fn main() {
     App::build()
         .add_default_plugins()
-        .add_plugin(DiagnosticsPlugin::default())
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(PrintDiagnosticsPlugin::default())
         .add_startup_system(setup)
         .add_system(move_system.system())
         .run();

src/add_default_plugins.rs

@@ -8,6 +8,9 @@ impl AddDefaultPlugins for AppBuilder {
     fn add_default_plugins(&mut self) -> &mut Self {
         #[cfg(feature = "core")]
         self.add_plugin(bevy_core::CorePlugin::default());
+        
+        #[cfg(feature = "diagnostic")]
+        self.add_plugin(bevy_diagnostic::DiagnosticsPlugin::default());
 
         #[cfg(feature = "input")]
         self.add_plugin(bevy_input::InputPlugin::default());