#![deny(missing_docs)]

//! A Glutin window back-end for the Piston game engine.

extern crate glutin;

extern crate gl;

extern crate glutin_winit;

extern crate input;

extern crate raw_window_handle;

extern crate window;

extern crate winit;

extern crate shader_version;

extern crate rustc_hash;

use rustc_hash::FxHashMap;

use std::collections::VecDeque;

use std::error::Error;

// External crates.

use input::{

ButtonArgs,

ButtonState,

CloseArgs,

Event,

Key,

Motion,

MouseButton,

Button,

Input,

ResizeArgs,

};

use window::{

BuildFromWindowSettings,

OpenGLWindow,

Window,

AdvancedWindow,

ProcAddress,

WindowSettings,

Size,

Position,

Api,

UnsupportedGraphicsApiError,

};

use winit::{

application::ApplicationHandler,

dpi::{LogicalPosition, LogicalSize},

event_loop::{ActiveEventLoop, EventLoop},

event::{DeviceId, ElementState, MouseScrollDelta, WindowEvent},

window::WindowId,

};

use glutin::context::PossiblyCurrentGlContext;

use glutin::display::GlDisplay;

use glutin::prelude::GlSurface;

use std::time::Duration;

use std::sync::Arc;

pub use shader_version::OpenGL;

/// Settings for whether to ignore modifiers and use standard keyboard layouts instead.

///

/// This does not affect `piston::input::TextEvent`.

///

/// Piston uses the same key codes as in SDL2.

/// The problem is that without knowing the keyboard layout,

/// there is no coherent way of generating key codes.

///

/// This option choose different tradeoffs depending on need.

#[derive(Copy, Clone, PartialEq, Eq, Debug)]

pub enum KeyboardIgnoreModifiers {

/// Keep the key codes that are affected by modifiers.

///

/// This is a good default for most applications.

/// However, make sure to display understandable information to the user.

///

/// If you experience user problems among gamers,

/// then you might consider allowing other options in your game engine.

/// Some gamers might be used to how stuff works in other traditional game engines

/// and struggle understanding this configuration, depending on how you use keyboard layout.

None,

/// Assume the user's keyboard layout is standard English ABC.

///

/// In some non-English speaking countries, this might be more user friendly for some gamers.

///

/// This might sound counter-intuitive at first, so here is the reason:

///

/// Gamers can customize their keyboard layout without needing to understand scan codes.

/// When gamers want physically accuracy with good default options,

/// they can simply use standard English ABC.

///

/// In other cases, this option displays understandable information for game instructions.

/// This information makes it easier for users to correct the problem themselves.

///

/// Most gaming consoles use standard controllers.

/// Typically, the only device that might be problematic for users is the keyboard.

/// Instead of solving this problem in your game engine, let users do it in the OS.

///

/// This option gives more control to users and is also better for user data privacy.

/// Detecting keyboard layout is usually not needed.

/// Instead, provide options for the user where they can modify the keys.

/// If users want to switch layout in the middle of a game, they can do it through the OS.

AbcKeyCode,

}

/// Contains stuff for game window.

pub struct GlutinWindow {

/// The OpenGL context.

pub ctx: Option<glutin::context::PossiblyCurrentContext>,

/// The window surface.

pub surface: Option<glutin::surface::Surface<glutin::surface::WindowSurface>>,

/// The graphics display.

pub display: Option<glutin::display::Display>,

/// The event loop of the window.

///

/// This is optional because when pumping events using `ApplicationHandler`,

/// the event loop can not be owned by `WinitWindow`.

pub event_loop: Option<EventLoop<UserEvent>>,

/// Sets keyboard layout.

///

/// When set, the key codes are

pub keyboard_ignore_modifiers: KeyboardIgnoreModifiers,

/// The Winit window.

///

/// This is optional because when creating the window,

/// it is only accessible by `ActiveEventLoop::create_window`,

/// which in turn requires `ApplicationHandler`.

/// One call to `Window::pull_event` is needed to trigger

/// Winit to call `ApplicationHandler::request_redraw`,

/// which creates the window.

pub window: Option<Arc<winit::window::Window>>,

/// Keeps track of connected devices.

pub devices: u32,

/// Maps device id to a unique id used by Piston.

pub device_id_map: FxHashMap<DeviceId, u32>,

// The window settings that created the window.

settings: WindowSettings,

// The back-end does not remember the title.

title: String,

exit_on_esc: bool,

should_close: bool,

automatic_close: bool,

// Used to fake capturing of cursor,

// to get relative mouse events.

is_capturing_cursor: bool,

// Stores the last known cursor position.

last_cursor_pos: Option<[f64; 2]>,

// Stores relative coordinates to emit on next poll.

mouse_relative: Option<(f64, f64)>,

// Used to emit cursor event after enter/leave.

cursor_pos: Option<[f64; 2]>,

// Used to filter repeated key presses (does not affect text repeat).

last_key_pressed: Option<input::Key>,

// Stores list of events ready for processing.

events: VecDeque<Event>,

}

