repose-devtools 0.14.1

Repose developer tools for debugging.
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

use std::sync::Arc;

use web_time::Instant;

use repose_core::{Color, Rect, Scene, SceneNode};

pub struct Hud {
    pub inspector_enabled: bool,
    pub hovered: Option<Rect>,
    frame_count: u64,
    last_frame: Option<Instant>,
    fps_smooth: f32,
    pub metrics: Option<Metrics>,
}

impl Default for Hud {
    fn default() -> Self {
        Self::new()
    }
}

impl Hud {
    pub fn new() -> Self {
        Self {
            inspector_enabled: false,
            hovered: None,
            frame_count: 0,
            last_frame: None,
            fps_smooth: 0.0,
            metrics: None,
        }
    }
    pub fn toggle_inspector(&mut self) {
        self.inspector_enabled = !self.inspector_enabled;
    }
    pub fn set_hovered(&mut self, r: Option<Rect>) {
        self.hovered = r;
    }

    pub fn overlay(&mut self, scene: &mut Scene) {
        self.frame_count += 1;
        // FPS
        let now = Instant::now();
        if let Some(prev) = self.last_frame.replace(now) {
            let dt = (now - prev).as_secs_f32();
            if dt > 0.0 {
                let fps = 1.0 / dt;
                // simple EMA
                let a = 0.2;
                self.fps_smooth = if self.fps_smooth == 0.0 {
                    fps
                } else {
                    (1.0 - a) * self.fps_smooth + a * fps
                };
            }
        }
        let mut lines = vec![
            format!("frame: {}", self.frame_count),
            format!("fps: {:.1}", self.fps_smooth),
        ];
        if let Some(m) = &self.metrics {
            lines.push(format!("build+layout: {:.2} ms", m.build_layout_ms));
            lines.push(format!("nodes: {}", m.scene_nodes));
        }
        let text = lines.join("  |  ");
        scene.nodes.push(SceneNode::Text {
            rect: Rect {
                x: 8.0,
                y: 8.0,
                w: 200.0,
                h: 16.0,
            },
            text: Arc::<str>::from(text),
            color: Color::from_hex("#AAAAAA"),
            size: 14.0,
        });

        if let Some(r) = self.hovered {
            scene.nodes.push(SceneNode::Border {
                rect: r,
                color: Color::from_hex("#44AAFF"),
                width: 2.0,
                radius: 0.0,
            });
        }
    }
}

#[derive(Clone, Debug, Default)]
pub struct Metrics {
    pub build_layout_ms: f32,
    pub scene_nodes: usize,
}

pub struct Inspector {
    pub hud: Hud,
}
impl Default for Inspector {
    fn default() -> Self {
        Self::new()
    }
}

impl Inspector {
    pub fn new() -> Self {
        Self { hud: Hud::new() }
    }
    pub fn frame(&mut self, scene: &mut Scene) {
        if self.hud.inspector_enabled {
            self.hud.overlay(scene);
        }
    }
}