SolarEngine/solar_engine/src/input.rs

use winit::event::{ElementState, KeyEvent, Modifiers};
use winit::keyboard::{Key as WinitKey, ModifiersKeyState};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Key {
    // Symbols
    Comma, Period, Minus, Plus, Slash, Backslash, Semicolon, Apostrophe,
    LeftBracket, RightBracket, Grave, Equal,

    // Digits
    Num0, Num1, Num2, Num3, Num4, Num5, Num6, Num7, Num8, Num9,

    // Letters
    A, B, C, D, E, F, G, H, I, J, K, L, M,
    N, O, P, Q, R, S, T, U, V, W, X, Y, Z,

    // Arrows
    ArrowUp, ArrowDown, ArrowLeft, ArrowRight,

    // Controls
    Escape, Enter, Space, Tab, Backspace,
    Insert, Delete, Home, End, PageUp, PageDown,

    // Modifier keys
    Shift, Control, Alt, Super,

    // Function keys
    F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,

    // Numpad
    Numpad0, Numpad1, Numpad2, Numpad3, Numpad4,
    Numpad5, Numpad6, Numpad7, Numpad8, Numpad9,
    NumpadAdd, NumpadSubtract, NumpadMultiply, NumpadDivide, NumpadEnter,

    // Unknown
    Unknown,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyState {
    Pressed,
    Released,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct KeyModifiers {
    pub lshift: bool,
    pub rshift: bool,
    pub lcontrol: bool,
    pub rcontrol: bool,
    pub lalt: bool,
    pub ralt: bool,
    pub rsuper_key: bool,
    pub lsuper_key: bool,
}

#[derive(Debug, Clone)]
pub struct InputEvent {
    pub key: Key,
    pub state: KeyState,
    pub text: String,
    pub modifiers: KeyModifiers,
}

pub fn from_winit_input(event: &KeyEvent, modifiers: Modifiers) -> InputEvent {
    InputEvent {
        key: map_winit_key(&event.logical_key),
        state: match event.state {
            ElementState::Pressed => KeyState::Pressed,
            ElementState::Released => KeyState::Released,
        },
        text: event.text.clone().unwrap_or_default().into(),
        modifiers: KeyModifiers {
            lshift: modifiers.lshift_state() == ModifiersKeyState::Pressed,
            rshift: modifiers.rshift_state() == ModifiersKeyState::Pressed,
            lcontrol: modifiers.lcontrol_state() == ModifiersKeyState::Pressed,
            rcontrol: modifiers.rcontrol_state() == ModifiersKeyState::Pressed,
            lalt: modifiers.lalt_state() == ModifiersKeyState::Pressed,
            ralt: modifiers.ralt_state() == ModifiersKeyState::Pressed,
            rsuper_key: modifiers.rsuper_state() == ModifiersKeyState::Pressed,
            lsuper_key: modifiers.lsuper_state() == ModifiersKeyState::Pressed,
        },
    }
}

pub fn map_winit_key(key: &WinitKey) -> Key {
    use Key::*;
    match key {
        WinitKey::Character(s) => match s.as_str() {
            "a" | "A" => A,
            "b" | "B" => B,
            "c" | "C" => C,
            "d" | "D" => D,
            "e" | "E" => E,
            "f" | "F" => F,
            "g" | "G" => G,
            "h" | "H" => H,
            "i" | "I" => I,
            "j" | "J" => J,
            "k" | "K" => K,
            "l" | "L" => L,
            "m" | "M" => M,
            "n" | "N" => N,
            "o" | "O" => O,
            "p" | "P" => P,
            "q" | "Q" => Q,
            "r" | "R" => R,
            "s" | "S" => S,
            "t" | "T" => T,
            "u" | "U" => U,
            "v" | "V" => V,
            "w" | "W" => W,
            "x" | "X" => X,
            "y" | "Y" => Y,
            "z" | "Z" => Z,
            "0" => Num0,
            "1" => Num1,
            "2" => Num2,
            "3" => Num3,
            "4" => Num4,
            "5" => Num5,
            "6" => Num6,
            "7" => Num7,
            "8" => Num8,
            "9" => Num9,
            "," => Comma,
            "." => Period,
            "-" => Minus,
            "+" => Plus,
            "/" => Slash,
            "\\" => Backslash,
            ";" => Semicolon,
            "'" => Apostrophe,
            "[" => LeftBracket,
            "]" => RightBracket,
            "`" => Grave,
            "=" => Equal,
            _ => Unknown,
        },
        WinitKey::Named(n) => match n.to_text().unwrap_or("") {
            "ArrowUp" => ArrowUp,
            "ArrowDown" => ArrowDown,
            "ArrowLeft" => ArrowLeft,
            "ArrowRight" => ArrowRight,
            "Escape" => Escape,
            "Enter" => Enter,
            "Tab" => Tab,
            "Space" => Space,
            "Backspace" => Backspace,
            "Insert" => Insert,
            "Delete" => Delete,
            "Home" => Home,
            "End" => End,
            "PageUp" => PageUp,
            "PageDown" => PageDown,
            "Shift" => Shift,
            "Control" => Control,
            "Alt" => Alt,
            "Super" => Super,
            "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" => Numpad0,
            "Numpad1" => Numpad1,
            "Numpad2" => Numpad2,
            "Numpad3" => Numpad3,
            "Numpad4" => Numpad4,
            "Numpad5" => Numpad5,
            "Numpad6" => Numpad6,
            "Numpad7" => Numpad7,
            "Numpad8" => Numpad8,
            "Numpad9" => Numpad9,
            "NumpadAdd" => NumpadAdd,
            "NumpadSubtract" => NumpadSubtract,
            "NumpadMultiply" => NumpadMultiply,
            "NumpadDivide" => NumpadDivide,
            "NumpadEnter" => NumpadEnter,
            _ => Unknown,
        },
        _ => Unknown,
    }
}