fn graphics_api_from_settings(settings: &WindowSettings) -> Result<Api, Box<dyn Error>> {

let api = settings.get_maybe_graphics_api().unwrap_or(Api::opengl(3, 2));

if api.api != "OpenGL" {

return Err(UnsupportedGraphicsApiError {

found: api.api,

expected: vec!["OpenGL".into()]

}.into());

};

Ok(api)

}

fn surface_attributes_builder_from_settings(

settings: &WindowSettings

) -> glutin::surface::SurfaceAttributesBuilder<glutin::surface::WindowSurface> {

glutin::surface::SurfaceAttributesBuilder::<glutin::surface::WindowSurface>::new()

.with_srgb(Some(settings.get_srgb()))

}

fn config_template_builder_from_settings(

settings: &WindowSettings

) -> glutin::config::ConfigTemplateBuilder {

let x = glutin::config::ConfigTemplateBuilder::new()

.with_transparency(settings.get_transparent());

let samples = settings.get_samples();

if samples == 0 {x} else {

x.with_multisampling(samples)

}

}

impl GlutinWindow {

/// Creates a new game window for Glutin.

pub fn new(settings: &WindowSettings) -> Result<Self, Box<dyn Error>> {

let event_loop = winit::event_loop::EventLoop::with_user_event().build()?;

Self::from_event_loop(settings, event_loop)

}

/// Creates a game window from a pre-existing Glutin event loop.

pub fn from_event_loop(

settings: &WindowSettings,

event_loop: winit::event_loop::EventLoop<UserEvent>,

) -> Result<Self, Box<dyn Error>> {

let title = settings.get_title();

let exit_on_esc = settings.get_exit_on_esc();

let mut w = GlutinWindow {

ctx: None,

display: None,

surface: None,

window: None,

title,

exit_on_esc,

settings: settings.clone(),

should_close: false,

automatic_close: settings.get_automatic_close(),

cursor_pos: None,

is_capturing_cursor: false,

last_cursor_pos: None,

mouse_relative: None,

last_key_pressed: None,

event_loop: Some(event_loop),

keyboard_ignore_modifiers: KeyboardIgnoreModifiers::None,

events: VecDeque::new(),

devices: 0,

device_id_map: FxHashMap::default(),

};

// Causes the window to be created through `ApplicationHandler::request_redraw`.

if let Some(e) = w.poll_event() {w.events.push_front(e)}

Ok(w)

}

/// Gets a reference to the window.

///

/// This is faster than [get_window], but borrows self.

pub fn get_window_ref(&self) -> &winit::window::Window {

self.window.as_ref().unwrap()

}

/// Returns a cloned smart pointer to the underlying Winit window.

pub fn get_window(&self) -> Arc<winit::window::Window> {

self.window.as_ref().unwrap().clone()

}

// These events are emitted before popping a new event from the queue.

// This is because Piston handles some events separately.

fn pre_pop_front_event(&mut self) -> Option<Input> {

use input::Motion;

// Check for a pending mouse cursor move event.

if let Some(pos) = self.cursor_pos {

self.cursor_pos = None;

return Some(Input::Move(Motion::MouseCursor(pos)));

}

// Check for a pending relative mouse move event.

if let Some((x, y)) = self.mouse_relative {

self.mouse_relative = None;

return Some(Input::Move(Motion::MouseRelative([x, y])));

}

None

}

/// Convert an incoming Winit event to Piston input.

/// Update cursor state if necessary.

///

/// The `unknown` flag is set to `true` when the event is not recognized.

/// This is used to poll another event to make the event loop logic sound.

/// When `unknown` is `true`, the return value is `None`.

fn handle_event(

&mut self,

event: winit::event::WindowEvent,

unknown: &mut bool,

) -> Option<Input> {

use winit::keyboard::{Key, NamedKey};

match event {

WindowEvent::KeyboardInput { event: ref ev, .. } => {

if self.exit_on_esc {

if let Key::Named(NamedKey::Escape) = ev.logical_key {

self.set_should_close(true);

return None;

}

}

if let Some(s) = &ev.text {

let s = s.to_string();

let repeat = ev.repeat;

if !repeat {

if let Some(input) = map_window_event(

event,

self.get_window_ref().scale_factor(),

self.keyboard_ignore_modifiers,

unknown,

&mut self.last_key_pressed,

&mut self.devices,

&mut self.device_id_map,

) {

self.events.push_back(Event::Input(input, None));

}

}

return Some(Input::Text(s));

}

}

WindowEvent::CursorMoved { position, .. } => {

let scale = self.get_window_ref().scale_factor();

let position = position.to_logical::<f64>(scale);

let x = f64::from(position.x);

let y = f64::from(position.y);

let pre_event = self.pre_pop_front_event();

let mut input = || {

if let Some(pos) = self.last_cursor_pos {

let dx = x - pos[0];

let dy = y - pos[1];

if self.is_capturing_cursor {

self.last_cursor_pos = Some([x, y]);

self.fake_capture();

// Skip normal mouse movement and emit relative motion only.

return Some(Input::Move(Motion::MouseRelative([dx as f64, dy as f64])));

}

// Send relative mouse movement next time.

self.mouse_relative = Some((dx as f64, dy as f64));

} else if self.is_capturing_cursor {

// Ignore this event since mouse positions

// should not be emitted when capturing cursor.

self.last_cursor_pos = Some([x, y]);

return None;

}

self.last_cursor_pos = Some([x, y]);

return Some(Input::Move(Motion::MouseCursor([x, y])))

};

let input = input();

return if pre_event.is_some() {

if let Some(input) = input {

self.events.push_back(Event::Input(input, None));

}

pre_event

} else {input}

}

_ => {}

}

// Usual events are handled here and passed to user.

let input = map_window_event(

event,

self.get_window_ref().scale_factor(),

self.keyboard_ignore_modifiers,

unknown,

&mut self.last_key_pressed,

&mut self.devices,

&mut self.device_id_map,

);

let pre_event = self.pre_pop_front_event();

if pre_event.is_some() {

if let Some(input) = input {

self.events.push_back(Event::Input(input, None));

}

pre_event

} else {input}

}

fn fake_capture(&mut self) {

if let Some(pos) = self.last_cursor_pos {

// Fake capturing of cursor.

let size = self.size();

let cx = size.width / 2.0;

let cy = size.height / 2.0;

let dx = cx - pos[0];

let dy = cy - pos[1];

if dx != 0.0 || dy != 0.0 {

let pos = winit::dpi::LogicalPosition::new(cx, cy);

if let Ok(_) = self.get_window_ref().set_cursor_position(pos) {

self.last_cursor_pos = Some([cx, cy]);

}

}

}

}

}

