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

use super::*;

mod console;
mod fps_counter;

use console::*;
use fps_counter::*;

struct Data {
    fps_counter: FpsCounter,
    console: Console,
}

impl Data {
    fn new(geng: &Rc<Geng>) -> Self {
        Self {
            fps_counter: FpsCounter::new(geng),
            console: Console::new(geng),
        }
    }
    fn before_draw(&mut self) {
        self.fps_counter.before_draw();
        self.console.before_draw();
    }
    fn ui(&mut self) -> impl ui::Widget + '_ {
        use ui::*;
        ui::column![
            self.fps_counter.ui().align(vec2(0.0, 1.0)),
            self.console.ui(),
        ]
    }
}

pub struct DebugOverlay {
    ui_controller: ui::Controller,
    data: Data,
    state: Box<dyn State>,
    enabled: bool,
}

impl DebugOverlay {
    pub fn new(geng: &Rc<Geng>, state: impl State) -> Self {
        Self {
            ui_controller: ui::Controller::new(),
            data: Data::new(geng),
            state: Box::new(state),
            enabled: false,
        }
    }
}

impl State for DebugOverlay {
    fn update(&mut self, delta_time: f64) {
        if self.enabled {
            self.ui_controller.update(&mut self.data.ui(), delta_time);
        }
        self.state.update(delta_time);
    }
    fn draw(&mut self, framebuffer: &mut ugli::Framebuffer) {
        self.state.draw(framebuffer);
        if self.enabled {
            self.data.before_draw();
            self.ui_controller.draw(&mut self.data.ui(), framebuffer);
        }
    }
    fn handle_event(&mut self, event: Event) {
        if let Event::KeyDown { key: Key::F3 } = event {
            self.enabled = !self.enabled;
        }
        if !self.enabled
            || !self
                .ui_controller
                .handle_event(&mut self.data.ui(), event.clone())
        {
            self.state.handle_event(event);
        }
    }
    fn transition(&mut self) -> Option<Transition> {
        match self.state.transition() {
            Some(Transition::Pop) => Some(Transition::Pop),
            None => None,
            _ => unreachable!(),
        }
    }
}