From 8dc9daaafd3ad3b7242b3042d3caab032717b7b7 Mon Sep 17 00:00:00 2001
From: jsgroth <1137683+jsgroth@users.noreply.github.com>
Date: Fri, 27 Dec 2024 14:58:03 -0600
Subject: [PATCH] assorted cleanup of input-related code and EmulatorTrait

* replace the `define_controller_inputs` proc macro with a declarative macro
* move the MappableInputs<Button> trait from jgenesis-native-driver to jgenesis-common, and implement it in the backend cores
* add a Button associated type to EmulatorTrait, and add necessary trait bounds for InputMapper to EmulatorTrait::Button and EmulatorTrait::Inputs
* change NativeEmulator to only have a single generic type parameter Emulator, with a struct-level trait bound Emulator: EmulatorTrait
* remove now-unnecessary generic type parameters and trait bounds in a few places
---
 backend/gb-core/src/api.rs                    |   3 +-
 backend/gb-core/src/inputs.rs                 |  32 +-
 backend/genesis-core/src/api.rs               |   3 +-
 backend/genesis-core/src/input.rs             |  47 ++-
 backend/nes-core/src/api.rs                   |   3 +-
 backend/nes-core/src/input.rs                 |  63 ++--
 backend/s32x-core/src/api.rs                  |   3 +-
 backend/segacd-core/src/api.rs                |   3 +-
 backend/smsgg-core/src/api.rs                 |   3 +-
 backend/smsgg-core/src/input.rs               |  39 ++-
 backend/snes-core/src/api.rs                  |   3 +-
 backend/snes-core/src/input.rs                |  77 +++--
 common/jgenesis-common/src/frontend.rs        |  29 +-
 common/jgenesis-common/src/input.rs           | 166 ++++++++++
 common/jgenesis-proc-macros/src/inputs.rs     | 288 ------------------
 common/jgenesis-proc-macros/src/lib.rs        |  75 -----
 common/jgenesis-proc-macros/tests/inputs.rs   |  64 ----
 common/jgenesis-proc-macros/tests/lib.rs      |   1 -
 frontend/jgenesis-cli/src/main.rs             |  11 +-
 frontend/jgenesis-native-driver/src/input.rs  | 130 +-------
 .../jgenesis-native-driver/src/mainloop.rs    |  24 +-
 .../jgenesis-native-driver/src/mainloop/gb.rs |   7 +-
 .../src/mainloop/genesis.rs                   |  16 +-
 .../src/mainloop/nes.rs                       |   6 +-
 .../src/mainloop/smsgg.rs                     |   5 +-
 .../src/mainloop/snes.rs                      |   7 +-
 frontend/jgenesis-renderer/src/renderer.rs    |  13 +-
 27 files changed, 387 insertions(+), 734 deletions(-)
 delete mode 100644 common/jgenesis-proc-macros/src/inputs.rs
 delete mode 100644 common/jgenesis-proc-macros/tests/inputs.rs

diff --git a/backend/gb-core/src/api.rs b/backend/gb-core/src/api.rs
index 32b7d285..0066559e 100644
--- a/backend/gb-core/src/api.rs
+++ b/backend/gb-core/src/api.rs
@@ -5,7 +5,7 @@ use crate::bus::Bus;
 use crate::cartridge::{Cartridge, SoftwareType};
 use crate::dma::DmaUnit;
 use crate::graphics::RgbaFrameBuffer;
-use crate::inputs::{GameBoyInputs, InputState};
+use crate::inputs::{GameBoyButton, GameBoyInputs, InputState};
 use crate::interrupts::InterruptRegisters;
 use crate::memory::Memory;
 use crate::ppu::Ppu;