impl ApplicationHandler<UserEvent> for GlutinWindow {

fn resumed(&mut self, event_loop: &ActiveEventLoop) {

use glutin::display::GetGlDisplay;

use glutin::config::GlConfig;

use glutin::context::ContextApi;

use glutin::context::NotCurrentGlContext;

use raw_window_handle::HasRawWindowHandle;

use std::num::NonZeroU32;

let settings = &self.settings;

let template = config_template_builder_from_settings(settings);

let display_builder = glutin_winit::DisplayBuilder::new();

let (_, gl_config) = display_builder

.build(event_loop, template, |configs| {

configs.reduce(|accum, config| {

let transparency_check = config.supports_transparency().unwrap_or(false)

& !accum.supports_transparency().unwrap_or(false);

if transparency_check || config.num_samples() > accum.num_samples() {

config

} else {

accum

}

})

.unwrap()

}).unwrap();

let window = event_loop.create_window(winit::window::Window::default_attributes()

.with_inner_size(LogicalSize::<f64>::new(

settings.get_size().width.into(),

settings.get_size().height.into(),

))

.with_title(settings.get_title())

).unwrap();

let raw_window_handle = window.raw_window_handle().unwrap();

let draw_size = window.inner_size();

let dw = NonZeroU32::new(draw_size.width).unwrap();

let dh = NonZeroU32::new(draw_size.height).unwrap();

let surface_attributes = surface_attributes_builder_from_settings(settings)

.build(raw_window_handle, dw, dh);

let display: glutin::display::Display = gl_config.display();

let surface = unsafe {display.create_window_surface(&gl_config, &surface_attributes).unwrap()};

let api = graphics_api_from_settings(settings).unwrap();

let context_attributes = glutin::context::ContextAttributesBuilder::new()

.with_context_api(glutin::context::ContextApi::OpenGl(Some(glutin::context::Version::new(api.major as u8, api.minor as u8))))

.build(Some(raw_window_handle));

let fallback_context_attributes = glutin::context::ContextAttributesBuilder::new()

.with_context_api(ContextApi::Gles(None))

.build(Some(raw_window_handle));

let legacy_context_attributes = glutin::context::ContextAttributesBuilder::new()

.with_context_api(glutin::context::ContextApi::OpenGl(Some(glutin::context::Version::new(2, 1))))

.build(Some(raw_window_handle));

let mut not_current_gl_context = Some(unsafe {

if let Ok(x) = display.create_context(&gl_config, &context_attributes) {x}

else if let Ok(x) = display.create_context(&gl_config, &fallback_context_attributes) {x}

else {

display.create_context(&gl_config, &legacy_context_attributes).unwrap()

}

});

let ctx: glutin::context::PossiblyCurrentContext = not_current_gl_context.take().unwrap()

.make_current(&surface).unwrap();

if settings.get_vsync() {

surface.set_swap_interval(&ctx,

glutin::surface::SwapInterval::Wait(NonZeroU32::new(1).unwrap())).unwrap();

}

// Load the OpenGL function pointers.

gl::load_with(|s| {

use std::ffi::CString;

let s = CString::new(s).expect("CString::new failed");

display.get_proc_address(&s) as *const _

});

self.ctx = Some(ctx);

self.surface = Some(surface);

self.display = Some(display);

self.window = Some(Arc::new(window));

}

fn window_event(

&mut self,

event_loop: &ActiveEventLoop,

_window_id: WindowId,

event: WindowEvent,

) {

let window = &self.get_window_ref();

match event {

WindowEvent::CloseRequested => {

if self.automatic_close {

self.should_close = true;

event_loop.exit();

}

}

WindowEvent::RedrawRequested => {

window.request_redraw();

},

event => {

let mut unknown = false;

if let Some(ev) = self.handle_event(event, &mut unknown) {

if !unknown {

self.events.push_back(Event::Input(ev, None));

}

}

}

}

}

}

