SolarEngine/solar_engine/src/input.rs

use log::info;
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::*;
    use winit::keyboard::NamedKey;
    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(named_key) => match named_key {
            NamedKey::ArrowUp => ArrowUp,
            NamedKey::ArrowDown => ArrowDown,
            NamedKey::ArrowLeft => ArrowLeft,
            NamedKey::ArrowRight => ArrowRight,
            NamedKey::Escape => Escape,
            NamedKey::Enter => Enter,
            NamedKey::Tab => Tab,
            NamedKey::Space => Space,
            NamedKey::Backspace => Backspace,
            NamedKey::Insert => Insert,
            NamedKey::Delete => Delete,
            NamedKey::Home => Home,
            NamedKey::End => End,
            NamedKey::PageUp => PageUp,
            NamedKey::PageDown => PageDown,
            NamedKey::Shift => Shift,
            NamedKey::Control => Control,
            NamedKey::Alt => Alt,
            NamedKey::Super => Super,
            NamedKey::F1 => F1,
            NamedKey::F2 => F2,
            NamedKey::F3 => F3,
            NamedKey::F4 => F4,
            NamedKey::F5 => F5,
            NamedKey::F6 => F6,
            NamedKey::F7 => F7,
            NamedKey::F8 => F8,
            NamedKey::F9 => F9,
            NamedKey::F10 => F10,
            NamedKey::F11 => F11,
            NamedKey::F12 => F12,
            _ => Unknown,
        },
        _ => Unknown,
    }
}