@@ -186,6 +186,7 @@ impl GameBoyEmulator {
 }
 
 impl EmulatorTrait for GameBoyEmulator {
+    type Button = GameBoyButton;
     type Inputs = GameBoyInputs;
     type Config = GameBoyEmulatorConfig;
     type Err<
diff --git a/backend/gb-core/src/inputs.rs b/backend/gb-core/src/inputs.rs
index 86af6f37..8c0eb088 100644
--- a/backend/gb-core/src/inputs.rs
+++ b/backend/gb-core/src/inputs.rs
@@ -3,23 +3,29 @@
 use crate::interrupts::InterruptRegisters;
 use crate::sm83::InterruptType;
 use bincode::{Decode, Encode};
+use jgenesis_common::define_controller_inputs;
+use jgenesis_common::frontend::MappableInputs;
+use jgenesis_common::input::Player;
 use jgenesis_common::num::GetBit;
-use jgenesis_proc_macros::define_controller_inputs;
 
 define_controller_inputs! {
-    enum GameBoyButton {
-        Up,
-        Left,
-        Right,
-        Down,
-        A,
-        B,
-        Start,
-        Select,
-    }
+    buttons: GameBoyButton {
+        Up -> up,
+        Left -> left,
+        Right -> right,
+        Down -> down,
+        A -> a,
+        B -> b,
+        Start -> start,
+        Select -> select,
+    },
+    joypad: GameBoyInputs,
+}
 
-    struct GameBoyInputs {
-        buttons!
+impl MappableInputs<GameBoyButton> for GameBoyInputs {
+    #[inline]
+    fn set_field(&mut self, button: GameBoyButton, _player: Player, pressed: bool) {
+        self.set_button(button, pressed);
     }
 }
 
diff --git a/backend/genesis-core/src/api.rs b/backend/genesis-core/src/api.rs
index 180a8a36..f1a94333 100644
--- a/backend/genesis-core/src/api.rs
+++ b/backend/genesis-core/src/api.rs
@@ -1,7 +1,7 @@
 //! Genesis public interface and main loop
 
 use crate::audio::{GenesisAudioResampler, LowPassFilter};
-use crate::input::{GenesisInputs, InputState};
+use crate::input::{GenesisButton, GenesisInputs, InputState};
 use crate::memory::{Cartridge, MainBus, MainBusSignals, MainBusWrites, Memory};
 use crate::timing::{CycleCounters, GenesisCycleCounters};
 use crate::vdp::{TimingModeExt, Vdp, VdpConfig, VdpTickEffect};
@@ -335,6 +335,7 @@ pub fn render_frame<R: Renderer>(
 }
 
 impl EmulatorTrait for GenesisEmulator {
+    type Button = GenesisButton;
     type Inputs = GenesisInputs;
     type Config = GenesisEmulatorConfig;
 
diff --git a/backend/genesis-core/src/input.rs b/backend/genesis-core/src/input.rs
index 43ed78dc..fbc3949e 100644
--- a/backend/genesis-core/src/input.rs
+++ b/backend/genesis-core/src/input.rs
@@ -2,33 +2,32 @@
 
 use crate::GenesisEmulatorConfig;
 use bincode::{Decode, Encode};
+use jgenesis_common::define_controller_inputs;
 use jgenesis_common::num::GetBit;
-use jgenesis_proc_macros::{EnumAll, EnumDisplay, define_controller_inputs};
+use jgenesis_proc_macros::{EnumAll, EnumDisplay};
 
 define_controller_inputs! {
-    enum GenesisButton {
-        Up,
-        Left,
-        Right,
-        Down,
-        A,
-        B,
-        C,
-        X,
-        Y,
-        Z,
-        Start,
-        Mode,
-    }
-
-    struct GenesisJoypadState {
-        buttons!
-    }
-
-    struct GenesisInputs {
-        p1: Player::One,
-        p2: Player::Two,
-    }
+    buttons: GenesisButton {
+        Up -> up,
+        Left -> left,
+        Right -> right,
+        Down -> down,
+        A -> a,
+        B -> b,
+        C -> c,
+        X -> x,
+        Y -> y,
+        Z -> z,
+        Start -> start,
+        Mode -> mode,
+    },
+    joypad: GenesisJoypadState,
+    inputs: GenesisInputs {
+        players: {
+            p1: Player::One,
+            p2: Player::Two,
+        },
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Encode, Decode, EnumDisplay, EnumAll)]
diff --git a/backend/nes-core/src/api.rs b/backend/nes-core/src/api.rs
index e2c25fa4..ac5a7529 100644
--- a/backend/nes-core/src/api.rs
+++ b/backend/nes-core/src/api.rs
@@ -4,7 +4,7 @@ use crate::bus::cartridge::CartridgeFileError;
 use crate::bus::{Bus, cartridge};
 use crate::cpu::CpuState;
 use crate::graphics::TimingModeGraphicsExt;
-use crate::input::NesInputs;
+use crate::input::{NesButton, NesInputs};
 use crate::ppu::PpuState;
 use crate::{apu, audio, cpu, graphics, ppu};
 use bincode::{Decode, Encode};
@@ -277,6 +277,7 @@ fn new_rgba_frame_buffer() -> Vec<Color> {
 }
 
 impl EmulatorTrait for NesEmulator {
+    type Button = NesButton;
     type Inputs = NesInputs;
     type Config = NesEmulatorConfig;
     type Err<
diff --git a/backend/nes-core/src/input.rs b/backend/nes-core/src/input.rs
index 2390fd7e..443d955b 100644
--- a/backend/nes-core/src/input.rs
+++ b/backend/nes-core/src/input.rs
@@ -1,26 +1,21 @@
 use bincode::{Decode, Encode};
+use jgenesis_common::define_controller_inputs;
+use jgenesis_common::frontend::{DisplayArea, FrameSize, MappableInputs};
 use jgenesis_common::input::Player;
-use jgenesis_proc_macros::define_controller_inputs;
 
 define_controller_inputs! {
-    enum NesButton {
-        Up,
-        Left,
-        Right,
-        Down,
-        A,
-        B,
-        Start,
-        Select,
-        #[on_console]
-        ZapperFire,
-        #[on_console]
-        ZapperForceOffscreen,
-    }
-
-    struct NesJoypadState {
-        buttons!
-    }
+    buttons: NesButton {
+        Up -> up,
+        Left -> left,
+        Right -> right,
+        Down -> down,
+        A -> a,
+        B -> b,
+        Start -> start,
+        Select -> select,
+    },
+    non_gamepad_buttons: [ZapperFire, ZapperForceOffscreen],
+    joypad: NesJoypadState,
 }
 
 impl NesButton {
@@ -100,9 +95,9 @@ pub struct NesInputs {
     pub p2: NesInputDevice,
 }
 
-impl NesInputs {
+impl MappableInputs<NesButton> for NesInputs {
     #[inline]
-    pub fn set_button(&mut self, button: NesButton, player: Player, pressed: bool) {
+    fn set_field(&mut self, button: NesButton, player: Player, pressed: bool) {
         match (button, player) {
             (NesButton::ZapperFire | NesButton::ZapperForceOffscreen, _) => {
                 if let NesInputDevice::Zapper(zapper_state) = &mut self.p2 {
@@ -121,6 +116,32 @@ impl NesInputs {
             }
         }
     }
+
+    #[inline]
+    fn handle_mouse_motion(
+        &mut self,
+        x: i32,
+        y: i32,
+        frame_size: FrameSize,
+        display_area: DisplayArea,
+    ) {
+        if let NesInputDevice::Zapper(zapper_state) = &mut self.p2 {
+            zapper_state.position = jgenesis_common::input::viewport_position_to_frame_position(
+                x,
+                y,
+                frame_size,
+                display_area,
+            );
+            log::debug!("Set Zapper position to {:?}", zapper_state.position);
+        }
+    }
+
+    #[inline]
+    fn handle_mouse_leave(&mut self) {
+        if let NesInputDevice::Zapper(zapper_state) = &mut self.p2 {
+            zapper_state.position = None;
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, Encode, Decode)]
diff --git a/backend/s32x-core/src/api.rs b/backend/s32x-core/src/api.rs
index 8685ed2b..dca5f264 100644
--- a/backend/s32x-core/src/api.rs
+++ b/backend/s32x-core/src/api.rs
@@ -5,7 +5,7 @@
 use crate::audio::Sega32XResampler;
 use crate::core::Sega32X;
 use bincode::{Decode, Encode};
-use genesis_core::input::InputState;
+use genesis_core::input::{GenesisButton, InputState};
 use genesis_core::memory::{MainBus, MainBusSignals, MainBusWrites, Memory};
 use genesis_core::timing::GenesisCycleCounters;
 use genesis_core::vdp::{Vdp, VdpTickEffect};
@@ -177,6 +177,7 @@ impl Sega32XEmulator {
 }
 
 impl EmulatorTrait for Sega32XEmulator {
+    type Button = GenesisButton;
     type Inputs = GenesisInputs;
     type Config = Sega32XEmulatorConfig;
     type Err<
diff --git a/backend/segacd-core/src/api.rs b/backend/segacd-core/src/api.rs
index 15f116af..53f99b59 100644
--- a/backend/segacd-core/src/api.rs
+++ b/backend/segacd-core/src/api.rs
@@ -8,7 +8,7 @@ use crate::rf5c164::Rf5c164;
 use bincode::{Decode, Encode};
 use cdrom::CdRomError;
 use cdrom::reader::{CdRom, CdRomFileFormat};
-use genesis_core::input::InputState;
+use genesis_core::input::{GenesisButton, InputState};
 use genesis_core::memory::{MainBus, MainBusSignals, MainBusWrites, Memory};
 use genesis_core::timing::CycleCounters;
 use genesis_core::vdp::{Vdp, VdpTickEffect};
@@ -336,6 +336,7 @@ impl SegaCdEmulator {
 }
 
 impl EmulatorTrait for SegaCdEmulator {
+    type Button = GenesisButton;
     type Inputs = GenesisInputs;
     type Config = SegaCdEmulatorConfig;
 
diff --git a/backend/smsgg-core/src/api.rs b/backend/smsgg-core/src/api.rs
index e7ebdcd3..ea88b13e 100644
--- a/backend/smsgg-core/src/api.rs
+++ b/backend/smsgg-core/src/api.rs
@@ -6,7 +6,7 @@ use crate::input::InputState;
 use crate::memory::Memory;
 use crate::psg::{Sn76489, Sn76489TickEffect, Sn76489Version};
 use crate::vdp::{Vdp, VdpBuffer, VdpTickEffect};
-use crate::{SmsGgInputs, VdpVersion, vdp};
+use crate::{SmsGgButton, SmsGgInputs, VdpVersion, vdp};
 use bincode::{Decode, Encode};
 use jgenesis_common::frontend::{
     AudioOutput, Color, EmulatorTrait, FrameSize, PartialClone, PixelAspectRatio, Renderer,
@@ -327,6 +327,7 @@ fn determine_aspect_ratio(
 }
 
 impl EmulatorTrait for SmsGgEmulator {
+    type Button = SmsGgButton;
     type Inputs = SmsGgInputs;
     type Config = SmsGgEmulatorConfig;
 
diff --git a/backend/smsgg-core/src/input.rs b/backend/smsgg-core/src/input.rs
index adf816b0..84e028db 100644
--- a/backend/smsgg-core/src/input.rs
+++ b/backend/smsgg-core/src/input.rs
@@ -2,30 +2,27 @@
 
 use crate::api::SmsRegion;
 use bincode::{Decode, Encode};
+use jgenesis_common::define_controller_inputs;
 use jgenesis_common::num::GetBit;
-use jgenesis_proc_macros::define_controller_inputs;
 
 define_controller_inputs! {
-    enum SmsGgButton {
-        Up,
-        Left,
-        Right,
-        Down,
-        Button1,
-        Button2,
-        #[on_console]
-        Pause,
-    }
-
-    struct SmsGgJoypadState {
-        buttons!
-    }
-
-    struct SmsGgInputs {
-        p1: Player::One,
-        p2: Player::Two,
-        pause: Button::Pause,
-    }
+    buttons: SmsGgButton {
+        Up -> up,
+        Left -> left,
+        Right -> right,
+        Down -> down,
+        Button1 -> button1,
+        Button2 -> button2,
+    },
+    non_gamepad_buttons: [Pause],
+    joypad: SmsGgJoypadState,
+    inputs: SmsGgInputs {
+        players: {
+            p1: Player::One,
+            p2: Player::Two,
+        },
+        buttons: [Pause -> pause],
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
diff --git a/backend/snes-core/src/api.rs b/backend/snes-core/src/api.rs
index 4b58b9d5..02de9d20 100644
--- a/backend/snes-core/src/api.rs
+++ b/backend/snes-core/src/api.rs
@@ -3,7 +3,7 @@
 use crate::apu::{Apu, ApuTickEffect};
 use crate::audio::AudioResampler;
 use crate::bus::Bus;
-use crate::input::SnesInputs;
+use crate::input::{SnesButton, SnesInputs};
 use crate::memory::dma::{DmaStatus, DmaUnit};
 use crate::memory::{CpuInternalRegisters, Memory};
 use crate::ppu::{Ppu, PpuTickEffect};
@@ -276,6 +276,7 @@ impl SnesEmulator {
 }
 
 impl EmulatorTrait for SnesEmulator {
+    type Button = SnesButton;
     type Inputs = SnesInputs;
     type Config = SnesEmulatorConfig;
 
diff --git a/backend/snes-core/src/input.rs b/backend/snes-core/src/input.rs
index f4a45ab3..9ebe2dc3 100644
--- a/backend/snes-core/src/input.rs
+++ b/backend/snes-core/src/input.rs
@@ -1,34 +1,25 @@
 use bincode::{Decode, Encode};
+use jgenesis_common::define_controller_inputs;
+use jgenesis_common::frontend::{DisplayArea, FrameSize, MappableInputs};
 use jgenesis_common::input::Player;
-use jgenesis_proc_macros::define_controller_inputs;
 
 define_controller_inputs! {
-    enum SnesButton {
-        Up,
-        Left,
-        Right,
-        Down,
-        A,
-        B,
-        X,
-        Y,
-        L,
-        R,
-        Start,
-        Select,
-        #[on_console]
-        SuperScopeFire,
-        #[on_console]
-        SuperScopeCursor,
-        #[on_console]
-        SuperScopePause,
-        #[on_console]
-        SuperScopeTurboToggle,
-    }
-
-    struct SnesJoypadState {
-        buttons!
-    }
+    buttons: SnesButton {
+        Up -> up,
+        Left -> left,
+        Right -> right,
+        Down -> down,
+        A -> a,
+        B -> b,
+        X -> x,
+        Y -> y,
+        L -> l,
+        R -> r,
+        Start -> start,
+        Select -> select,
+    },
+    non_gamepad_buttons: [SuperScopeFire, SuperScopeCursor, SuperScopePause, SuperScopeTurboToggle],
+    joypad: SnesJoypadState,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -140,9 +131,9 @@ pub struct SnesInputs {
     pub p2: SnesInputDevice,
 }
 
-impl SnesInputs {
+impl MappableInputs<SnesButton> for SnesInputs {
     #[inline]
-    pub fn set_button(&mut self, button: SnesButton, player: Player, pressed: bool) {
+    fn set_field(&mut self, button: SnesButton, player: Player, pressed: bool) {
         if let Some(super_scope_button) = button.to_super_scope() {
             if let SnesInputDevice::SuperScope(super_scope_state) = &mut self.p2 {
                 super_scope_state.set_button(super_scope_button, pressed);
@@ -163,9 +154,29 @@ impl SnesInputs {
     }
 
     #[inline]
-    #[must_use]
-    pub fn with_button(mut self, button: SnesButton, player: Player, pressed: bool) -> Self {
-        self.set_button(button, player, pressed);
-        self
+    fn handle_mouse_motion(
+        &mut self,
+        x: i32,
+        y: i32,
+        frame_size: FrameSize,
+        display_area: DisplayArea,
+    ) {
+        if let SnesInputDevice::SuperScope(super_scope_state) = &mut self.p2 {
+            super_scope_state.position =
+                jgenesis_common::input::viewport_position_to_frame_position(
+                    x,
+                    y,
+                    frame_size,
+                    display_area,
+                );
+            log::debug!("Set Super Scope position to {:?}", super_scope_state.position);
+        }
+    }
+
+    #[inline]
+    fn handle_mouse_leave(&mut self) {
+        if let SnesInputDevice::SuperScope(super_scope_state) = &mut self.p2 {
+            super_scope_state.position = None;
+        }
     }
 }
diff --git a/common/jgenesis-common/src/frontend.rs b/common/jgenesis-common/src/frontend.rs
index 9c58b7cf..85220588 100644
--- a/common/jgenesis-common/src/frontend.rs
+++ b/common/jgenesis-common/src/frontend.rs
@@ -2,6 +2,7 @@ use bincode::{Decode, Encode};
 use jgenesis_proc_macros::{EnumAll, EnumDisplay, EnumFromStr};
 use std::error::Error;
 use std::fmt::{Debug, Display};
+use std::hash::Hash;
 use std::num::NonZeroU32;
 
 #[repr(C)]
@@ -44,6 +45,14 @@ pub struct FrameSize {
     pub height: u32,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct DisplayArea {
+    pub width: u32,
+    pub height: u32,
+    pub x: u32,
+    pub y: u32,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Encode, Decode)]
 pub struct PixelAspectRatio(f64);
 
@@ -155,6 +164,7 @@ pub trait PartialClone {
     fn partial_clone(&self) -> Self;
 }
 
+use crate::input::Player;
 pub use jgenesis_proc_macros::PartialClone;
 
 #[derive(
@@ -176,8 +186,25 @@ pub enum TickEffect {
 
 pub type TickResult<Err> = Result<TickEffect, Err>;
 
+pub trait MappableInputs<Button> {
+    fn set_field(&mut self, button: Button, player: Player, pressed: bool);
+
+    #[allow(unused_variables)]
+    fn handle_mouse_motion(
+        &mut self,
+        x: i32,
+        y: i32,
+        frame_size: FrameSize,
+        display_area: DisplayArea,
+    ) {
+    }
+
+    fn handle_mouse_leave(&mut self) {}
+}
+
 pub trait EmulatorTrait: Encode + Decode + PartialClone {
-    type Inputs;
+    type Button: Debug + Copy + Eq + Hash;
+    type Inputs: Default + MappableInputs<Self::Button>;
     type Config;
 
     type Err<RErr: Debug + Display + Send + Sync + 'static, AErr: Debug + Display + Send + Sync + 'static, SErr: Debug + Display + Send + Sync + 'static>: Error + Send + Sync + 'static;
diff --git a/common/jgenesis-common/src/input.rs b/common/jgenesis-common/src/input.rs
index f6ad44bb..990cf4b0 100644
--- a/common/jgenesis-common/src/input.rs
+++ b/common/jgenesis-common/src/input.rs
@@ -3,3 +3,169 @@ pub enum Player {
     One,
     Two,
 }
+
+#[inline]
+#[must_use]
+pub fn viewport_position_to_frame_position(
+    x: i32,
+    y: i32,
+    frame_size: FrameSize,
+    display_area: DisplayArea,
+) -> Option<(u16, u16)> {
+    let display_left = display_area.x as i32;
+    let display_right = display_left + display_area.width as i32;
+    let display_top = display_area.y as i32;
+    let display_bottom = display_top + display_area.height as i32;
+
+    if !(display_left..display_right).contains(&x) || !(display_top..display_bottom).contains(&y) {
+        return None;
+    }
+
+    let x: f64 = x.into();
+    let y: f64 = y.into();
+    let display_left: f64 = display_left.into();
+    let display_width: f64 = display_area.width.into();
+    let frame_width: f64 = frame_size.width.into();
+    let display_top: f64 = display_top.into();
+    let display_height: f64 = display_area.height.into();
+    let frame_height: f64 = frame_size.height.into();
+
+    let frame_x = ((x - display_left) * frame_width / display_width).round() as u16;
+    let frame_y = ((y - display_top) * frame_height / display_height).round() as u16;
+
+    log::trace!(
+        "Mapped mouse position ({x}, {y}) to ({frame_x}, {frame_y}) (frame size {frame_size:?}, display_area {display_area:?})"
+    );
+
+    Some((frame_x, frame_y))
+}
+
+#[macro_export]
+macro_rules! define_controller_inputs {
+    (
+        buttons: $button_enum:ident {
+            $($button:ident -> $button_field:ident),* $(,)?
+        }
+        $(, non_gamepad_buttons: [$($non_gamepad_button:ident),* $(,)?])?
+        , joypad: $joypad_struct:ident
+        $(
+            , inputs: $inputs_struct:ident {
+                players: {
+                    $($player_field:ident: Player::$player_value:ident),* $(,)?
+                }
+                $(, buttons: [$($ex_button:ident -> $ex_button_field:ident),* $(,)?])?
+                $(,)?
+            }
+        )?
+        $(,)?
+    ) => {
+        #[derive(
+            Debug,
+            Clone,
+            Copy,
+            PartialEq,
+            Eq,
+            ::std::hash::Hash,
+            ::bincode::Encode,
+            ::bincode::Decode,
+            ::jgenesis_proc_macros::EnumAll,
+            ::jgenesis_proc_macros::EnumDisplay,
+            ::jgenesis_proc_macros::EnumFromStr,
+        )]
+        pub enum $button_enum {
+            $(
+                $button,
+            )*
+            $($(
+                $non_gamepad_button,
+            )*)?
+        }
+
+        #[derive(
+            Debug,
+            Clone,
+            Copy,
+            PartialEq,
+            Eq,
+            Default,
+            ::std::hash::Hash,
+            ::bincode::Encode,
+            ::bincode::Decode,
+        )]
+        pub struct $joypad_struct {
+            $(
+                pub $button_field: bool,
+            )*
+        }
+
+        impl $joypad_struct {
+            #[inline]
+            pub fn set_button(&mut self, button: $button_enum, pressed: bool) {
+                match button {
+                    $(
+                        $button_enum::$button => self.$button_field = pressed,
+                    )*
+                    $(
+                        $(
+                            $button_enum::$non_gamepad_button => {}
+                        )*
+                    )?
+                }
+            }
+
+            #[inline]
+            pub fn with_button(mut self, button: $button_enum, pressed: bool) -> Self {
+                self.set_button(button, pressed);
+                self
+            }
+        }
+
+        $(
+            #[derive(
+                Debug,
+                Clone,
+                Copy,
+                PartialEq,
+                Eq,
+                Default,
+                ::std::hash::Hash,
+                ::bincode::Encode,
+                ::bincode::Decode,
+            )]
+            pub struct $inputs_struct {
+                $(
+                    pub $player_field: $joypad_struct,
+                )*
+                $($(
+                    pub $ex_button_field: bool,
+                )*)?
+            }
+
+            impl ::jgenesis_common::frontend::MappableInputs<$button_enum> for $inputs_struct {
+                #[inline]
+                fn set_field(
+                    &mut self,
+                    button: $button_enum,
+                    player: ::jgenesis_common::input::Player,
+                    pressed: bool,
+                ) {
+                    match (button, player) {
+                        $($(
+                            ($button_enum::$ex_button, _) => {
+                                self.$ex_button_field = pressed;
+                            }
+                        )*)?
+                        $(
+                            (button, ::jgenesis_common::input::Player::$player_value) => {
+                                self.$player_field.set_button(button, pressed);
+                            }
+                        )*
+                    }
+                }
+            }
+        )?
+    }
+}
+
+use crate::frontend::{DisplayArea, FrameSize};
+pub use define_controller_inputs;
diff --git a/common/jgenesis-proc-macros/src/inputs.rs b/common/jgenesis-proc-macros/src/inputs.rs
deleted file mode 100644
index e36f5c54..00000000
--- a/common/jgenesis-proc-macros/src/inputs.rs
+++ /dev/null
@@ -1,288 +0,0 @@
-#![allow(clippy::manual_assert)]
-
-use proc_macro2::{Ident, TokenStream};
-use quote::{format_ident, quote};
-use syn::parse::{Parse, ParseStream};
-use syn::punctuated::Punctuated;
-use syn::{Field, Token, Type, Variant, braced, parse_macro_input};
-
-struct ButtonEnum {
-    name: Ident,
-    variants: Punctuated<Variant, Token![,]>,
-}
-
-impl Parse for ButtonEnum {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        input.parse::<Token![enum]>()?;
-
-        let name: Ident = input.parse()?;
-
-        let content;
-        braced!(content in input);
-
-        let variants = content.parse_terminated(Variant::parse, Token![,])?;
-
-        Ok(Self { name, variants })
-    }
-}
-
-struct JoypadStruct {
-    name: Ident,
-}
-
-impl Parse for JoypadStruct {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        input.parse::<Token![struct]>()?;
-
-        let name: Ident = input.parse()?;
-
-        let content;
-        braced!(content in input);
-
-        let filler_ident: Ident = content.parse()?;
-        if filler_ident.to_string().as_str() != "buttons" {
-            return Err(content.error(format!("Expected 'buttons', got '{filler_ident}'")));
-        }
-
-        content.parse::<Token![!]>()?;
-
-        Ok(Self { name })
-    }
-}
-
-enum InputsField {
-    Player(Ident),
-    Button(Ident),
-}
-
-struct InputsStruct {
-    name: Ident,
-    fields: Vec<(Ident, InputsField)>,
-}
-
-impl Parse for InputsStruct {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        input.parse::<Token![struct]>()?;
-
-        let name: Ident = input.parse()?;
-
-        let content;
-        braced!(content in input);
-
-        let mut fields = Vec::new();
-        let raw_fields = content.parse_terminated(Field::parse_named, Token![,])?;
-        for raw_field in raw_fields {
-            let field_name = raw_field.ident.unwrap();
-            let Type::Path(path) = raw_field.ty else {
-                return Err(content.error("Expected type path"));
-            };
-
-            let segments: Vec<_> = path.path.segments.into_iter().collect();
-            if segments.len() != 2 {
-                return Err(content
-                    .error(format!("Expected type path of length 2, was {}", segments.len())));
-            }
-
-            let field = match segments[0].ident.to_string().as_str() {
-                "Player" => InputsField::Player(segments[1].ident.clone()),
-                "Button" => InputsField::Button(segments[1].ident.clone()),
-                _ => {
-                    return Err(content.error(format!(
-                        "Expected 'Player' or 'Button', got '{}'",
-                        segments[0].ident
-                    )));
-                }
-            };
-            fields.push((field_name, field));
-        }
-
-        Ok(Self { name, fields })
-    }
-}
-
-struct MacroInput {
-    button_enum: ButtonEnum,
-    joypad_struct: JoypadStruct,
-    inputs_struct: Option<InputsStruct>,
-}
-
-impl Parse for MacroInput {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let button_enum: ButtonEnum = input.parse()?;
-        let joypad_struct: JoypadStruct = input.parse()?;
-
-        if input.is_empty() {
-            return Ok(MacroInput { button_enum, joypad_struct, inputs_struct: None });
-        }
-
-        let inputs_struct: InputsStruct = input.parse()?;
-
-        Ok(Self { button_enum, joypad_struct, inputs_struct: Some(inputs_struct) })
-    }
-}
-
-pub fn define_controller_inputs(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let input = parse_macro_input!(input as MacroInput);
-
-    let button_enum = generate_button_enum(&input.button_enum);
-
-    let joypad_struct = generate_joypad_struct(&input.button_enum, &input.joypad_struct);
-
-    let inputs_struct = match &input.inputs_struct {
-        Some(inputs_struct) => {
-            generate_inputs_struct(&input.button_enum, &input.joypad_struct, inputs_struct)
-        }
-        None => quote! {},
-    };
-
-    let gen = quote! {
-        #button_enum
-        #joypad_struct
-        #inputs_struct
-    };
-
-    gen.into()
-}
-
-fn generate_button_enum(button_enum: &ButtonEnum) -> TokenStream {
-    let name = &button_enum.name;
-
-    let variants: Vec<_> = button_enum
-        .variants
-        .iter()
-        .map(|variant| {
-            let ident = &variant.ident;
-            quote! {
-                #ident
-            }
-        })
-        .collect();
-
-    quote! {
-        #[derive(
-            Debug,
-            Clone,
-            Copy,
-            PartialEq,
-            Eq,
-            ::std::hash::Hash,
-            ::bincode::Encode,
-            ::bincode::Decode,
-            ::jgenesis_proc_macros::EnumDisplay,
-            ::jgenesis_proc_macros::EnumFromStr,
-            ::jgenesis_proc_macros::EnumAll,
-        )]
-        pub enum #name {
-            #(#variants,)*
-        }
-    }
-}
-
-fn generate_joypad_struct(button_enum: &ButtonEnum, joypad_struct: &JoypadStruct) -> TokenStream {
-    let button_name = &button_enum.name;
-    let joypad_name = &joypad_struct.name;
-
-    let mut fields = Vec::new();
-    let mut match_arms = Vec::new();
-    for variant in &button_enum.variants {
-        if variant.attrs.iter().any(|attr| attr.path().is_ident("on_console")) {
-            // SMS/GG: Joypad struct should not contain any buttons with the #[on_console] attribute
-            continue;
-        }
-
-        let field_name = format_ident!("{}", variant.ident.to_string().to_lowercase());
-        fields.push(quote! {
-            pub #field_name: bool
-        });
-
-        let variant_ident = &variant.ident;
-        match_arms.push(quote! {
-            #button_name::#variant_ident => self.#field_name = pressed
-        });
-    }
-
-    match_arms.push(quote! {
-        _ => return
-    });
-
-    quote! {
-        #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, ::std::hash::Hash, ::bincode::Encode, ::bincode::Decode)]
-        pub struct #joypad_name {
-            #(#fields,)*
-        }
-
-        impl #joypad_name {
-            #[inline]
-            pub fn set_button(&mut self, button: #button_name, pressed: bool) {
-                match button {
-                    #(#match_arms,)*
-                }
-            }
-
-            #[inline]
-            pub fn with_button(mut self, button: #button_name, pressed: bool) -> Self {
-                self.set_button(button, pressed);
-                self
-            }
-        }
-    }
-}
-
-fn generate_inputs_struct(
-    button_enum: &ButtonEnum,
-    joypad_struct: &JoypadStruct,
-    inputs_struct: &InputsStruct,
-) -> TokenStream {
-    let button_name = &button_enum.name;
-    let joypad_name = &joypad_struct.name;
-    let inputs_name = &inputs_struct.name;
-
-    let mut fields = Vec::new();
-    let mut button_match_arms = Vec::new();
-    let mut player_match_arms = Vec::new();
-    for (field_name, raw_field) in &inputs_struct.fields {
-        match raw_field {
-            InputsField::Player(player) => {
-                fields.push(quote! {
-                    pub #field_name: #joypad_name
-                });
-
-                player_match_arms.push(quote! {
-                    (::jgenesis_common::input::Player::#player, _) => self.#field_name.set_button(button, pressed)
-                });
-            }
-            InputsField::Button(button) => {
-                fields.push(quote! {
-                    pub #field_name: bool
-                });
-
-                button_match_arms.push(quote! {
-                    (_, #button_name::#button) => self.#field_name = pressed
-                });
-            }
-        }
-    }
-
-    quote! {
-        #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, ::std::hash::Hash, ::bincode::Encode, ::bincode::Decode)]
-        pub struct #inputs_name {
-            #(#fields,)*
-        }
-
-        impl #inputs_name {
-            #[inline]
-            pub fn set_button(&mut self, button: #button_name, player: ::jgenesis_common::input::Player, pressed: bool) {
-                match (player, button) {
-                    #(#button_match_arms,)*
-                    #(#player_match_arms,)*
-                }
-            }
-
-            #[inline]
-            pub fn with_button(mut self, button: #button_name, player: ::jgenesis_common::input::Player, pressed: bool) -> Self {
-                self.set_button(button, player, pressed);
-                self
-            }
-        }
-    }
-}
diff --git a/common/jgenesis-proc-macros/src/lib.rs b/common/jgenesis-proc-macros/src/lib.rs
index 45160c4b..6c090adc 100644
--- a/common/jgenesis-proc-macros/src/lib.rs
+++ b/common/jgenesis-proc-macros/src/lib.rs
@@ -1,7 +1,6 @@
 mod config;
 mod encode;
 mod enums;
-mod inputs;
 mod partialclone;
 
 use proc_macro::TokenStream;
@@ -315,77 +314,3 @@ pub fn partial_clone(input: TokenStream) -> TokenStream {
 pub fn match_each_variant_macro(input: TokenStream) -> TokenStream {
     enums::match_each_variant_macro(input)
 }
-
-/// Define a button enum, joypad state struct, and console inputs struct.
-///
-/// As an example, this will define an enum `NesButton`, a struct `NesJoypadState`, and a struct
-/// `NesInputs`:
-///
-/// ```
-/// use jgenesis_common::input::Player;
-/// use jgenesis_proc_macros::define_controller_inputs;
-///
-/// define_controller_inputs! {
-///     enum NesButton {
-///         Up,
-///         Left,
-///         Right,
-///         Down,
-///         A,
-///         B,
-///         Start,
-///         Select,
-///     }
-///
-///     struct NesJoypadState {
-///         buttons!
-///     }
-///
-///     struct NesInputs {
-///         p1: Player::One,
-///         p2: Player::Two,
-///     }
-/// }
-///
-/// let mut inputs = NesInputs {
-///     p1: NesJoypadState {
-///         up: true,
-///         left: false,
-///         right: false,
-///         down: false,
-///         a: false,
-///         b: true,
-///         start: false,
-///         select: false,
-///     },
-///     p2: NesJoypadState::default(),
-/// };
-/// inputs = inputs.with_button(NesButton::A, Player::Two, true);
-/// assert!(inputs.p2.a);
-/// ```
-///
-/// The `NesButton` enum will have one variant per button in `buttons`.
-///
-/// The `NesJoypadState` struct will have a `bool` field for each button, with the field name equal
-/// to the lowercased variant name. It will also have the following two methods defined for setting
-/// fields from button enum values:
-/// * `set_button(&mut self, button: NesButton, pressed: bool)`
-/// * `with_button(self, button: NesButton, pressed: bool) -> Self`
-///
-/// The `NesInputs` struct will have two fields: `p1` and `p2`, both of type `NesJoypadState`. It
-/// will also have the following two methods defined for setting fields from button/player values:
-/// * `set_button(&mut self, button: NesButton, player: Player, pressed: bool)`
-/// * `with_button(self, button: NesButton, player: Player, pressed: bool) -> Self`
-///
-/// `inputs_ident` is optional. If it is omitted then no inputs struct will be defined.
-///
-/// All fields and methods will have `pub` visibility.
-///
-/// All enums and structs will implement the following traits: `Debug`, `Clone`, `Copy`, `PartialEq`,
-/// `Eq`, `Default`, `Hash`, `bincode::Encode`, and `bincode::Decode`. The button enum will additionally
-/// implement the traits `Display` and `FromStr`, and it will have an `ALL` associated constant
-/// containing all enum values.
-#[proc_macro]
-pub fn define_controller_inputs(input: TokenStream) -> TokenStream {
-    inputs::define_controller_inputs(input)
-}
diff --git a/common/jgenesis-proc-macros/tests/inputs.rs b/common/jgenesis-proc-macros/tests/inputs.rs
deleted file mode 100644
index f34a9223..00000000
--- a/common/jgenesis-proc-macros/tests/inputs.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use jgenesis_common::input::Player;
-use jgenesis_proc_macros::define_controller_inputs;
-
-define_controller_inputs! {
-    enum SmsGgButton {
-        Up,
-        Left,
-        Right,
-        Down,
-        Button1,
-        Button2,
-        #[on_console]
-        Pause,
-    }
-
-    struct SmsGgJoypadState {
-        buttons!
-    }
-
-    struct SmsGgInputs {
-        p1: Player::One,
-        p2: Player::Two,
-        pause: Button::Pause,
-    }
-}
-
-#[test]
-fn button_enum() {
-    assert_eq!(SmsGgButton::Button1, SmsGgButton::Button1);
-    assert_eq!(SmsGgButton::Pause, SmsGgButton::Pause);
-
-    assert_eq!(SmsGgButton::ALL.len(), 7);
-}
-
-#[test]
-fn joypad_struct() {
-    let mut joypad_state = SmsGgJoypadState::default();
-    joypad_state.set_button(SmsGgButton::Button2, true);
-    assert!(joypad_state.button2);
-
-    let joypad_state =
-        joypad_state.with_button(SmsGgButton::Left, true).with_button(SmsGgButton::Button2, false);
-    assert!(joypad_state.left);
-    assert!(!joypad_state.button2);
-
-    assert_eq!(joypad_state, joypad_state.with_button(SmsGgButton::Pause, true));
-}
-
-#[test]
-fn inputs_struct() {
-    let mut inputs = SmsGgInputs::default();
-    inputs.set_button(SmsGgButton::Pause, Player::One, true);
-    assert!(inputs.pause);
-
-    inputs = inputs.with_button(SmsGgButton::Pause, Player::Two, false);
-    assert!(!inputs.pause);
-
-    inputs.set_button(SmsGgButton::Left, Player::Two, true);
-    assert!(inputs.p2.left);
-
-    inputs = inputs.with_button(SmsGgButton::Button2, Player::One, true);
-    assert!(inputs.p1.button2);
-    assert!(inputs.p2.left);
-}
diff --git a/common/jgenesis-proc-macros/tests/lib.rs b/common/jgenesis-proc-macros/tests/lib.rs
index 55704db9..cdebc758 100644
--- a/common/jgenesis-proc-macros/tests/lib.rs
+++ b/common/jgenesis-proc-macros/tests/lib.rs
@@ -1,4 +1,3 @@
 mod config;
 mod enums;
-mod inputs;
 mod partialclone;
diff --git a/frontend/jgenesis-cli/src/main.rs b/frontend/jgenesis-cli/src/main.rs
index a106b796..598b42ce 100644
--- a/frontend/jgenesis-cli/src/main.rs
+++ b/frontend/jgenesis-cli/src/main.rs
@@ -10,7 +10,6 @@ use jgenesis_native_config::AppConfig;
 use jgenesis_native_config::common::ConfigSavePath;
 use jgenesis_native_driver::config::input::{NesControllerType, SnesControllerType};
 use jgenesis_native_driver::config::{FullscreenMode, HideMouseCursor};
-use jgenesis_native_driver::input::MappableInputs;
 use jgenesis_native_driver::{NativeEmulator, NativeTickEffect};
 use jgenesis_proc_macros::{CustomValueEnum, EnumAll, EnumDisplay};
 use jgenesis_renderer::config::{
@@ -25,7 +24,6 @@ use snes_core::api::{AudioInterpolationMode, SnesAspectRatio};
 use std::ffi::OsStr;
 use std::fmt::Debug;
 use std::fs;
-use std::hash::Hash;
 use std::num::{NonZeroU32, NonZeroU64};
 use std::path::{Path, PathBuf};
 
@@ -828,15 +826,12 @@ fn run_gb(args: Args, config: AppConfig) -> anyhow::Result<()> {
     run_emulator(&mut emulator, &args)
 }
 
-// TODO simplify these trait bounds (required by load_state() definition)
-fn run_emulator<Inputs, Button, Config, Emulator>(
-    emulator: &mut NativeEmulator<Inputs, Button, Config, Emulator>,
+fn run_emulator<Emulator>(
+    emulator: &mut NativeEmulator<Emulator>,
     args: &Args,
 ) -> anyhow::Result<()>
 where
-    Inputs: Default + MappableInputs<Button>,
-    Button: Debug + Copy + Hash + Eq,
-    Emulator: EmulatorTrait<Inputs = Inputs, Config = Config>,
+    Emulator: EmulatorTrait,
 {
     if let Some(save_state_slot) = args.load_save_state {
         log::info!("Loading save state slot {save_state_slot} at launch");
diff --git a/frontend/jgenesis-native-driver/src/input.rs b/frontend/jgenesis-native-driver/src/input.rs
index 40f7276f..b1f062cd 100644
--- a/frontend/jgenesis-native-driver/src/input.rs
+++ b/frontend/jgenesis-native-driver/src/input.rs
@@ -1,22 +1,15 @@
 mod serialize;
 
 use arrayvec::ArrayVec;
-use gb_core::inputs::{GameBoyButton, GameBoyInputs};
-use genesis_core::GenesisInputs;
-use genesis_core::input::GenesisButton;
-use jgenesis_common::frontend::FrameSize;
+use jgenesis_common::frontend::{DisplayArea, FrameSize, MappableInputs};
 use jgenesis_common::input::Player;
 use jgenesis_proc_macros::{EnumAll, EnumDisplay, EnumFromStr};
-use jgenesis_renderer::renderer::DisplayArea;
-use nes_core::input::{NesButton, NesInputDevice, NesInputs};
 use rustc_hash::{FxHashMap, FxHashSet};
 use sdl2::event::{Event, WindowEvent};
 use sdl2::joystick::{HatState, Joystick};
 use sdl2::keyboard::Keycode;
 use sdl2::mouse::MouseButton;
 use sdl2::{IntegerOrSdlError, JoystickSubsystem};
-use smsgg_core::{SmsGgButton, SmsGgInputs};
-use snes_core::input::{SnesButton, SnesInputDevice, SnesInputs};
 use std::array;
 use std::borrow::Cow;
 use std::cell::RefCell;
@@ -333,126 +326,6 @@ pub enum GenericButton<Button> {
     Hotkey(Hotkey),
 }
 
-pub trait MappableInputs<Button> {
-    fn set_field(&mut self, button: Button, player: Player, pressed: bool);
-
-    #[allow(unused_variables)]
-    fn handle_mouse_motion(
-        &mut self,
-        x: i32,
-        y: i32,
-        frame_size: FrameSize,
-        display_area: DisplayArea,
-    ) {
-    }
-
-    fn handle_mouse_leave(&mut self) {}
-}
-
-fn viewport_position_to_frame_position(
-    x: i32,
-    y: i32,
-    frame_size: FrameSize,
-    display_area: DisplayArea,
-) -> Option<(u16, u16)> {
-    let display_left = display_area.x as i32;
-    let display_right = display_left + display_area.width as i32;
-    let display_top = display_area.y as i32;
-    let display_bottom = display_top + display_area.height as i32;
-
-    if !(display_left..display_right).contains(&x) || !(display_top..display_bottom).contains(&y) {
-        return None;
-    }
-
-    let x: f64 = x.into();
-    let y: f64 = y.into();
-    let display_left: f64 = display_left.into();
-    let display_width: f64 = display_area.width.into();
-    let frame_width: f64 = frame_size.width.into();
-    let display_top: f64 = display_top.into();
-    let display_height: f64 = display_area.height.into();
-    let frame_height: f64 = frame_size.height.into();
-
-    let frame_x = ((x - display_left) * frame_width / display_width).round() as u16;
-    let frame_y = ((y - display_top) * frame_height / display_height).round() as u16;
-
-    log::trace!(
-        "Mapped mouse position ({x}, {y}) to ({frame_x}, {frame_y}) (frame size {frame_size:?}, display_area {display_area:?})"
-    );
-
-    Some((frame_x, frame_y))
-}
-
-impl MappableInputs<SmsGgButton> for SmsGgInputs {
-    fn set_field(&mut self, button: SmsGgButton, player: Player, pressed: bool) {
-        self.set_button(button, player, pressed);
-    }
-}
-
-impl MappableInputs<GenesisButton> for GenesisInputs {
-    fn set_field(&mut self, button: GenesisButton, player: Player, pressed: bool) {
-        self.set_button(button, player, pressed);
-    }
-}
-
-impl MappableInputs<NesButton> for NesInputs {
-    fn set_field(&mut self, button: NesButton, player: Player, pressed: bool) {
-        self.set_button(button, player, pressed);
-    }
-
-    fn handle_mouse_motion(
-        &mut self,
-        x: i32,
-        y: i32,
-        frame_size: FrameSize,
-        display_area: DisplayArea,
-    ) {
-        if let NesInputDevice::Zapper(zapper_state) = &mut self.p2 {
-            zapper_state.position =
-                viewport_position_to_frame_position(x, y, frame_size, display_area);
-            log::debug!("Set Zapper position to {:?}", zapper_state.position);
-        }
-    }
-
-    fn handle_mouse_leave(&mut self) {
-        if let NesInputDevice::Zapper(zapper_state) = &mut self.p2 {
-            zapper_state.position = None;
-        }
-    }
-}
-
-impl MappableInputs<SnesButton> for SnesInputs {
-    fn set_field(&mut self, button: SnesButton, player: Player, pressed: bool) {
-        self.set_button(button, player, pressed);
-    }
-
-    fn handle_mouse_motion(
-        &mut self,
-        x: i32,
-        y: i32,
-        frame_size: FrameSize,
-        display_area: DisplayArea,
-    ) {
-        if let SnesInputDevice::SuperScope(super_scope_state) = &mut self.p2 {
-            super_scope_state.position =
-                viewport_position_to_frame_position(x, y, frame_size, display_area);
-            log::debug!("Set Super Scope position to {:?}", super_scope_state.position);
-        }
-    }
-
-    fn handle_mouse_leave(&mut self) {
-        if let SnesInputDevice::SuperScope(super_scope_state) = &mut self.p2 {
-            super_scope_state.position = None;
-        }
-    }
-}
-
-impl MappableInputs<GameBoyButton> for GameBoyInputs {
-    fn set_field(&mut self, button: GameBoyButton, _player: Player, pressed: bool) {
-        self.set_button(button, pressed);
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum HotkeyEvent {
     Pressed(Hotkey),
@@ -915,6 +788,7 @@ fn is_hat_direction_pressed(direction: HatDirection, state: HatState) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use smsgg_core::{SmsGgButton, SmsGgInputs};
     use std::mem;
 
     fn take_hotkey_events<I, B>(state: &mut InputMapperState<I, B>) -> Vec<HotkeyEvent> {
diff --git a/frontend/jgenesis-native-driver/src/mainloop.rs b/frontend/jgenesis-native-driver/src/mainloop.rs
index f9cb8181..29694689 100644
--- a/frontend/jgenesis-native-driver/src/mainloop.rs
+++ b/frontend/jgenesis-native-driver/src/mainloop.rs
@@ -23,7 +23,7 @@ use crate::archive::ArchiveError;
 use crate::config::input::ButtonMappingVec;
 use crate::config::{CommonConfig, FullscreenMode, HideMouseCursor, WindowSize};
 use crate::fpstracker::FpsTracker;
-use crate::input::{CompactHotkey, Hotkey, HotkeyEvent, InputMapper, Joysticks, MappableInputs};
+use crate::input::{CompactHotkey, Hotkey, HotkeyEvent, InputMapper, Joysticks};
 use crate::mainloop::audio::SdlAudioOutput;
 use crate::mainloop::debug::{DebugRenderFn, DebuggerWindow};
 use crate::mainloop::rewind::Rewinder;
@@ -47,7 +47,6 @@ use std::cell::RefCell;
 use std::error::Error;
 use std::ffi::NulError;
 use std::fmt::Debug;
-use std::hash::Hash;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::LazyLock;
@@ -189,12 +188,12 @@ pub enum NativeTickEffect {
     Exit,
 }
 
-pub struct NativeEmulator<Inputs, Button, Config, Emulator> {
+pub struct NativeEmulator<Emulator: EmulatorTrait> {
     emulator: Emulator,
-    config: Config,
+    config: Emulator::Config,
     renderer: WgpuRenderer<Window>,
     audio_output: SdlAudioOutput,
-    input_mapper: InputMapper<Inputs, Button>,
+    input_mapper: InputMapper<Emulator::Inputs, Emulator::Button>,
     save_writer: FsSaveWriter,
     sdl: Sdl,
     event_pump: EventPump,
@@ -206,9 +205,7 @@ pub struct NativeEmulator<Inputs, Button, Config, Emulator> {
     rom_extension: String,
 }
 
-impl<Inputs, Button, Config, Emulator: EmulatorTrait>
-    NativeEmulator<Inputs, Button, Config, Emulator>
-{
+impl<Emulator: EmulatorTrait> NativeEmulator<Emulator> {
     fn reload_common_config(&mut self, config: &CommonConfig) -> Result<(), AudioError> {
         self.renderer.reload_config(config.renderer_config);
 
@@ -379,12 +376,9 @@ pub enum NativeEmulatorError {
 
 pub type NativeEmulatorResult<T> = Result<T, NativeEmulatorError>;
 
-// TODO simplify or generalize these trait bounds
-impl<Inputs, Button, Config, Emulator> NativeEmulator<Inputs, Button, Config, Emulator>
+impl<Emulator> NativeEmulator<Emulator>
 where
-    Inputs: Default + MappableInputs<Button>,
-    Button: Debug + Copy + Hash + Eq,
-    Emulator: EmulatorTrait<Inputs = Inputs, Config = Config>,
+    Emulator: EmulatorTrait,
 {
     #[allow(clippy::too_many_arguments)]
     fn new(
@@ -396,8 +390,8 @@ where
         window_title: &str,
         save_writer: FsSaveWriter,
         save_state_path: PathBuf,
-        button_mappings: &ButtonMappingVec<'_, Button>,
-        initial_inputs: Inputs,
+        button_mappings: &ButtonMappingVec<'_, Emulator::Button>,
+        initial_inputs: Emulator::Inputs,
         debug_render_fn: fn() -> Box<DebugRenderFn<Emulator>>,
     ) -> NativeEmulatorResult<Self> {
         let (sdl, video, audio, joystick, event_pump) = init_sdl(&common_config)?;
diff --git a/frontend/jgenesis-native-driver/src/mainloop/gb.rs b/frontend/jgenesis-native-driver/src/mainloop/gb.rs
index 7abb0417..87696a37 100644
--- a/frontend/jgenesis-native-driver/src/mainloop/gb.rs
+++ b/frontend/jgenesis-native-driver/src/mainloop/gb.rs
@@ -3,13 +3,12 @@ use crate::config::RomReadResult;
 use crate::mainloop::save::{DeterminedPaths, FsSaveWriter};
 use crate::mainloop::{debug, file_name_no_ext, save};
 use crate::{AudioError, NativeEmulator, NativeEmulatorResult, config};
-use gb_core::api::{GameBoyEmulator, GameBoyEmulatorConfig};
-use gb_core::inputs::{GameBoyButton, GameBoyInputs};
+use gb_core::api::GameBoyEmulator;
+use gb_core::inputs::GameBoyInputs;
 use jgenesis_common::frontend::EmulatorTrait;
 use std::path::Path;
 
-pub type NativeGameBoyEmulator =
-    NativeEmulator<GameBoyInputs, GameBoyButton, GameBoyEmulatorConfig, GameBoyEmulator>;
+pub type NativeGameBoyEmulator = NativeEmulator<GameBoyEmulator>;
 
 pub const SUPPORTED_EXTENSIONS: &[&str] = &["gb", "gbc"];
 
diff --git a/frontend/jgenesis-native-driver/src/mainloop/genesis.rs b/frontend/jgenesis-native-driver/src/mainloop/genesis.rs
index 871370ee..f56ab98a 100644
--- a/frontend/jgenesis-native-driver/src/mainloop/genesis.rs
+++ b/frontend/jgenesis-native-driver/src/mainloop/genesis.rs
@@ -3,17 +3,15 @@ use crate::config::{GenesisConfig, Sega32XConfig, SegaCdConfig};
 use crate::mainloop::save::{DeterminedPaths, FsSaveWriter};
 use crate::mainloop::{NativeEmulatorError, debug, save};
 use crate::{AudioError, NativeEmulator, NativeEmulatorResult, config};
-use genesis_core::input::GenesisButton;
-use genesis_core::{GenesisEmulator, GenesisEmulatorConfig, GenesisInputs};
+use genesis_core::{GenesisEmulator, GenesisInputs};
 use jgenesis_common::frontend::EmulatorTrait;
-use s32x_core::api::{Sega32XEmulator, Sega32XEmulatorConfig};
+use s32x_core::api::Sega32XEmulator;
 use segacd_core::CdRomFileFormat;
-use segacd_core::api::{SegaCdEmulator, SegaCdEmulatorConfig, SegaCdLoadResult};
+use segacd_core::api::{SegaCdEmulator, SegaCdLoadResult};
 use std::fs;
 use std::path::Path;
 
-pub type NativeGenesisEmulator =
-    NativeEmulator<GenesisInputs, GenesisButton, GenesisEmulatorConfig, GenesisEmulator>;
+pub type NativeGenesisEmulator = NativeEmulator<GenesisEmulator>;
 
 pub const GENESIS_SUPPORTED_EXTENSIONS: &[&str] = &["md", "bin"];
 pub const S32X_SUPPORTED_EXTENSIONS: &[&str] = &["32x"];
@@ -40,8 +38,7 @@ impl NativeGenesisEmulator {
     }
 }
 
-pub type NativeSegaCdEmulator =
-    NativeEmulator<GenesisInputs, GenesisButton, SegaCdEmulatorConfig, SegaCdEmulator>;
+pub type NativeSegaCdEmulator = NativeEmulator<SegaCdEmulator>;
 
 impl NativeSegaCdEmulator {
     /// # Errors
@@ -106,8 +103,7 @@ impl NativeSegaCdEmulator {
     }
 }
 
-pub type Native32XEmulator =
-    NativeEmulator<GenesisInputs, GenesisButton, Sega32XEmulatorConfig, Sega32XEmulator>;
+pub type Native32XEmulator = NativeEmulator<Sega32XEmulator>;
 
 impl Native32XEmulator {
     /// # Errors
diff --git a/frontend/jgenesis-native-driver/src/mainloop/nes.rs b/frontend/jgenesis-native-driver/src/mainloop/nes.rs
index fa6dd51b..6af7c264 100644
--- a/frontend/jgenesis-native-driver/src/mainloop/nes.rs
+++ b/frontend/jgenesis-native-driver/src/mainloop/nes.rs
@@ -5,8 +5,8 @@ use crate::mainloop::{debug, file_name_no_ext, save};
 use crate::{AudioError, NativeEmulator, NativeEmulatorResult, config};
 use jgenesis_common::frontend::EmulatorTrait;
 
-use nes_core::api::{NesEmulator, NesEmulatorConfig};
-use nes_core::input::{NesButton, NesInputDevice, NesInputs, NesJoypadState, ZapperState};
+use nes_core::api::NesEmulator;
+use nes_core::input::{NesInputDevice, NesInputs, NesJoypadState, ZapperState};
 
 use crate::config::RomReadResult;
 use crate::config::input::NesControllerType;
@@ -25,7 +25,7 @@ impl NesControllerTypeExt for NesControllerType {
     }
 }
 
-pub type NativeNesEmulator = NativeEmulator<NesInputs, NesButton, NesEmulatorConfig, NesEmulator>;
+pub type NativeNesEmulator = NativeEmulator<NesEmulator>;
 
 pub const SUPPORTED_EXTENSIONS: &[&str] = &["nes"];
 
diff --git a/frontend/jgenesis-native-driver/src/mainloop/smsgg.rs b/frontend/jgenesis-native-driver/src/mainloop/smsgg.rs
index 7941c7ba..26568267 100644
--- a/frontend/jgenesis-native-driver/src/mainloop/smsgg.rs
+++ b/frontend/jgenesis-native-driver/src/mainloop/smsgg.rs
@@ -6,11 +6,10 @@ use crate::{AudioError, NativeEmulator, NativeEmulatorResult, config};
 use jgenesis_common::frontend::EmulatorTrait;
 
 use crate::config::RomReadResult;
-use smsgg_core::{SmsGgButton, SmsGgEmulator, SmsGgEmulatorConfig, SmsGgHardware, SmsGgInputs};
+use smsgg_core::{SmsGgEmulator, SmsGgHardware, SmsGgInputs};
 use std::path::Path;
 
-pub type NativeSmsGgEmulator =
-    NativeEmulator<SmsGgInputs, SmsGgButton, SmsGgEmulatorConfig, SmsGgEmulator>;
+pub type NativeSmsGgEmulator = NativeEmulator<SmsGgEmulator>;
 
 pub const SUPPORTED_EXTENSIONS: &[&str] = &["sms", "gg"];
 
diff --git a/frontend/jgenesis-native-driver/src/mainloop/snes.rs b/frontend/jgenesis-native-driver/src/mainloop/snes.rs
index e179d052..a666e18d 100644
--- a/frontend/jgenesis-native-driver/src/mainloop/snes.rs
+++ b/frontend/jgenesis-native-driver/src/mainloop/snes.rs
@@ -7,8 +7,8 @@ use jgenesis_common::frontend::EmulatorTrait;
 
 use crate::config::RomReadResult;
 use crate::config::input::SnesControllerType;
-use snes_core::api::{SnesEmulator, SnesEmulatorConfig};
-use snes_core::input::{SnesButton, SnesInputDevice, SnesInputs, SnesJoypadState, SuperScopeState};
+use snes_core::api::SnesEmulator;
+use snes_core::input::{SnesInputDevice, SnesInputs, SnesJoypadState, SuperScopeState};
 use std::path::Path;
 
 trait SnesControllerTypeExt {
@@ -24,8 +24,7 @@ impl SnesControllerTypeExt for SnesControllerType {
     }
 }
 
-pub type NativeSnesEmulator =
-    NativeEmulator<SnesInputs, SnesButton, SnesEmulatorConfig, SnesEmulator>;
+pub type NativeSnesEmulator = NativeEmulator<SnesEmulator>;
 
 pub const SUPPORTED_EXTENSIONS: &[&str] = &["sfc", "smc"];
 
diff --git a/frontend/jgenesis-renderer/src/renderer.rs b/frontend/jgenesis-renderer/src/renderer.rs
index 07fdf410..c2ad95bd 100644
--- a/frontend/jgenesis-renderer/src/renderer.rs
+++ b/frontend/jgenesis-renderer/src/renderer.rs
@@ -1,12 +1,11 @@
 use crate::config::{PreprocessShader, PrescaleMode, RendererConfig, Scanlines, WgpuBackend};
 use cfg_if::cfg_if;
-use jgenesis_common::frontend::{Color, FrameSize, PixelAspectRatio, Renderer};
+use jgenesis_common::frontend::{Color, DisplayArea, FrameSize, PixelAspectRatio, Renderer};
 use jgenesis_common::timeutils;
 use raw_window_handle::{HandleError, HasDisplayHandle, HasWindowHandle};
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt::Debug;
-use std::time::Duration;
 use std::{cmp, iter};
 use thiserror::Error;
 use wgpu::util::DeviceExt;
@@ -757,14 +756,6 @@ fn compute_vertices(
         .collect()
 }
 
-#[derive(Debug, Clone, Copy)]
-pub struct DisplayArea {
-    pub width: u32,
-    pub height: u32,
-    pub x: u32,
-    pub y: u32,
-}
-
 fn determine_display_area(
     window_width: u32,
     window_height: u32,
@@ -1211,7 +1202,7 @@ impl<Window> WgpuRenderer<Window> {
     }
 
     #[cfg(feature = "ttf")]
-    pub fn add_modal(&mut self, text: String, duration: Duration) {
+    pub fn add_modal(&mut self, text: String, duration: std::time::Duration) {
         self.modal_renderer.add_modal(text, duration);
     }
 }