impl Window for GlutinWindow {

fn size(&self) -> Size {

let window = self.get_window_ref();

let (w, h): (u32, u32) = window.inner_size().into();

let hidpi = window.scale_factor();

((w as f64 / hidpi) as u32, (h as f64 / hidpi) as u32).into()

}

fn should_close(&self) -> bool { self.should_close }

fn set_should_close(&mut self, value: bool) { self.should_close = value; }

fn swap_buffers(&mut self) {

if let (Some(ctx), Some(surface)) = (&self.ctx, &self.surface) {

let _ = surface.swap_buffers(ctx);

}

}

fn wait_event(&mut self) -> Event {

use winit::platform::pump_events::EventLoopExtPumpEvents;

use input::{IdleArgs, Loop};

// Add all events we got to the event queue, since winit only allows us to get all pending

// events at once.

if let Some(mut event_loop) = std::mem::replace(&mut self.event_loop, None) {

let event_loop_proxy = event_loop.create_proxy();

event_loop_proxy

.send_event(UserEvent::WakeUp)

.expect("Event loop is closed before property handling all events.");

event_loop.pump_app_events(None, self);

self.event_loop = Some(event_loop);

}

// Get the first event in the queue

let event = self.events.pop_front();

// Check if we got a close event, if we did we need to mark ourselves as should-close

if let &Some(Event::Input(Input::Close(_), ..)) = &event {

self.set_should_close(true);

}

event.unwrap_or(Event::Loop(Loop::Idle(IdleArgs {dt: 0.0})))

}

fn wait_event_timeout(&mut self, timeout: Duration) -> Option<Event> {

use winit::platform::pump_events::EventLoopExtPumpEvents;

// Add all events we got to the event queue, since winit only allows us to get all pending

// events at once.

if let Some(mut event_loop) = std::mem::replace(&mut self.event_loop, None) {

let event_loop_proxy = event_loop.create_proxy();

event_loop_proxy

.send_event(UserEvent::WakeUp)

.expect("Event loop is closed before property handling all events.");

event_loop.pump_app_events(Some(timeout), self);

self.event_loop = Some(event_loop);

}

// Get the first event in the queue

let event = self.events.pop_front();

// Check if we got a close event, if we did we need to mark ourselves as should-close

if let &Some(Event::Input(Input::Close(_), ..)) = &event {

self.set_should_close(true);

}

event

}

fn poll_event(&mut self) -> Option<Event> {

use winit::platform::pump_events::EventLoopExtPumpEvents;

// Add all events we got to the event queue, since winit only allows us to get all pending

// events at once.

if let Some(mut event_loop) = std::mem::replace(&mut self.event_loop, None) {

let event_loop_proxy = event_loop.create_proxy();

event_loop_proxy

.send_event(UserEvent::WakeUp)

.expect("Event loop is closed before property handling all events.");

event_loop.pump_app_events(Some(Duration::ZERO), self);

self.event_loop = Some(event_loop);

}

// Get the first event in the queue

let event = self.events.pop_front();

// Check if we got a close event, if we did we need to mark ourselves as should-close

if let &Some(Event::Input(Input::Close(_), ..)) = &event {

self.set_should_close(true);

}

event

}

fn draw_size(&self) -> Size {

let size: (f64, f64) = self.get_window_ref().inner_size().into();

size.into()

}

}

