neser 0.3.1

NESER - NES Emulator in Rust. Desktop (SDL) and WebAssembly frontends.
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

use imgui::Io;
use imgui::Key;

/// Mouse buttons relevant to the renderer input layer.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MouseButton {
    Left,
    Right,
    Middle,
}

/// Input events forwarded to the renderer (backend-agnostic).
#[derive(Debug, Clone, PartialEq)]
pub enum InputEvent {
    /// Mouse movement in window coordinates.
    MouseMotion { x: f32, y: f32 },
    /// Mouse button press/release.
    MouseButton { button: MouseButton, pressed: bool },
    /// Mouse wheel scroll delta.
    MouseWheel { x: f32, y: f32 },
    /// Text input for ImGui.
    TextInput(String),
    /// Key press/release events routed to ImGui.
    Key { key: Key, down: bool },
}

/// Applies a single input event to the ImGui IO state.
pub fn apply_input(io: &mut Io, event: &InputEvent) {
    match event {
        InputEvent::MouseMotion { x, y } => {
            io.mouse_pos = [*x, *y];
        }
        InputEvent::MouseButton { button, pressed } => {
            let index = match button {
                MouseButton::Left => 0,
                MouseButton::Right => 1,
                MouseButton::Middle => 2,
            };
            io.mouse_down[index] = *pressed;
        }
        InputEvent::MouseWheel { x, y } => {
            io.mouse_wheel_h += *x;
            io.mouse_wheel += *y;
        }
        InputEvent::TextInput(text) => {
            for ch in text.chars() {
                io.add_input_character(ch);
            }
        }
        InputEvent::Key { key, down } => {
            io.add_key_event(*key, *down);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serial_test::serial;

    #[serial]
    #[test]
    fn apply_input_sets_mouse_position() {
        let mut imgui = imgui::Context::create();
        imgui.set_ini_filename(None);
        let io = imgui.io_mut();
        apply_input(io, &InputEvent::MouseMotion { x: 10.0, y: 20.0 });
        assert_eq!(io.mouse_pos, [10.0, 20.0]);
    }

    #[serial]
    #[test]
    fn apply_input_sets_mouse_button_down() {
        let mut imgui = imgui::Context::create();
        imgui.set_ini_filename(None);
        let io = imgui.io_mut();
        apply_input(
            io,
            &InputEvent::MouseButton {
                button: MouseButton::Left,
                pressed: true,
            },
        );
        assert!(io.mouse_down[0]);
    }

    #[serial]
    #[test]
    fn apply_input_updates_mouse_wheel() {
        let mut imgui = imgui::Context::create();
        imgui.set_ini_filename(None);
        let io = imgui.io_mut();
        apply_input(io, &InputEvent::MouseWheel { x: 1.0, y: -2.0 });
        assert_eq!(io.mouse_wheel_h, 1.0);
        assert_eq!(io.mouse_wheel, -2.0);
    }

    #[serial]
    #[test]
    fn apply_input_sets_key_state() {
        let mut imgui = imgui::Context::create();
        imgui.set_ini_filename(None);
        let io = imgui.io_mut();
        apply_input(
            io,
            &InputEvent::Key {
                key: Key::Space,
                down: true,
            },
        );
        let io = imgui.io_mut();
        io.display_size = [1.0, 1.0];
        io.delta_time = 1.0 / 60.0;
        let _ = imgui.fonts().build_rgba32_texture();
        imgui.frame();
        assert!(imgui.io().keys_down[Key::Space as usize]);
    }
}