neser 0.1.0

NESER - NES Emulator in Rust - is a NES emulator written in Rust. It aims to be a high-quality, hardware-accurate emulator that is also easy to use and extend. It supports a wide range of NES games and features, including various mappers, audio processing, and input handling. NESER is designed to be modular and extensible, allowing developers to easily add new features or support for additional hardware. It can be run using one of two frontends: a native desktop application using SDL2, or a web application using WebAssembly. The desktop application provides a high-performance, feature-rich experience with support for various input devices and display options, while the web application allows users to play NES games directly in their browsers without needing to install any software in a BYOR manner (Bring Your Own Roms).
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]);
    }
}