impl BuildFromWindowSettings for GlutinWindow {

fn build_from_window_settings(settings: &WindowSettings)

-> Result<Self, Box<dyn Error>> {

GlutinWindow::new(settings)

}

}

impl AdvancedWindow for GlutinWindow {

fn get_title(&self) -> String {

self.title.clone()

}

fn set_title(&mut self, value: String) {

self.get_window_ref().set_title(&value);

self.title = value;

}

fn get_exit_on_esc(&self) -> bool {

self.exit_on_esc

}

fn set_exit_on_esc(&mut self, value: bool) {

self.exit_on_esc = value

}

fn set_capture_cursor(&mut self, value: bool) {

// Normally we would call `.set_cursor_grab`

// but since relative mouse events does not work,

// because device deltas have unspecified coordinates,

// the capturing of cursor is faked by hiding the cursor

// and setting the position to the center of window.

self.is_capturing_cursor = value;

self.get_window_ref().set_cursor_visible(!value);

if value {

self.fake_capture();

}

}

fn get_automatic_close(&self) -> bool {self.automatic_close}

fn set_automatic_close(&mut self, value: bool) {self.automatic_close = value}

fn show(&mut self) {

self.get_window_ref().set_visible(true);

}

fn hide(&mut self) {

self.get_window_ref().set_visible(false);

}

fn get_position(&self) -> Option<Position> {

self.get_window_ref()

.outer_position()

.map(|p| Position { x: p.x, y: p.y })

.ok()

}

fn set_position<P: Into<Position>>(&mut self, val: P) {

let val = val.into();

self.get_window_ref()

.set_outer_position(LogicalPosition::new(val.x as f64, val.y as f64))

}

fn set_size<S: Into<Size>>(&mut self, size: S) {

let size: Size = size.into();

let w = self.get_window_ref();

let _ = w.request_inner_size(LogicalSize::new(

size.width as f64,

size.height as f64,

));

}

}

