Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

18.4 KB
Raw Blame
use iced::keyboard::key::Code;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct KeyboardConfig {
    pub gc: GcKeysConfig,
    pub wii: WiiKeysConfig,
    pub hotkeys: HotkeysConfig,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct GcKeysConfig {
    pub stick_up: Option<String>,
    pub stick_down: Option<String>,
    pub stick_left: Option<String>,
    pub stick_right: Option<String>,
    pub a: Option<String>,
    pub b: Option<String>,
    pub x: Option<String>,
    pub y: Option<String>,
    pub start: Option<String>,
    pub l: Option<String>,
    pub r: Option<String>,
    pub z: Option<String>,
    pub dpad_up: Option<String>,
    pub dpad_down: Option<String>,
    pub dpad_left: Option<String>,
    pub dpad_right: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct WiiKeysConfig {
    pub one: Option<String>,
    pub two: Option<String>,
    pub plus: Option<String>,
    pub minus: Option<String>,
    pub home: Option<String>,
    pub dpad_up: Option<String>,
    pub dpad_down: Option<String>,
    pub dpad_left: Option<String>,
    pub dpad_right: Option<String>,
    pub shake: Option<String>,
    pub nunchuk_up: Option<String>,
    pub nunchuk_down: Option<String>,
    pub nunchuk_left: Option<String>,
    pub nunchuk_right: Option<String>,
    pub nunchuk_z: Option<String>,
    pub nunchuk_c: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct HotkeysConfig {
    pub pause: Option<String>,
    pub uncapped: Option<String>,
    pub fullscreen: Option<String>,
    pub overlay: Option<String>,
    pub screenshot: Option<String>,
    pub save_state: Option<String>,
    pub load_state: Option<String>,
    pub release_mouse: Option<String>,
}

#[derive(Debug, Clone, Copy)]
pub struct GcKeys {
    pub stick_up: Code,
    pub stick_down: Code,
    pub stick_left: Code,
    pub stick_right: Code,
    pub a: Code,
    pub b: Code,
    pub x: Code,
    pub y: Code,
    pub start: Code,
    pub l: Code,
    pub r: Code,
    pub z: Code,
    pub dpad_up: Code,
    pub dpad_down: Code,
    pub dpad_left: Code,
    pub dpad_right: Code,
}

impl Default for GcKeys {
    fn default() -> Self {
        Self {
            stick_up: Code::ArrowUp,
            stick_down: Code::ArrowDown,
            stick_left: Code::ArrowLeft,
            stick_right: Code::ArrowRight,
            a: Code::KeyX,
            b: Code::KeyZ,
            x: Code::KeyC,
            y: Code::KeyV,
            start: Code::Enter,
            l: Code::KeyA,
            r: Code::KeyS,
            z: Code::KeyD,
            dpad_up: Code::KeyI,
            dpad_down: Code::KeyK,
            dpad_left: Code::KeyJ,
            dpad_right: Code::KeyL,
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub struct WiiKeys {
    pub one: Code,
    pub two: Code,
    pub plus: Code,
    pub minus: Code,
    pub home: Code,
    pub dpad_up: Code,
    pub dpad_down: Code,
    pub dpad_left: Code,
    pub dpad_right: Code,
    pub shake: Code,
    pub nunchuk_up: Code,
    pub nunchuk_down: Code,
    pub nunchuk_left: Code,
    pub nunchuk_right: Code,
    pub nunchuk_z: Code,
    pub nunchuk_c: Code,
}

impl Default for WiiKeys {
    fn default() -> Self {
        Self {
            one: Code::Digit1,
            two: Code::Digit2,
            plus: Code::Equal,
            minus: Code::Minus,
            home: Code::Home,
            dpad_up: Code::ArrowUp,
            dpad_down: Code::ArrowDown,
            dpad_left: Code::ArrowLeft,
            dpad_right: Code::ArrowRight,
            shake: Code::ShiftLeft,
            nunchuk_up: Code::KeyW,
            nunchuk_down: Code::KeyS,
            nunchuk_left: Code::KeyA,
            nunchuk_right: Code::KeyD,
            nunchuk_z: Code::KeyQ,
            nunchuk_c: Code::KeyE,
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub struct Hotkeys {
    pub pause: Code,
    pub uncapped: Code,
    pub fullscreen: Code,
    pub overlay: Code,
    pub screenshot: Code,
    pub save_state: Code,
    pub load_state: Code,
    pub release_mouse: Code,
}

impl Default for Hotkeys {
    fn default() -> Self {
        Self {
            pause: Code::Space,
            uncapped: Code::Tab,
            fullscreen: Code::F10,
            overlay: Code::F11,
            screenshot: Code::F12,
            save_state: Code::F5,
            load_state: Code::F7,
            release_mouse: Code::Escape,
        }
    }
}

#[derive(Debug, Clone, Copy, Default)]
pub struct Keymap {
    pub gc: GcKeys,
    pub wii: WiiKeys,
    pub hotkeys: Hotkeys,
}

#[derive(Debug, Clone, Copy)]
pub enum Hotkey {
    Pause,
    Uncapped,
    Fullscreen,
    Overlay,
    Screenshot,
    SaveState,
    LoadState,
    ReleaseMouse,
}

impl Hotkeys {
    pub fn lookup(&self, key: Code) -> Option<Hotkey> {
        if key == self.pause {
            Some(Hotkey::Pause)
        } else if key == self.uncapped {
            Some(Hotkey::Uncapped)
        } else if key == self.fullscreen {
            Some(Hotkey::Fullscreen)
        } else if key == self.overlay {
            Some(Hotkey::Overlay)
        } else if key == self.screenshot {
            Some(Hotkey::Screenshot)
        } else if key == self.save_state {
            Some(Hotkey::SaveState)
        } else if key == self.load_state {
            Some(Hotkey::LoadState)
        } else if key == self.release_mouse {
            Some(Hotkey::ReleaseMouse)
        } else {
            None
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyTarget {
    GcStickUp,
    GcStickDown,
    GcStickLeft,
    GcStickRight,
    GcA,
    GcB,
    GcX,
    GcY,
    GcStart,
    GcL,
    GcR,
    GcZ,
    GcDpadUp,
    GcDpadDown,
    GcDpadLeft,
    GcDpadRight,
    WiiOne,
    WiiTwo,
    WiiPlus,
    WiiMinus,
    WiiHome,
    WiiDpadUp,
    WiiDpadDown,
    WiiDpadLeft,
    WiiDpadRight,
    WiiShake,
    NunchukUp,
    NunchukDown,
    NunchukLeft,
    NunchukRight,
    NunchukZ,
    NunchukC,
    HotkeyPause,
    HotkeyUncapped,
    HotkeyFullscreen,
    HotkeyOverlay,
    HotkeyScreenshot,
    HotkeySaveState,
    HotkeyLoadState,
    HotkeyReleaseMouse,
}

pub const GC_KEY_TARGETS: &[(KeyTarget, &str)] = &[
    (KeyTarget::GcStickUp, "Stick Up"),
    (KeyTarget::GcStickDown, "Stick Down"),
    (KeyTarget::GcStickLeft, "Stick Left"),
    (KeyTarget::GcStickRight, "Stick Right"),
    (KeyTarget::GcA, "A"),
    (KeyTarget::GcB, "B"),
    (KeyTarget::GcX, "X"),
    (KeyTarget::GcY, "Y"),
    (KeyTarget::GcStart, "Start"),
    (KeyTarget::GcL, "L"),
    (KeyTarget::GcR, "R"),
    (KeyTarget::GcZ, "Z"),
    (KeyTarget::GcDpadUp, "D-Pad Up"),
    (KeyTarget::GcDpadDown, "D-Pad Down"),
    (KeyTarget::GcDpadLeft, "D-Pad Left"),
    (KeyTarget::GcDpadRight, "D-Pad Right"),
];

pub const WII_KEY_TARGETS: &[(KeyTarget, &str)] = &[
    (KeyTarget::WiiDpadUp, "D-Pad Up"),
    (KeyTarget::WiiDpadDown, "D-Pad Down"),
    (KeyTarget::WiiDpadLeft, "D-Pad Left"),
    (KeyTarget::WiiDpadRight, "D-Pad Right"),
    (KeyTarget::WiiOne, "1"),
    (KeyTarget::WiiTwo, "2"),
    (KeyTarget::WiiPlus, "Plus"),
    (KeyTarget::WiiMinus, "Minus"),
    (KeyTarget::WiiHome, "Home"),
    (KeyTarget::WiiShake, "Shake"),
    (KeyTarget::NunchukUp, "Nunchuk Up"),
    (KeyTarget::NunchukDown, "Nunchuk Down"),
    (KeyTarget::NunchukLeft, "Nunchuk Left"),
    (KeyTarget::NunchukRight, "Nunchuk Right"),
    (KeyTarget::NunchukZ, "Nunchuk Z"),
    (KeyTarget::NunchukC, "Nunchuk C"),
];

pub const HOTKEY_TARGETS: &[(KeyTarget, &str)] = &[
    (KeyTarget::HotkeyPause, "Pause"),
    (KeyTarget::HotkeyUncapped, "Uncapped"),
    (KeyTarget::HotkeyFullscreen, "Fullscreen"),
    (KeyTarget::HotkeyOverlay, "Overlay"),
    (KeyTarget::HotkeyScreenshot, "Screenshot"),
    (KeyTarget::HotkeySaveState, "Save State"),
    (KeyTarget::HotkeyLoadState, "Load State"),
    (KeyTarget::HotkeyReleaseMouse, "Release Mouse"),
];

pub fn field(config: &mut KeyboardConfig, target: KeyTarget) -> &mut Option<String> {
    match target {
        KeyTarget::GcStickUp => &mut config.gc.stick_up,
        KeyTarget::GcStickDown => &mut config.gc.stick_down,
        KeyTarget::GcStickLeft => &mut config.gc.stick_left,
        KeyTarget::GcStickRight => &mut config.gc.stick_right,
        KeyTarget::GcA => &mut config.gc.a,
        KeyTarget::GcB => &mut config.gc.b,
        KeyTarget::GcX => &mut config.gc.x,
        KeyTarget::GcY => &mut config.gc.y,
        KeyTarget::GcStart => &mut config.gc.start,
        KeyTarget::GcL => &mut config.gc.l,
        KeyTarget::GcR => &mut config.gc.r,
        KeyTarget::GcZ => &mut config.gc.z,
        KeyTarget::GcDpadUp => &mut config.gc.dpad_up,
        KeyTarget::GcDpadDown => &mut config.gc.dpad_down,
        KeyTarget::GcDpadLeft => &mut config.gc.dpad_left,
        KeyTarget::GcDpadRight => &mut config.gc.dpad_right,
        KeyTarget::WiiOne => &mut config.wii.one,
        KeyTarget::WiiTwo => &mut config.wii.two,
        KeyTarget::WiiPlus => &mut config.wii.plus,
        KeyTarget::WiiMinus => &mut config.wii.minus,
        KeyTarget::WiiHome => &mut config.wii.home,
        KeyTarget::WiiDpadUp => &mut config.wii.dpad_up,
        KeyTarget::WiiDpadDown => &mut config.wii.dpad_down,
        KeyTarget::WiiDpadLeft => &mut config.wii.dpad_left,
        KeyTarget::WiiDpadRight => &mut config.wii.dpad_right,
        KeyTarget::WiiShake => &mut config.wii.shake,
        KeyTarget::NunchukUp => &mut config.wii.nunchuk_up,
        KeyTarget::NunchukDown => &mut config.wii.nunchuk_down,
        KeyTarget::NunchukLeft => &mut config.wii.nunchuk_left,
        KeyTarget::NunchukRight => &mut config.wii.nunchuk_right,
        KeyTarget::NunchukZ => &mut config.wii.nunchuk_z,
        KeyTarget::NunchukC => &mut config.wii.nunchuk_c,
        KeyTarget::HotkeyPause => &mut config.hotkeys.pause,
        KeyTarget::HotkeyUncapped => &mut config.hotkeys.uncapped,
        KeyTarget::HotkeyFullscreen => &mut config.hotkeys.fullscreen,
        KeyTarget::HotkeyOverlay => &mut config.hotkeys.overlay,
        KeyTarget::HotkeyScreenshot => &mut config.hotkeys.screenshot,
        KeyTarget::HotkeySaveState => &mut config.hotkeys.save_state,
        KeyTarget::HotkeyLoadState => &mut config.hotkeys.load_state,
        KeyTarget::HotkeyReleaseMouse => &mut config.hotkeys.release_mouse,
    }
}

impl Keymap {
    pub fn code(&self, target: KeyTarget) -> Code {
        match target {
            KeyTarget::GcStickUp => self.gc.stick_up,
            KeyTarget::GcStickDown => self.gc.stick_down,
            KeyTarget::GcStickLeft => self.gc.stick_left,
            KeyTarget::GcStickRight => self.gc.stick_right,
            KeyTarget::GcA => self.gc.a,
            KeyTarget::GcB => self.gc.b,
            KeyTarget::GcX => self.gc.x,
            KeyTarget::GcY => self.gc.y,
            KeyTarget::GcStart => self.gc.start,
            KeyTarget::GcL => self.gc.l,
            KeyTarget::GcR => self.gc.r,
            KeyTarget::GcZ => self.gc.z,
            KeyTarget::GcDpadUp => self.gc.dpad_up,
            KeyTarget::GcDpadDown => self.gc.dpad_down,
            KeyTarget::GcDpadLeft => self.gc.dpad_left,
            KeyTarget::GcDpadRight => self.gc.dpad_right,
            KeyTarget::WiiOne => self.wii.one,
            KeyTarget::WiiTwo => self.wii.two,
            KeyTarget::WiiPlus => self.wii.plus,
            KeyTarget::WiiMinus => self.wii.minus,
            KeyTarget::WiiHome => self.wii.home,
            KeyTarget::WiiDpadUp => self.wii.dpad_up,
            KeyTarget::WiiDpadDown => self.wii.dpad_down,
            KeyTarget::WiiDpadLeft => self.wii.dpad_left,
            KeyTarget::WiiDpadRight => self.wii.dpad_right,
            KeyTarget::WiiShake => self.wii.shake,
            KeyTarget::NunchukUp => self.wii.nunchuk_up,
            KeyTarget::NunchukDown => self.wii.nunchuk_down,
            KeyTarget::NunchukLeft => self.wii.nunchuk_left,
            KeyTarget::NunchukRight => self.wii.nunchuk_right,
            KeyTarget::NunchukZ => self.wii.nunchuk_z,
            KeyTarget::NunchukC => self.wii.nunchuk_c,
            KeyTarget::HotkeyPause => self.hotkeys.pause,
            KeyTarget::HotkeyUncapped => self.hotkeys.uncapped,
            KeyTarget::HotkeyFullscreen => self.hotkeys.fullscreen,
            KeyTarget::HotkeyOverlay => self.hotkeys.overlay,
            KeyTarget::HotkeyScreenshot => self.hotkeys.screenshot,
            KeyTarget::HotkeySaveState => self.hotkeys.save_state,
            KeyTarget::HotkeyLoadState => self.hotkeys.load_state,
            KeyTarget::HotkeyReleaseMouse => self.hotkeys.release_mouse,
        }
    }
}

impl KeyboardConfig {
    pub fn resolve(&self) -> Keymap {
        let mut keymap = Keymap::default();

        self::set(&mut keymap.gc.stick_up, &self.gc.stick_up);
        self::set(&mut keymap.gc.stick_down, &self.gc.stick_down);
        self::set(&mut keymap.gc.stick_left, &self.gc.stick_left);
        self::set(&mut keymap.gc.stick_right, &self.gc.stick_right);
        self::set(&mut keymap.gc.a, &self.gc.a);
        self::set(&mut keymap.gc.b, &self.gc.b);
        self::set(&mut keymap.gc.x, &self.gc.x);
        self::set(&mut keymap.gc.y, &self.gc.y);
        self::set(&mut keymap.gc.start, &self.gc.start);
        self::set(&mut keymap.gc.l, &self.gc.l);
        self::set(&mut keymap.gc.r, &self.gc.r);
        self::set(&mut keymap.gc.z, &self.gc.z);
        self::set(&mut keymap.gc.dpad_up, &self.gc.dpad_up);
        self::set(&mut keymap.gc.dpad_down, &self.gc.dpad_down);
        self::set(&mut keymap.gc.dpad_left, &self.gc.dpad_left);
        self::set(&mut keymap.gc.dpad_right, &self.gc.dpad_right);

        self::set(&mut keymap.wii.one, &self.wii.one);
        self::set(&mut keymap.wii.two, &self.wii.two);
        self::set(&mut keymap.wii.plus, &self.wii.plus);
        self::set(&mut keymap.wii.minus, &self.wii.minus);
        self::set(&mut keymap.wii.home, &self.wii.home);
        self::set(&mut keymap.wii.dpad_up, &self.wii.dpad_up);
        self::set(&mut keymap.wii.dpad_down, &self.wii.dpad_down);
        self::set(&mut keymap.wii.dpad_left, &self.wii.dpad_left);
        self::set(&mut keymap.wii.dpad_right, &self.wii.dpad_right);
        self::set(&mut keymap.wii.shake, &self.wii.shake);
        self::set(&mut keymap.wii.nunchuk_up, &self.wii.nunchuk_up);
        self::set(&mut keymap.wii.nunchuk_down, &self.wii.nunchuk_down);
        self::set(&mut keymap.wii.nunchuk_left, &self.wii.nunchuk_left);
        self::set(&mut keymap.wii.nunchuk_right, &self.wii.nunchuk_right);
        self::set(&mut keymap.wii.nunchuk_z, &self.wii.nunchuk_z);
        self::set(&mut keymap.wii.nunchuk_c, &self.wii.nunchuk_c);

        self::set(&mut keymap.hotkeys.pause, &self.hotkeys.pause);
        self::set(&mut keymap.hotkeys.uncapped, &self.hotkeys.uncapped);
        self::set(&mut keymap.hotkeys.fullscreen, &self.hotkeys.fullscreen);
        self::set(&mut keymap.hotkeys.overlay, &self.hotkeys.overlay);
        self::set(&mut keymap.hotkeys.screenshot, &self.hotkeys.screenshot);
        self::set(&mut keymap.hotkeys.save_state, &self.hotkeys.save_state);
        self::set(&mut keymap.hotkeys.load_state, &self.hotkeys.load_state);
        self::set(&mut keymap.hotkeys.release_mouse, &self.hotkeys.release_mouse);

        keymap
    }
}

fn set(slot: &mut Code, name: &Option<String>) {
    let Some(name) = name.as_deref() else {
        return;
    };

    match self::parse_key(name) {
        Some(code) => *slot = code,
        None => tracing::warn!(key = name, "unknown key name in config, keeping default"),
    }
}

pub fn key_label(code: Code) -> String {
    match self::key_name(code) {
        Some(name) => self::title_case(name),
        None => "Unsupported".to_owned(),
    }
}

fn title_case(name: &str) -> String {
    name.split('_')
        .map(|word| {
            let mut chars = word.chars();
            match chars.next() {
                Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
                None => String::new(),
            }
        })
        .collect::<Vec<_>>()
        .join(" ")
}

macro_rules! key_names {
    ($($variant:ident => $name:literal),* $(,)?) => {
        pub fn key_name(code: Code) -> Option<&'static str> {
            match code {
                $( Code::$variant => Some($name), )*
                _ => None,
            }
        }

        pub fn parse_key(name: &str) -> Option<Code> {
            match name {
                $( $name => Some(Code::$variant), )*
                _ => None,
            }
        }
    };
}

key_names! {
    KeyA => "a", KeyB => "b", KeyC => "c", KeyD => "d", KeyE => "e", KeyF => "f",
    KeyG => "g", KeyH => "h", KeyI => "i", KeyJ => "j", KeyK => "k", KeyL => "l",
    KeyM => "m", KeyN => "n", KeyO => "o", KeyP => "p", KeyQ => "q", KeyR => "r",
    KeyS => "s", KeyT => "t", KeyU => "u", KeyV => "v", KeyW => "w", KeyX => "x",
    KeyY => "y", KeyZ => "z",
    Digit0 => "0", Digit1 => "1", Digit2 => "2", Digit3 => "3", Digit4 => "4",
    Digit5 => "5", Digit6 => "6", Digit7 => "7", Digit8 => "8", Digit9 => "9",
    ArrowUp => "up", ArrowDown => "down", ArrowLeft => "left", ArrowRight => "right",
    Space => "space", Enter => "enter", Tab => "tab", Escape => "escape",
    Backspace => "backspace", Delete => "delete", Insert => "insert",
    Home => "home", End => "end", PageUp => "page_up", PageDown => "page_down",
    CapsLock => "caps_lock",
    ShiftLeft => "shift_left", ShiftRight => "shift_right",
    ControlLeft => "ctrl_left", ControlRight => "ctrl_right",
    AltLeft => "alt_left", AltRight => "alt_right",
    SuperLeft => "super_left", SuperRight => "super_right",
    Minus => "minus", Equal => "equal", Comma => "comma", Period => "period",
    Slash => "slash", Semicolon => "semicolon", Quote => "quote",
    Backquote => "backquote", Backslash => "backslash",
    BracketLeft => "bracket_left", BracketRight => "bracket_right",
    F1 => "f1", F2 => "f2", F3 => "f3", F4 => "f4", F5 => "f5", F6 => "f6",
    F7 => "f7", F8 => "f8", F9 => "f9", F10 => "f10", F11 => "f11", F12 => "f12",
    Numpad0 => "numpad_0", Numpad1 => "numpad_1", Numpad2 => "numpad_2",
    Numpad3 => "numpad_3", Numpad4 => "numpad_4", Numpad5 => "numpad_5",
    Numpad6 => "numpad_6", Numpad7 => "numpad_7", Numpad8 => "numpad_8",
    Numpad9 => "numpad_9", NumpadEnter => "numpad_enter", NumpadAdd => "numpad_add",
    NumpadSubtract => "numpad_subtract", NumpadMultiply => "numpad_multiply",
    NumpadDivide => "numpad_divide", NumpadDecimal => "numpad_decimal",
}