use crate::input::{ButtonState, KeyCode, Modifiers, MouseButton, ScrollUnits, Theme, ViewportEvent};
pub fn from_winit(event: &::winit::event::WindowEvent, scale_factor: f32) -> Option<ViewportEvent> {
use ::winit::event::{MouseScrollDelta, WindowEvent};
let inv_scale = 1.0 / scale_factor.max(0.001);
match event {
WindowEvent::CursorMoved { position, .. } => Some(ViewportEvent::PointerMoved {
position: glam::Vec2::new(position.x as f32, position.y as f32) * inv_scale,
}),
WindowEvent::CursorLeft { .. } => Some(ViewportEvent::PointerLeft),
WindowEvent::MouseInput { state, button, .. } => Some(ViewportEvent::MouseButton {
button: map_button(*button)?,
state: map_state(*state),
}),
WindowEvent::MouseWheel { delta, .. } => {
let (delta, units) = match delta {
MouseScrollDelta::LineDelta(x, y) => (glam::Vec2::new(*x, *y), ScrollUnits::Lines),
MouseScrollDelta::PixelDelta(p) => {
(glam::Vec2::new(p.x as f32, p.y as f32), ScrollUnits::Pixels)
}
};
Some(ViewportEvent::Wheel { delta, units })
}
WindowEvent::ModifiersChanged(mods) => {
let s = mods.state();
Some(ViewportEvent::ModifiersChanged(Modifiers {
alt: s.alt_key(),
shift: s.shift_key(),
ctrl: s.control_key() || s.super_key(),
}))
}
WindowEvent::Focused(false) => Some(ViewportEvent::FocusLost),
WindowEvent::KeyboardInput { event, .. } => {
let key = map_key(&event.physical_key)?;
Some(ViewportEvent::Key {
key,
state: map_state(event.state),
repeat: event.repeat,
})
}
WindowEvent::ThemeChanged(theme) => Some(ViewportEvent::ThemeChanged(match theme {
::winit::window::Theme::Light => Theme::Light,
::winit::window::Theme::Dark => Theme::Dark,
})),
WindowEvent::Occluded(occluded) => Some(ViewportEvent::Occluded(*occluded)),
WindowEvent::RotationGesture { delta, .. } => {
Some(ViewportEvent::TrackpadRotate(delta.to_radians()))
}
WindowEvent::PinchGesture { delta, .. } => {
Some(ViewportEvent::TrackpadPinch(*delta as f32))
}
WindowEvent::PanGesture { delta, .. } => Some(ViewportEvent::TrackpadPan(
glam::Vec2::new(delta.x, delta.y) * inv_scale,
)),
WindowEvent::DroppedFile(path) => Some(ViewportEvent::FileDropped(path.clone())),
WindowEvent::HoveredFile(path) => Some(ViewportEvent::FileHovered(path.clone())),
WindowEvent::HoveredFileCancelled => Some(ViewportEvent::FileHoverCancelled),
_ => None,
}
}
pub fn from_winit_device(event: &::winit::event::DeviceEvent) -> Option<ViewportEvent> {
use ::winit::event::DeviceEvent;
match event {
DeviceEvent::MouseMotion { delta } => Some(ViewportEvent::RawMotion {
delta: glam::Vec2::new(delta.0 as f32, delta.1 as f32),
}),
_ => None,
}
}
fn map_state(state: ::winit::event::ElementState) -> ButtonState {
match state {
::winit::event::ElementState::Pressed => ButtonState::Pressed,
::winit::event::ElementState::Released => ButtonState::Released,
}
}
fn map_button(button: ::winit::event::MouseButton) -> Option<MouseButton> {
match button {
::winit::event::MouseButton::Left => Some(MouseButton::Left),
::winit::event::MouseButton::Right => Some(MouseButton::Right),
::winit::event::MouseButton::Middle => Some(MouseButton::Middle),
::winit::event::MouseButton::Back => Some(MouseButton::Back),
::winit::event::MouseButton::Forward => Some(MouseButton::Forward),
::winit::event::MouseButton::Other(n) => Some(MouseButton::Other(n)),
}
}
fn map_key(key: &::winit::keyboard::PhysicalKey) -> Option<KeyCode> {
use ::winit::keyboard::{KeyCode as W, PhysicalKey};
let PhysicalKey::Code(code) = key else {
return None;
};
let k = match code {
W::KeyA => KeyCode::A,
W::KeyB => KeyCode::B,
W::KeyC => KeyCode::C,
W::KeyD => KeyCode::D,
W::KeyE => KeyCode::E,
W::KeyF => KeyCode::F,
W::KeyG => KeyCode::G,
W::KeyH => KeyCode::H,
W::KeyI => KeyCode::I,
W::KeyJ => KeyCode::J,
W::KeyK => KeyCode::K,
W::KeyL => KeyCode::L,
W::KeyM => KeyCode::M,
W::KeyN => KeyCode::N,
W::KeyO => KeyCode::O,
W::KeyP => KeyCode::P,
W::KeyQ => KeyCode::Q,
W::KeyR => KeyCode::R,
W::KeyS => KeyCode::S,
W::KeyT => KeyCode::T,
W::KeyU => KeyCode::U,
W::KeyV => KeyCode::V,
W::KeyW => KeyCode::W,
W::KeyX => KeyCode::X,
W::KeyY => KeyCode::Y,
W::KeyZ => KeyCode::Z,
W::Digit0 => KeyCode::Num0,
W::Digit1 => KeyCode::Num1,
W::Digit2 => KeyCode::Num2,
W::Digit3 => KeyCode::Num3,
W::Digit4 => KeyCode::Num4,
W::Digit5 => KeyCode::Num5,
W::Digit6 => KeyCode::Num6,
W::Digit7 => KeyCode::Num7,
W::Digit8 => KeyCode::Num8,
W::Digit9 => KeyCode::Num9,
W::Escape => KeyCode::Escape,
W::Enter => KeyCode::Enter,
W::Tab => KeyCode::Tab,
W::Space => KeyCode::Space,
W::Backspace => KeyCode::Backspace,
W::ArrowUp => KeyCode::Up,
W::ArrowDown => KeyCode::Down,
W::ArrowLeft => KeyCode::Left,
W::ArrowRight => KeyCode::Right,
W::ShiftLeft => KeyCode::LeftShift,
W::ShiftRight => KeyCode::RightShift,
W::Minus => KeyCode::Minus,
W::Comma => KeyCode::Comma,
W::Period => KeyCode::Period,
W::Slash => KeyCode::Slash,
W::Backquote => KeyCode::Backtick,
W::Backslash => KeyCode::Backslash,
W::BracketLeft => KeyCode::LeftBracket,
W::BracketRight => KeyCode::RightBracket,
W::Semicolon => KeyCode::Semicolon,
W::Quote => KeyCode::Apostrophe,
W::Equal => KeyCode::Equals,
W::Delete => KeyCode::Delete,
W::Insert => KeyCode::Insert,
W::Home => KeyCode::Home,
W::End => KeyCode::End,
W::PageUp => KeyCode::PageUp,
W::PageDown => KeyCode::PageDown,
W::CapsLock => KeyCode::CapsLock,
W::ControlLeft => KeyCode::LeftCtrl,
W::ControlRight => KeyCode::RightCtrl,
W::AltLeft => KeyCode::LeftAlt,
W::AltRight => KeyCode::RightAlt,
W::SuperLeft => KeyCode::LeftSuper,
W::SuperRight => KeyCode::RightSuper,
W::NumLock => KeyCode::NumLock,
W::PrintScreen => KeyCode::PrintScreen,
W::Pause => KeyCode::Pause,
W::ScrollLock => KeyCode::ScrollLock,
W::F1 => KeyCode::F1,
W::F2 => KeyCode::F2,
W::F3 => KeyCode::F3,
W::F4 => KeyCode::F4,
W::F5 => KeyCode::F5,
W::F6 => KeyCode::F6,
W::F7 => KeyCode::F7,
W::F8 => KeyCode::F8,
W::F9 => KeyCode::F9,
W::F10 => KeyCode::F10,
W::F11 => KeyCode::F11,
W::F12 => KeyCode::F12,
W::F13 => KeyCode::F13,
W::F14 => KeyCode::F14,
W::F15 => KeyCode::F15,
W::F16 => KeyCode::F16,
W::F17 => KeyCode::F17,
W::F18 => KeyCode::F18,
W::F19 => KeyCode::F19,
W::F20 => KeyCode::F20,
W::F21 => KeyCode::F21,
W::F22 => KeyCode::F22,
W::F23 => KeyCode::F23,
W::F24 => KeyCode::F24,
W::Numpad0 => KeyCode::Numpad0,
W::Numpad1 => KeyCode::Numpad1,
W::Numpad2 => KeyCode::Numpad2,
W::Numpad3 => KeyCode::Numpad3,
W::Numpad4 => KeyCode::Numpad4,
W::Numpad5 => KeyCode::Numpad5,
W::Numpad6 => KeyCode::Numpad6,
W::Numpad7 => KeyCode::Numpad7,
W::Numpad8 => KeyCode::Numpad8,
W::Numpad9 => KeyCode::Numpad9,
W::NumpadAdd => KeyCode::NumpadAdd,
W::NumpadSubtract => KeyCode::NumpadSubtract,
W::NumpadMultiply => KeyCode::NumpadMultiply,
W::NumpadDivide => KeyCode::NumpadDivide,
W::NumpadDecimal => KeyCode::NumpadDecimal,
W::NumpadEnter => KeyCode::NumpadEnter,
_ => return None,
};
Some(k)
}
#[cfg(test)]
mod tests {
use super::*;
use ::winit::event::{ElementState, MouseButton as WinitMouseButton};
use ::winit::keyboard::{KeyCode as Wk, PhysicalKey};
macro_rules! key_pairs {
($($lib:ident => $winit:ident),* $(,)?) => {
const ALL_KEYCODES: &[KeyCode] = &[$(KeyCode::$lib),*];
fn winit_key_for(k: KeyCode) -> Wk {
match k { $(KeyCode::$lib => Wk::$winit),* }
}
};
}
key_pairs! {
A => KeyA, B => KeyB, C => KeyC, D => KeyD, E => KeyE, F => KeyF, G => KeyG,
H => KeyH, I => KeyI, J => KeyJ, K => KeyK, L => KeyL, M => KeyM, N => KeyN,
O => KeyO, P => KeyP, Q => KeyQ, R => KeyR, S => KeyS, T => KeyT, U => KeyU,
V => KeyV, W => KeyW, X => KeyX, Y => KeyY, Z => KeyZ,
Num0 => Digit0, Num1 => Digit1, Num2 => Digit2, Num3 => Digit3, Num4 => Digit4,
Num5 => Digit5, Num6 => Digit6, Num7 => Digit7, Num8 => Digit8, Num9 => Digit9,
Tab => Tab, Enter => Enter, Escape => Escape, Backtick => Backquote,
Backspace => Backspace, Comma => Comma, Period => Period,
LeftBracket => BracketLeft, RightBracket => BracketRight, Slash => Slash,
LeftShift => ShiftLeft, RightShift => ShiftRight, Space => Space,
Up => ArrowUp, Down => ArrowDown, Left => ArrowLeft, Right => ArrowRight,
F1 => F1, F2 => F2, F3 => F3, F4 => F4, F5 => F5, F6 => F6, F7 => F7,
F8 => F8, F9 => F9, F10 => F10, F11 => F11, F12 => F12, F13 => F13,
F14 => F14, F15 => F15, F16 => F16, F17 => F17, F18 => F18, F19 => F19,
F20 => F20, F21 => F21, F22 => F22, F23 => F23, F24 => F24,
Semicolon => Semicolon, Apostrophe => Quote, Backslash => Backslash,
Minus => Minus, Equals => Equal, LeftCtrl => ControlLeft,
RightCtrl => ControlRight, LeftAlt => AltLeft, RightAlt => AltRight,
LeftSuper => SuperLeft, RightSuper => SuperRight, CapsLock => CapsLock,
Delete => Delete, Insert => Insert, Home => Home, End => End,
PageUp => PageUp, PageDown => PageDown,
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, NumpadDecimal => NumpadDecimal,
NumpadEnter => NumpadEnter, NumLock => NumLock, PrintScreen => PrintScreen,
Pause => Pause, ScrollLock => ScrollLock,
}
#[test]
fn every_defined_key_maps_from_winit() {
for &code in ALL_KEYCODES {
let winit = winit_key_for(code);
assert_eq!(
map_key(&PhysicalKey::Code(winit)),
Some(code),
"winit {winit:?} should map to KeyCode::{code:?}"
);
}
}
#[test]
fn unmapped_physical_key_is_none() {
assert_eq!(map_key(&PhysicalKey::Code(Wk::Fn)), None);
assert_eq!(map_key(&PhysicalKey::Code(Wk::ContextMenu)), None);
assert_eq!(
map_key(&PhysicalKey::Unidentified(
::winit::keyboard::NativeKeyCode::Unidentified
)),
None
);
}
#[test]
fn mouse_buttons_map_including_extras() {
assert_eq!(map_button(WinitMouseButton::Left), Some(MouseButton::Left));
assert_eq!(
map_button(WinitMouseButton::Right),
Some(MouseButton::Right)
);
assert_eq!(
map_button(WinitMouseButton::Middle),
Some(MouseButton::Middle)
);
assert_eq!(map_button(WinitMouseButton::Back), Some(MouseButton::Back));
assert_eq!(
map_button(WinitMouseButton::Forward),
Some(MouseButton::Forward)
);
assert_eq!(
map_button(WinitMouseButton::Other(9)),
Some(MouseButton::Other(9))
);
}
#[test]
fn element_state_maps() {
assert_eq!(map_state(ElementState::Pressed), ButtonState::Pressed);
assert_eq!(map_state(ElementState::Released), ButtonState::Released);
}
#[test]
fn theme_and_occlusion_translate() {
use ::winit::event::WindowEvent;
use ::winit::window::Theme as WinitTheme;
assert!(matches!(
from_winit(&WindowEvent::ThemeChanged(WinitTheme::Dark), 1.0),
Some(ViewportEvent::ThemeChanged(Theme::Dark))
));
assert!(matches!(
from_winit(&WindowEvent::ThemeChanged(WinitTheme::Light), 1.0),
Some(ViewportEvent::ThemeChanged(Theme::Light))
));
assert!(matches!(
from_winit(&WindowEvent::Occluded(true), 1.0),
Some(ViewportEvent::Occluded(true))
));
assert!(matches!(
from_winit(&WindowEvent::Occluded(false), 1.0),
Some(ViewportEvent::Occluded(false))
));
}
#[test]
fn file_drag_and_drop_translates() {
use ::winit::event::WindowEvent;
use std::path::PathBuf;
let path = PathBuf::from("/tmp/model.obj");
assert!(matches!(
from_winit(&WindowEvent::DroppedFile(path.clone()), 1.0),
Some(ViewportEvent::FileDropped(p)) if p == path
));
assert!(matches!(
from_winit(&WindowEvent::HoveredFile(path.clone()), 1.0),
Some(ViewportEvent::FileHovered(p)) if p == path
));
assert!(matches!(
from_winit(&WindowEvent::HoveredFileCancelled, 1.0),
Some(ViewportEvent::FileHoverCancelled)
));
}
#[test]
fn raw_device_motion_translates() {
use ::winit::event::DeviceEvent;
assert!(matches!(
from_winit_device(&DeviceEvent::MouseMotion { delta: (3.0, -4.0) }),
Some(ViewportEvent::RawMotion { delta }) if delta == glam::Vec2::new(3.0, -4.0)
));
assert!(from_winit_device(&DeviceEvent::MouseWheel {
delta: ::winit::event::MouseScrollDelta::LineDelta(0.0, 1.0)
})
.is_none());
}
}