impl OpenGLWindow for GlutinWindow {

fn get_proc_address(&mut self, proc_name: &str) -> ProcAddress {

use std::ffi::CString;

let s = CString::new(proc_name).expect("CString::new failed");

self.display.as_ref().expect("No display").get_proc_address(&s) as *const _

}

fn is_current(&self) -> bool {

if let Some(ctx) = &self.ctx {

ctx.is_current()

} else {false}

}

fn make_current(&mut self) {

if let (Some(ctx), Some(surface)) = (&self.ctx, &self.surface) {

let _ = ctx.make_current(surface);

}

}

}

fn map_key(input: &winit::event::KeyEvent, kim: KeyboardIgnoreModifiers) -> Key {

use winit::keyboard::NamedKey::*;

use winit::keyboard::Key::*;

use KeyboardIgnoreModifiers as KIM;

match input.logical_key {

Character(ref ch) => match ch.as_str() {

"0" | ")" if kim == KIM::AbcKeyCode => Key::D0,

"0" => Key::D0,

")" => Key::RightParen,

"1" | "!" if kim == KIM::AbcKeyCode => Key::D1,

"1" => Key::D1,

"!" => Key::NumPadExclam,

"2" | "@" if kim == KIM::AbcKeyCode => Key::D2,

"2" => Key::D2,

"@" => Key::At,

"3" | "#" if kim == KIM::AbcKeyCode => Key::D3,

"3" => Key::D3,

"#" => Key::Hash,

"4" | "$" if kim == KIM::AbcKeyCode => Key::D4,

"4" => Key::D4,

"$" => Key::Dollar,

"5" | "%" if kim == KIM::AbcKeyCode => Key::D5,

"5" => Key::D5,

"%" => Key::Percent,

"6" | "^" if kim == KIM::AbcKeyCode => Key::D6,

"6" => Key::D6,

"^" => Key::Caret,

"7" | "&" if kim == KIM::AbcKeyCode => Key::D7,

"7" => Key::D7,

"&" => Key::Ampersand,

"8" | "*" if kim == KIM::AbcKeyCode => Key::D8,

"8" => Key::D8,

"*" => Key::Asterisk,

"9" | "(" if kim == KIM::AbcKeyCode => Key::D9,

"9" => Key::D9,

"(" => Key::LeftParen,

"a" | "A" => Key::A,

"b" | "B" => Key::B,

"c" | "C" => Key::C,

"d" | "D" => Key::D,

"e" | "E" => Key::E,

"f" | "F" => Key::F,

"g" | "G" => Key::G,

"h" | "H" => Key::H,

"i" | "I" => Key::I,

"j" | "J" => Key::J,

"k" | "K" => Key::K,

"l" | "L" => Key::L,

"m" | "M" => Key::M,

"n" | "N" => Key::N,

"o" | "O" => Key::O,

"p" | "P" => Key::P,

"q" | "Q" => Key::Q,

"r" | "R" => Key::R,

"s" | "S" => Key::S,

"t" | "T" => Key::T,

"u" | "U" => Key::U,

"v" | "V" => Key::V,

"w" | "W" => Key::W,

"x" | "X" => Key::X,

"y" | "Y" => Key::Y,

"z" | "Z" => Key::Z,

"'" | "\"" if kim == KIM::AbcKeyCode => Key::Quote,

"'" => Key::Quote,

"\"" => Key::Quotedbl,

";" | ":" if kim == KIM::AbcKeyCode => Key::Semicolon,

";" => Key::Semicolon,

":" => Key::Colon,

"[" | "{" if kim == KIM::AbcKeyCode => Key::LeftBracket,

"[" => Key::LeftBracket,

"{" => Key::NumPadLeftBrace,

"]" | "}" if kim == KIM::AbcKeyCode => Key::RightBracket,

"]" => Key::RightBracket,

"}" => Key::NumPadRightBrace,

"\\" | "|" if kim == KIM::AbcKeyCode => Key::Backslash,

"\\" => Key::Backslash,

"|" => Key::NumPadVerticalBar,

"," | "<" if kim == KIM::AbcKeyCode => Key::Comma,

"," => Key::Comma,

"<" => Key::Less,

"." | ">" if kim == KIM::AbcKeyCode => Key::Period,

"." => Key::Period,

">" => Key::Greater,

"/" | "?" if kim == KIM::AbcKeyCode => Key::Slash,

"/" => Key::Slash,

"?" => Key::Question,

"`" | "~" if kim == KIM::AbcKeyCode => Key::Backquote,

"`" => Key::Backquote,

// Piston v1.0 does not support `~` using modifier.

// Use `KeyboardIgnoreModifiers::AbcKeyCode` on window to fix this issue.

// It will be mapped to `Key::Backquote`.

"~" => Key::Unknown,

_ => Key::Unknown,

}

Named(Escape) => Key::Escape,

Named(F1) => Key::F1,

Named(F2) => Key::F2,

Named(F3) => Key::F3,

Named(F4) => Key::F4,

Named(F5) => Key::F5,

Named(F6) => Key::F6,

Named(F7) => Key::F7,

Named(F8) => Key::F8,

Named(F9) => Key::F9,

Named(F10) => Key::F10,

Named(F11) => Key::F11,

Named(F12) => Key::F12,

Named(F13) => Key::F13,

Named(F14) => Key::F14,

Named(F15) => Key::F15,

Named(Delete) => Key::Delete,

Named(ArrowLeft) => Key::Left,

Named(ArrowUp) => Key::Up,

Named(ArrowRight) => Key::Right,

Named(ArrowDown) => Key::Down,

Named(Backspace) => Key::Backspace,

Named(Enter) => Key::Return,

Named(Space) => Key::Space,

Named(Alt) => Key::LAlt,

Named(AltGraph) => Key::RAlt,

Named(Control) => Key::LCtrl,

Named(Super) => Key::Menu,

Named(Shift) => Key::LShift,

Named(Tab) => Key::Tab,

_ => Key::Unknown,

}

}

