Struct bevy::diagnostic::DiagnosticsStore

pub struct DiagnosticsStore { /* private fields */ }

A collection of Diagnostics.

Implementations

impl DiagnosticsStore

pub fn add(&mut self, diagnostic: Diagnostic)

Add a new Diagnostic.

If possible, prefer calling App::register_diagnostic.

pub fn get(&self, path: &DiagnosticPath) -> Option<&Diagnostic>

Examples found in repository

examples/ui/text.rs (line 137)

fn text_update_system(
    diagnostics: Res<DiagnosticsStore>,
    mut query: Query<&mut Text, With<FpsText>>,
) {
    for mut text in &mut query {
        if let Some(fps) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
            if let Some(value) = fps.smoothed() {
                // Update the value of the second section
                text.sections[1].value = format!("{value:.2}");
            }
        }
    }
}

examples/stress_tests/many_gizmos.rs (line 103)

fn ui_system(mut query: Query<&mut Text>, config: Res<Config>, diag: Res<DiagnosticsStore>) {
    let mut text = query.single_mut();

    let Some(fps) = diag
        .get(&FrameTimeDiagnosticsPlugin::FPS)
        .and_then(|fps| fps.smoothed())
    else {
        return;
    };

    text.sections[0].value = format!(
        "Line count: {}\n\
        FPS: {:.0}\n\n\
        Controls:\n\
        Up/Down: Raise or lower the line count.\n\
        Spacebar: Toggle fancy mode.",
        config.line_count, fps,
    );
}

examples/stress_tests/bevymark.rs (line 529)

fn counter_system(
    diagnostics: Res<DiagnosticsStore>,
    counter: Res<BevyCounter>,
    mut query: Query<&mut Text, With<StatsText>>,
) {
    let mut text = query.single_mut();

    if counter.is_changed() {
        text.sections[1].value = counter.count.to_string();
    }

    if let Some(fps) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
        if let Some(raw) = fps.value() {
            text.sections[3].value = format!("{raw:.2}");
        }
        if let Some(sma) = fps.average() {
            text.sections[5].value = format!("{sma:.2}");
        }
        if let Some(ema) = fps.smoothed() {
            text.sections[7].value = format!("{ema:.2}");
        }
    };
}

examples/ui/text_debug.rs (line 200)

fn change_text_system(
    time: Res<Time>,
    diagnostics: Res<DiagnosticsStore>,
    mut query: Query<&mut Text, With<TextChanges>>,
) {
    for mut text in &mut query {
        let mut fps = 0.0;
        if let Some(fps_diagnostic) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
            if let Some(fps_smoothed) = fps_diagnostic.smoothed() {
                fps = fps_smoothed;
            }
        }

        let mut frame_time = time.delta_seconds_f64();
        if let Some(frame_time_diagnostic) =
            diagnostics.get(&FrameTimeDiagnosticsPlugin::FRAME_TIME)
        {
            if let Some(frame_time_smoothed) = frame_time_diagnostic.smoothed() {
                frame_time = frame_time_smoothed;
            }
        }

        text.sections[0].value = format!(
            "This text changes in the bottom right - {fps:.1} fps, {frame_time:.3} ms/frame",
        );

        text.sections[2].value = format!("{fps:.1}");

        text.sections[4].value = format!("{frame_time:.3}");
    }
}

pub fn get_mut(&mut self, path: &DiagnosticPath) -> Option<&mut Diagnostic>

pub fn get_measurement( &self, path: &DiagnosticPath ) -> Option<&DiagnosticMeasurement>

Get the latest DiagnosticMeasurement from an enabled Diagnostic.

pub fn iter(&self) -> impl Iterator<Item = &Diagnostic>

Return an iterator over all Diagnostics.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Diagnostic>

Return an iterator over all Diagnostics, by mutable reference.

Trait Implementations

impl Debug for DiagnosticsStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for DiagnosticsStore

fn default() -> DiagnosticsStore

Returns the “default value” for a type.

impl Resource for DiagnosticsStore

where DiagnosticsStore: Send + Sync + 'static,