forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Print diagnostics plugin

Browse Source
This commit is contained in:
Carter Anderson 2020-05-04 13:42:49 -07:00
parent ea16f6fc56
commit 704a742661
7 changed files with 129 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
crates/bevy_diagnostic/src/diagnostics.rs
View File

@ -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);
}
}
}
}

32
crates/bevy_diagnostic/src/lib.rs
View File

@ -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 wait_duration: Duration,
pub filter: Option<Vec<DiagnosticId>>,
}
pub struct PrintDiagnostics {}
pub struct DiagnosticsPlugin {
pub print_diagnostics: Option<PrintDiagnostics>,
}
impl Default for DiagnosticsPlugin {
fn default() -> Self {
DiagnosticsPlugin {
print_diagnostics: Some(PrintDiagnostics {
wait_duration: Duration::from_secs_f64(1.0),
filter: None,
}),
}
}
}
#[derive(Default)]
pub struct DiagnosticsPlugin;
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());
}
}
}

110
crates/bevy_diagnostic/src/print_diagnostics_plugin.rs Normal file
View File

@ -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);
}
}
}
}
}

4
crates/bevy_wgpu/src/diagnostic/mod.rs
View File

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

6
crates/bevy_wgpu/src/diagnostic/wgpu_resource.rs → crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
View File

@ -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);

7
examples/3d/spawner.rs
View File

@ -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();

3
src/add_default_plugins.rs
View File

@ -9,6 +9,9 @@ impl AddDefaultPlugins for AppBuilder {
#[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());