fn map_keyboard_input(

input: &winit::event::KeyEvent,

kim: KeyboardIgnoreModifiers,

unknown: &mut bool,

last_key_pressed: &mut Option<Key>,

) -> Option<Input> {

let key = map_key(input, kim);

let state = if input.state == ElementState::Pressed {

// Filter repeated key presses (does not affect text repeat when holding keys).

if let Some(last_key) = &*last_key_pressed {

if last_key == &key {

*unknown = true;

return None;

}

}

*last_key_pressed = Some(key);

ButtonState::Press

} else {

if let Some(last_key) = &*last_key_pressed {

if last_key == &key {

*last_key_pressed = None;

}

}

ButtonState::Release

};

Some(Input::Button(ButtonArgs {

state: state,

button: Button::Keyboard(key),

scancode: if let winit::keyboard::PhysicalKey::Code(code) = input.physical_key {

Some(code as i32)

} else {None},

}))

}

/// Maps Glutin's mouse button to Piston's mouse button.

pub fn map_mouse(mouse_button: winit::event::MouseButton) -> MouseButton {

use winit::event::MouseButton as M;

match mouse_button {

M::Left => MouseButton::Left,

M::Right => MouseButton::Right,

M::Middle => MouseButton::Middle,

M::Other(0) => MouseButton::X1,

M::Other(1) => MouseButton::X2,

M::Other(2) => MouseButton::Button6,

M::Other(3) => MouseButton::Button7,

M::Other(4) => MouseButton::Button8,

_ => MouseButton::Unknown

}

}

/// Converts a winit's [`WindowEvent`] into a piston's [`Input`].

///

/// For some events that will not be passed to the user, returns `None`.

