bevy_debug_panel 0.18.2

show debug info to panel
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::collections::BTreeMap;
use std::time::Duration;

use bevy::prelude::*;

/// Debug Panel Plugin
/// show debug info by 'key: value'
pub struct DebugPanelPlugin;

impl Plugin for DebugPanelPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<DebugResource>();
        app.add_systems(Update, show_debug_info);
    }
}

/// Deubg Resource
#[derive(Debug, Resource)]
pub struct DebugResource {
    root_panel: Option<Entity>,
    map: BTreeMap<String, String>,
    timer: Timer,
    bg_color: Color,
    font_color: Color,
    font_size: f32,
    is_show: bool,
    z_index: i32,
}

impl Default for DebugResource {
    fn default() -> Self {
        Self {
            root_panel: None,
            map: BTreeMap::new(),
            timer: Timer::new(Duration::from_millis(500), TimerMode::Repeating),
            bg_color: Color::srgba(0.2, 0.2, 0.2, 0.9),
            font_color: Color::srgb(0.8, 0.8, 0.8),
            font_size: 20.,
            is_show: true,
            z_index: 10000,
        }
    }
}

impl DebugResource {
    /// insert debug info, key <-> value
    pub fn insert<T: Into<String>, U: Into<String>>(&mut self, k: T, v: U) {
        self.map.insert(k.into(), v.into());
    }

    /// remove debug info by key
    pub fn remove<T: Into<String>>(&mut self, k: T) -> Option<String> {
        self.map.remove(&k.into())
    }

    /// check is contain key
    pub fn contains_key<T: Into<String>>(&self, k: T) -> bool {
        self.map.contains_key(&k.into())
    }

    /// clear all debug info
    pub fn clear(&mut self) {
        self.map.clear();
    }

    /// set timer interval
    pub fn set_interval(&mut self, interval: Duration) {
        self.timer.set_duration(interval);
    }

    /// set background color
    pub fn set_bg_color(&mut self, bg_color: Color) {
        self.bg_color = bg_color;
    }

    /// set font color
    pub fn set_font_color(&mut self, font_color: Color) {
        self.font_color = font_color;
    }

    /// set font size
    pub fn set_font_size(&mut self, font_size: f32) {
        self.font_size = font_size;
    }

    /// set is show debug panel
    pub fn set_is_show(&mut self, is_show: bool) {
        self.is_show = is_show;
    }

    /// is show debug panel
    pub fn is_show(&self) -> bool {
        self.is_show
    }

    pub fn set_z_index(&mut self, z_index: i32) {
        self.z_index = z_index;
    }
}

fn show_debug_info(mut commands: Commands, mut debug_res: ResMut<DebugResource>, time: Res<Time>) {
    debug_res.timer.tick(time.delta());

    if debug_res.timer.just_finished() {
        // remove old root_panel
        if let Some(root_panel) = debug_res.root_panel {
            if let Ok(mut root_panel) = commands.get_entity(root_panel) {
                root_panel.despawn();
            }
        }

        if debug_res.is_show {
            // generate new root_panel
            let mut root_panel = commands.spawn((
                Node {
                    width: Val::Auto,
                    height: Val::Auto,
                    flex_direction: FlexDirection::Column,
                    ..default()
                },
                BackgroundColor(debug_res.bg_color),
                ZIndex(debug_res.z_index),
            ));
            debug_res.root_panel = Some(root_panel.id());

            // generate debug info
            for (k, v) in debug_res.map.iter() {
                root_panel.with_children(|p| {
                    p.spawn((
                        Text::new(format!("{}: {}", k, v)),
                        TextFont {
                            font_size: debug_res.font_size,
                            ..default()
                        },
                        TextColor(debug_res.font_color),
                    ));
                });
            }
        }
    }
}