fn map_window_event(

window_event: WindowEvent,

scale_factor: f64,

kim: KeyboardIgnoreModifiers,

unknown: &mut bool,

last_key_pressed: &mut Option<Key>,

devices: &mut u32,

device_id_map: &mut FxHashMap<DeviceId, u32>,

) -> Option<Input> {

use input::FileDrag;

match window_event {

WindowEvent::DroppedFile(path) =>

Some(Input::FileDrag(FileDrag::Drop(path))),

WindowEvent::HoveredFile(path) =>

Some(Input::FileDrag(FileDrag::Hover(path))),

WindowEvent::HoveredFileCancelled =>

Some(Input::FileDrag(FileDrag::Cancel)),

WindowEvent::Resized(size) => Some(Input::Resize(ResizeArgs {

window_size: [size.width as f64, size.height as f64],

draw_size: Size {

width: size.width as f64,

height: size.height as f64,

}

.into(),

})),

WindowEvent::CloseRequested => Some(Input::Close(CloseArgs)),

WindowEvent::Destroyed => Some(Input::Close(CloseArgs)),

WindowEvent::Focused(focused) => Some(Input::Focus(focused)),

WindowEvent::KeyboardInput { ref event, .. } => {

map_keyboard_input(event, kim, unknown, last_key_pressed)

}

WindowEvent::CursorMoved { position, .. } => {

let position = position.to_logical(scale_factor);

Some(Input::Move(Motion::MouseCursor([position.x, position.y])))

}

WindowEvent::CursorEntered { .. } => Some(Input::Cursor(true)),

WindowEvent::CursorLeft { .. } => Some(Input::Cursor(false)),

WindowEvent::MouseWheel { delta, .. } => match delta {

MouseScrollDelta::PixelDelta(position) => {

let position = position.to_logical(scale_factor);

Some(Input::Move(Motion::MouseScroll([position.x, position.y])))

}

MouseScrollDelta::LineDelta(x, y) =>

Some(Input::Move(Motion::MouseScroll([x as f64, y as f64]))),

},

WindowEvent::MouseInput { state, button, .. } => {

let button = map_mouse(button);

let state = match state {

ElementState::Pressed => ButtonState::Press,

ElementState::Released => ButtonState::Release,

};

Some(Input::Button(ButtonArgs {

state,

button: Button::Mouse(button),

scancode: None,

}))

}

WindowEvent::AxisMotion { device_id, axis, value } => {

use input::ControllerAxisArgs;

Some(Input::Move(Motion::ControllerAxis(ControllerAxisArgs::new(

{

if let Some(id) = device_id_map.get(&device_id) {*id}

else {

let id = *devices;

*devices += 1;

device_id_map.insert(device_id, id);

id

}

},

axis as u8,

value,

))))

}

WindowEvent::Touch(winit::event::Touch { phase, location, id, .. }) => {

use winit::event::TouchPhase;

use input::{Touch, TouchArgs};

let location = location.to_logical::<f64>(scale_factor);

Some(Input::Move(Motion::Touch(TouchArgs::new(

0, id as i64, [location.x, location.y], 1.0, match phase {

TouchPhase::Started => Touch::Start,

TouchPhase::Moved => Touch::Move,

TouchPhase::Ended => Touch::End,

TouchPhase::Cancelled => Touch::Cancel

}

))))

}

// Events not built-in by Piston v1.0.

// It is possible to use Piston's `Event::Custom`.

// This might be added as a library in the future to Piston's ecosystem.

WindowEvent::TouchpadPressure { .. } |

WindowEvent::PinchGesture { .. } |

WindowEvent::RotationGesture { .. } |

WindowEvent::PanGesture { .. } |

WindowEvent::DoubleTapGesture { .. } => None,

WindowEvent::ScaleFactorChanged { .. } => None,

WindowEvent::ActivationTokenDone { .. } => None,

WindowEvent::ThemeChanged(_) => None,

WindowEvent::Ime(_) => None,

WindowEvent::Occluded(_) => None,

WindowEvent::RedrawRequested { .. } => None,

WindowEvent::Moved(_) => None,

WindowEvent::ModifiersChanged(_) => None,

}

}

#[derive(Debug, Eq, PartialEq)]

/// Custom events for the glutin event loop

pub enum UserEvent {

/// Do nothing, just spin the event loop

WakeUp,

}