use crate::{ controller::*, render::{Renderer, WinColorFmt, WinDepthFmt}, settings::{ControlSettings, Settings}, ui, Error, }; use crossbeam::channel; use gilrs::{EventType, Gilrs}; use hashbrown::HashMap; use itertools::Itertools; use old_school_gfx_glutin_ext::{ContextBuilderExt, WindowInitExt, WindowUpdateExt}; use serde_derive::{Deserialize, Serialize}; use std::fmt; use tracing::{error, info, warn}; use vek::*; use winit::monitor::VideoMode; /// Represents a key that the game recognises after input mapping. #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)] pub enum GameInput { Primary, Secondary, Slot1, Slot2, Slot3, Slot4, Slot5, Slot6, Slot7, Slot8, Slot9, Slot10, ToggleCursor, MoveForward, MoveBack, MoveLeft, MoveRight, Jump, Sit, Dance, Glide, Climb, ClimbDown, SwimUp, SwimDown, Sneak, //WallLeap, ToggleLantern, Mount, Chat, Command, Escape, Map, Bag, Social, Crafting, Spellbook, Settings, ToggleInterface, Help, ToggleDebug, Fullscreen, Screenshot, ToggleIngameUi, Roll, Respawn, Interact, ToggleWield, //Charge, SwapLoadout, FreeLook, AutoWalk, CycleCamera, Select, AcceptGroupInvite, DeclineGroupInvite, } impl GameInput { pub fn get_localization_key(&self) -> &str { match *self { GameInput::Primary => "gameinput.primary", GameInput::Secondary => "gameinput.secondary", GameInput::ToggleCursor => "gameinput.togglecursor", GameInput::MoveForward => "gameinput.moveforward", GameInput::MoveLeft => "gameinput.moveleft", GameInput::MoveRight => "gameinput.moveright", GameInput::MoveBack => "gameinput.moveback", GameInput::Jump => "gameinput.jump", GameInput::Sit => "gameinput.sit", GameInput::Dance => "gameinput.dance", GameInput::Glide => "gameinput.glide", GameInput::Climb => "gameinput.climb", GameInput::ClimbDown => "gameinput.climbdown", GameInput::SwimUp => "gameinput.swimup", GameInput::SwimDown => "gameinput.swimdown", GameInput::Sneak => "gameinput.sneak", //GameInput::WallLeap => "gameinput.wallleap", GameInput::ToggleLantern => "gameinput.togglelantern", GameInput::Mount => "gameinput.mount", GameInput::Chat => "gameinput.chat", GameInput::Command => "gameinput.command", GameInput::CycleCamera => "gameinput.cyclecamera", GameInput::Escape => "gameinput.escape", GameInput::Map => "gameinput.map", GameInput::Bag => "gameinput.bag", GameInput::Social => "gameinput.social", GameInput::Crafting => "gameinput.crafting", GameInput::Spellbook => "gameinput.spellbook", GameInput::Settings => "gameinput.settings", GameInput::ToggleInterface => "gameinput.toggleinterface", GameInput::Help => "gameinput.help", GameInput::ToggleDebug => "gameinput.toggledebug", GameInput::Fullscreen => "gameinput.fullscreen", GameInput::Screenshot => "gameinput.screenshot", GameInput::ToggleIngameUi => "gameinput.toggleingameui", GameInput::Roll => "gameinput.roll", GameInput::Respawn => "gameinput.respawn", GameInput::Interact => "gameinput.interact", GameInput::ToggleWield => "gameinput.togglewield", //GameInput::Charge => "gameinput.charge", GameInput::FreeLook => "gameinput.freelook", GameInput::AutoWalk => "gameinput.autowalk", GameInput::Slot1 => "gameinput.slot1", GameInput::Slot2 => "gameinput.slot2", GameInput::Slot3 => "gameinput.slot3", GameInput::Slot4 => "gameinput.slot4", GameInput::Slot5 => "gameinput.slot5", GameInput::Slot6 => "gameinput.slot6", GameInput::Slot7 => "gameinput.slot7", GameInput::Slot8 => "gameinput.slot8", GameInput::Slot9 => "gameinput.slot9", GameInput::Slot10 => "gameinput.slot10", GameInput::SwapLoadout => "gameinput.swaploadout", GameInput::Select => "gameinput.select", GameInput::AcceptGroupInvite => "gameinput.acceptgroupinvite", GameInput::DeclineGroupInvite => "gameinput.declinegroupinvite", } } pub fn iterator() -> impl Iterator { [ GameInput::Primary, GameInput::Secondary, GameInput::ToggleCursor, GameInput::MoveForward, GameInput::MoveLeft, GameInput::MoveRight, GameInput::MoveBack, GameInput::Jump, GameInput::Sit, GameInput::Dance, GameInput::Glide, GameInput::Climb, GameInput::ClimbDown, GameInput::SwimUp, GameInput::SwimDown, GameInput::Sneak, GameInput::ToggleLantern, GameInput::Mount, GameInput::Chat, GameInput::Command, GameInput::Escape, GameInput::Map, GameInput::Bag, GameInput::Social, GameInput::Crafting, GameInput::Spellbook, GameInput::Settings, GameInput::ToggleInterface, GameInput::Help, GameInput::ToggleDebug, GameInput::Fullscreen, GameInput::Screenshot, GameInput::ToggleIngameUi, GameInput::Roll, GameInput::Respawn, GameInput::Interact, GameInput::ToggleWield, GameInput::FreeLook, GameInput::AutoWalk, GameInput::Slot1, GameInput::Slot2, GameInput::Slot3, GameInput::Slot4, GameInput::Slot5, GameInput::Slot6, GameInput::Slot7, GameInput::Slot8, GameInput::Slot9, GameInput::Slot10, GameInput::SwapLoadout, ] .iter() .copied() } /// Return true if `a` and `b` are able to be bound to the same key at the /// same time without conflict. For example, the player can't jump and climb /// at the same time, so these can be bound to the same key. pub fn can_share_bindings(a: GameInput, b: GameInput) -> bool { a.get_representative_binding() == b.get_representative_binding() } /// If two GameInputs are able to be bound at the same time, then they will /// return the same value from this function (the representative value for /// that set). This models the Find operation of a disjoint-set data /// structure. fn get_representative_binding(&self) -> GameInput { match self { GameInput::Jump => GameInput::Jump, GameInput::Climb => GameInput::Jump, GameInput::SwimUp => GameInput::Jump, GameInput::Respawn => GameInput::Jump, GameInput::FreeLook => GameInput::FreeLook, GameInput::AutoWalk => GameInput::FreeLook, _ => *self, } } } /// Represents a key that the game menus recognise after input mapping #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)] pub enum MenuInput { Up, Down, Left, Right, ScrollUp, ScrollDown, ScrollLeft, ScrollRight, Home, End, Apply, Back, Exit, } #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)] pub enum AnalogMenuInput { MoveX(f32), MoveY(f32), ScrollX(f32), ScrollY(f32), } #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)] pub enum AnalogGameInput { MovementX(f32), MovementY(f32), CameraX(f32), CameraY(f32), } /// Represents an incoming event from the window. #[derive(Clone, Debug)] pub enum Event { /// The window has been requested to close. Close, /// The window has been resized. Resize(Vec2), /// The window has been moved. Moved(Vec2), /// A key has been typed that corresponds to a specific character. Char(char), /// The cursor has been panned across the screen while grabbed. CursorPan(Vec2), /// The cursor has been moved across the screen while ungrabbed. CursorMove(Vec2), /// A mouse button has been pressed or released MouseButton(MouseButton, PressState), /// The camera has been requested to zoom. Zoom(f32), /// A key that the game recognises has been pressed or released. InputUpdate(GameInput, bool), /// Event that the ui uses. Ui(ui::Event), /// The view distance has changed. ViewDistanceChanged(u32), /// Game settings have changed. SettingsChanged, /// The window is (un)focused Focused(bool), /// A key that the game recognises for menu navigation has been pressed or /// released MenuInput(MenuInput, bool), /// Update of the analog inputs recognized by the menus AnalogMenuInput(AnalogMenuInput), /// Update of the analog inputs recognized by the game AnalogGameInput(AnalogGameInput), /// We tried to save a screenshot ScreenshotMessage(String), } pub type MouseButton = winit::event::MouseButton; pub type PressState = winit::event::ElementState; pub type EventLoop = winit::event_loop::EventLoop<()>; #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)] pub enum KeyMouse { Key(winit::event::VirtualKeyCode), Mouse(winit::event::MouseButton), } impl fmt::Display for KeyMouse { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use self::KeyMouse::*; use winit::event::{MouseButton, VirtualKeyCode::*}; write!(f, "{}", match self { Key(Key1) => "1", Key(Key2) => "2", Key(Key3) => "3", Key(Key4) => "4", Key(Key5) => "5", Key(Key6) => "6", Key(Key7) => "7", Key(Key8) => "8", Key(Key9) => "9", Key(Key0) => "0", Key(A) => "A", Key(B) => "B", Key(C) => "C", Key(D) => "D", Key(E) => "E", Key(F) => "F", Key(G) => "G", Key(H) => "H", Key(I) => "I", Key(J) => "J", Key(K) => "K", Key(L) => "L", Key(M) => "M", Key(N) => "N", Key(O) => "O", Key(P) => "P", Key(Q) => "Q", Key(R) => "R", Key(S) => "S", Key(T) => "T", Key(U) => "U", Key(V) => "V", Key(W) => "W", Key(X) => "X", Key(Y) => "Y", Key(Z) => "Z", Key(Escape) => "ESC", Key(F1) => "F1", Key(F2) => "F2", Key(F3) => "F3", Key(F4) => "F4", Key(F5) => "F5", Key(F6) => "F6", Key(F7) => "F7", Key(F8) => "F8", Key(F9) => "F9", Key(F10) => "F10", Key(F11) => "F11", Key(F12) => "F12", Key(F13) => "F13", Key(F14) => "F14", Key(F15) => "F15", Key(F16) => "F16", Key(F17) => "F17", Key(F18) => "F18", Key(F19) => "F19", Key(F20) => "F20", Key(F21) => "F21", Key(F22) => "F22", Key(F23) => "F23", Key(F24) => "F24", Key(Snapshot) => "Print Screen", Key(Scroll) => "Scroll Lock", Key(Pause) => "Pause/Break", Key(Insert) => "Insert", Key(Home) => "Home", Key(Delete) => "Delete", Key(End) => "End", Key(PageDown) => "PageDown", Key(PageUp) => "PageUp", Key(Left) => "Left Arrow", Key(Up) => "Up Arrow", Key(Right) => "Right Arrow", Key(Down) => "Down Arrow", Key(Back) => "Backspace", Key(Return) => "Enter", Key(Space) => "Space", Key(Compose) => "Compose", Key(Caret) => "^", Key(Numlock) => "Numlock", Key(Numpad0) => "Numpad 0", Key(Numpad1) => "Numpad 1", Key(Numpad2) => "Numpad 2", Key(Numpad3) => "Numpad 3", Key(Numpad4) => "Numpad 4", Key(Numpad5) => "Numpad 5", Key(Numpad6) => "Numpad 6", Key(Numpad7) => "Numpad 7", Key(Numpad8) => "Numpad 8", Key(Numpad9) => "Numpad 9", Key(AbntC1) => "Abnt C1", Key(AbntC2) => "Abnt C2", Key(Add) => "Numpad +", Key(Apostrophe) => "'", Key(Apps) => "Context Menu", Key(At) => "@", Key(Ax) => "Ax", Key(Backslash) => "\\", Key(Calculator) => "Calculator", Key(Capital) => "Caps Lock", Key(Colon) => ":", Key(Comma) => ",", Key(Convert) => "Convert", Key(Decimal) => "Numpad .", Key(Divide) => "Numpad /", Key(Equals) => "=", Key(Grave) => "`", Key(Kana) => "Kana", Key(Kanji) => "Kanji", Key(LAlt) => "LAlt", Key(LBracket) => "[", Key(LControl) => "LControl", Key(LShift) => "LShift", Key(LWin) => "LWin", Key(Mail) => "Mail", Key(MediaSelect) => "MediaSelect", Key(MediaStop) => "MediaStop", Key(Minus) => "-", Key(Multiply) => "Numpad *", Key(Mute) => "Mute", Key(MyComputer) => "My Computer", Key(NavigateForward) => "Navigate Forward", Key(NavigateBackward) => "Navigate Backward", Key(NextTrack) => "Next Track", Key(NoConvert) => "Non Convert", Key(NumpadComma) => "Num ,", Key(NumpadEnter) => "Num Enter", Key(NumpadEquals) => "Num =", Key(OEM102) => "<", Key(Period) => ".", Key(PlayPause) => "Play / Pause", Key(Power) => "Power", Key(PrevTrack) => "Prev Track", Key(RAlt) => "RAlt", Key(RBracket) => "]", Key(RControl) => "RControl", Key(RShift) => "RShift", Key(RWin) => "RWin", Key(Semicolon) => ";", Key(Slash) => "/", Key(Sleep) => "Sleep", Key(Stop) => "Media Stop", Key(Subtract) => "Num -", Key(Sysrq) => "Sysrq", Key(Tab) => "Tab", Key(Underline) => "_", Key(Unlabeled) => "No Name", Key(VolumeDown) => "Volume Down", Key(VolumeUp) => "Volume Up", Key(Wake) => "Wake", Key(WebBack) => "Browser Back", Key(WebFavorites) => "Browser Favorites", Key(WebForward) => "Browser Forward", Key(WebHome) => "Browser Home", Key(WebRefresh) => "Browser Refresh", Key(WebSearch) => "Browser Search", Key(WebStop) => "Browser Stop", Key(Yen) => "Yen", Key(Copy) => "Copy", Key(Paste) => "Paste", Key(Cut) => "Cut", Mouse(MouseButton::Left) => "M1", Mouse(MouseButton::Right) => "M2", Mouse(MouseButton::Middle) => "M3", Mouse(MouseButton::Other(button)) => // Additional mouse buttons after middle click start at 1 return write!(f, "M{}", button + 3), }) } } pub struct Window { renderer: Renderer, window: glutin::ContextWrapper, cursor_grabbed: bool, pub pan_sensitivity: u32, pub zoom_sensitivity: u32, pub zoom_inversion: bool, pub mouse_y_inversion: bool, fullscreen: bool, modifiers: winit::event::ModifiersState, needs_refresh_resize: bool, keypress_map: HashMap, pub remapping_keybindings: Option, events: Vec, focused: bool, gilrs: Option, controller_settings: ControllerSettings, cursor_position: winit::dpi::PhysicalPosition, mouse_emulation_vec: Vec2, // Currently used to send and receive screenshot result messages message_sender: channel::Sender, message_receiver: channel::Receiver, // Used for screenshots & fullscreen toggle to deduplicate/postpone to after event handler take_screenshot: bool, toggle_fullscreen: bool, } impl Window { pub fn new(settings: &Settings) -> Result<(Window, EventLoop), Error> { let event_loop = EventLoop::new(); let size = settings.graphics.window_size; let win_builder = winit::window::WindowBuilder::new() .with_title("Veloren") .with_inner_size(winit::dpi::LogicalSize::new(size[0] as f64, size[1] as f64)) .with_maximized(true); // Avoid cpal / winit OleInitialize conflict // See: https://github.com/rust-windowing/winit/pull/1524 #[cfg(target_os = "windows")] let win_builder = winit::platform::windows::WindowBuilderExtWindows::with_drag_and_drop( win_builder, false, ); let (window, device, factory, win_color_view, win_depth_view) = glutin::ContextBuilder::new() .with_gl(glutin::GlRequest::Specific(glutin::Api::OpenGl, (3, 3))) .with_vsync(false) .with_gfx_color_depth::() .build_windowed(win_builder, &event_loop) .map_err(|err| Error::BackendError(Box::new(err)))? .init_gfx::(); let vendor = device.get_info().platform_name.vendor; let renderer = device.get_info().platform_name.renderer; let opengl_version = device.get_info().version; let glsl_version = device.get_info().shading_language; info!( ?vendor, ?renderer, ?opengl_version, ?glsl_version, "selected graphics device" ); let keypress_map = HashMap::new(); let gilrs = match Gilrs::new() { Ok(gilrs) => Some(gilrs), Err(gilrs::Error::NotImplemented(_dummy)) => { warn!("Controller input is unsupported on this platform."); None }, Err(gilrs::Error::InvalidAxisToBtn) => { error!( "Invalid AxisToBtn controller mapping. Falling back to no controller support." ); None }, Err(gilrs::Error::Other(e)) => { error!( ?e, "Platform-specific error when creating a Gilrs instance. Falling back to no \ controller support." ); None }, }; let controller_settings = ControllerSettings::from(&settings.controller); let (message_sender, message_receiver): ( channel::Sender, channel::Receiver, ) = channel::unbounded::(); let mut this = Self { renderer: Renderer::new( device, factory, win_color_view, win_depth_view, settings.graphics.render_mode.clone(), )?, window, cursor_grabbed: false, pan_sensitivity: settings.gameplay.pan_sensitivity, zoom_sensitivity: settings.gameplay.zoom_sensitivity, zoom_inversion: settings.gameplay.zoom_inversion, mouse_y_inversion: settings.gameplay.mouse_y_inversion, fullscreen: false, modifiers: Default::default(), needs_refresh_resize: false, keypress_map, remapping_keybindings: None, events: Vec::new(), focused: true, gilrs, controller_settings, cursor_position: winit::dpi::PhysicalPosition::new(0.0, 0.0), mouse_emulation_vec: Vec2::zero(), // Currently used to send and receive screenshot result messages message_sender, message_receiver, take_screenshot: false, toggle_fullscreen: false, }; this.fullscreen( settings.graphics.fullscreen, settings.graphics.resolution, settings.graphics.bit_depth, settings.graphics.refresh_rate, ); Ok((this, event_loop)) } pub fn window( &self, ) -> &glutin::ContextWrapper { &self.window } pub fn renderer(&self) -> &Renderer { &self.renderer } pub fn renderer_mut(&mut self) -> &mut Renderer { &mut self.renderer } pub fn resolve_deduplicated_events(&mut self, settings: &mut Settings) { // Handle screenshots and toggling fullscreen if self.take_screenshot { self.take_screenshot = false; self.take_screenshot(&settings); } if self.toggle_fullscreen { self.toggle_fullscreen = false; self.toggle_fullscreen(settings); } } pub fn fetch_events(&mut self) -> Vec { // Refresh ui size (used when changing playstates) if self.needs_refresh_resize { self.events .push(Event::Ui(ui::Event::new_resize(self.logical_size()))); self.needs_refresh_resize = false; } // Receive any messages sent through the message channel for message in self.message_receiver.try_iter() { self.events.push(Event::ScreenshotMessage(message)) } if let Some(gilrs) = &mut self.gilrs { while let Some(event) = gilrs.next_event() { fn handle_buttons( settings: &ControllerSettings, events: &mut Vec, button: &Button, is_pressed: bool, ) { if let Some(evs) = settings.game_button_map.get(button) { for ev in evs { events.push(Event::InputUpdate(*ev, is_pressed)); } } if let Some(evs) = settings.menu_button_map.get(button) { for ev in evs { events.push(Event::MenuInput(*ev, is_pressed)); } } } match event.event { EventType::ButtonPressed(button, code) | EventType::ButtonRepeated(button, code) => { handle_buttons( &self.controller_settings, &mut self.events, &Button::from((button, code)), true, ); }, EventType::ButtonReleased(button, code) => { handle_buttons( &self.controller_settings, &mut self.events, &Button::from((button, code)), false, ); }, EventType::ButtonChanged(button, _value, code) => { if let Some(actions) = self .controller_settings .game_analog_button_map .get(&AnalogButton::from((button, code))) { for action in actions { match *action {} } } if let Some(actions) = self .controller_settings .menu_analog_button_map .get(&AnalogButton::from((button, code))) { for action in actions { match *action {} } } }, EventType::AxisChanged(axis, value, code) => { let value = if self .controller_settings .inverted_axes .contains(&Axis::from((axis, code))) { -value } else { value }; let value = self .controller_settings .apply_axis_deadzone(&Axis::from((axis, code)), value); if self.cursor_grabbed { if let Some(actions) = self .controller_settings .game_axis_map .get(&Axis::from((axis, code))) { for action in actions { match *action { AxisGameAction::MovementX => { self.events.push(Event::AnalogGameInput( AnalogGameInput::MovementX(value), )); }, AxisGameAction::MovementY => { self.events.push(Event::AnalogGameInput( AnalogGameInput::MovementY(value), )); }, AxisGameAction::CameraX => { self.events.push(Event::AnalogGameInput( AnalogGameInput::CameraX( value * self.controller_settings.pan_sensitivity as f32 / 100.0, ), )); }, AxisGameAction::CameraY => { self.events.push(Event::AnalogGameInput( AnalogGameInput::CameraY( value * self.controller_settings.pan_sensitivity as f32 / 100.0, ), )); }, } } } } else if let Some(actions) = self .controller_settings .menu_axis_map .get(&Axis::from((axis, code))) { // TODO: possibly add sensitivity settings when this is used for action in actions { match *action { AxisMenuAction::MoveX => { self.events.push(Event::AnalogMenuInput( AnalogMenuInput::MoveX(value), )); }, AxisMenuAction::MoveY => { self.events.push(Event::AnalogMenuInput( AnalogMenuInput::MoveY(value), )); }, AxisMenuAction::ScrollX => { self.events.push(Event::AnalogMenuInput( AnalogMenuInput::ScrollX(value), )); }, AxisMenuAction::ScrollY => { self.events.push(Event::AnalogMenuInput( AnalogMenuInput::ScrollY(value), )); }, } } } }, EventType::Connected => {}, EventType::Disconnected => {}, EventType::Dropped => {}, } } } let mut events = std::mem::take(&mut self.events); // Mouse emulation for the menus, to be removed when a proper menu navigation // system is available if !self.cursor_grabbed { events = events .into_iter() .filter_map(|event| match event { Event::AnalogMenuInput(input) => match input { AnalogMenuInput::MoveX(d) => { self.mouse_emulation_vec.x = d; None }, AnalogMenuInput::MoveY(d) => { // This just has to be inverted for some reason self.mouse_emulation_vec.y = d * -1.0; None }, input => Some(Event::AnalogMenuInput(input)), }, Event::MenuInput(MenuInput::Apply, state) => Some(match state { true => Event::Ui(ui::Event(conrod_core::event::Input::Press( conrod_core::input::Button::Mouse( conrod_core::input::state::mouse::Button::Left, ), ))), false => Event::Ui(ui::Event(conrod_core::event::Input::Release( conrod_core::input::Button::Mouse( conrod_core::input::state::mouse::Button::Left, ), ))), }), _ => Some(event), }) .collect(); let sensitivity = self.controller_settings.mouse_emulation_sensitivity; // TODO: make this independent of framerate // TODO: consider multiplying by scale factor self.offset_cursor(self.mouse_emulation_vec * sensitivity as f32); } events } pub fn handle_device_event(&mut self, event: winit::event::DeviceEvent) { use winit::event::DeviceEvent; let mouse_y_inversion = match self.mouse_y_inversion { true => -1.0, false => 1.0, }; match event { DeviceEvent::MouseMotion { delta: (dx, dy), .. } if self.focused => { let delta = Vec2::new( dx as f32 * (self.pan_sensitivity as f32 / 100.0), dy as f32 * (self.pan_sensitivity as f32 * mouse_y_inversion / 100.0), ); if self.cursor_grabbed { self.events.push(Event::CursorPan(delta)); } else { self.events.push(Event::CursorMove(delta)); } }, DeviceEvent::MouseWheel { delta, .. } if self.cursor_grabbed && self.focused => { self.events.push(Event::Zoom({ // Since scrolling apparently acts different depending on platform #[cfg(target_os = "windows")] const PLATFORM_FACTOR: f32 = -4.0; #[cfg(not(target_os = "windows"))] const PLATFORM_FACTOR: f32 = 1.0; let y = match delta { winit::event::MouseScrollDelta::LineDelta(_x, y) => y, // TODO: Check to see if there is a better way to find the "line // height" than just hardcoding 16.0 pixels. Alternately we could // get rid of this and have the user set zoom sensitivity, since // it's unlikely people would expect a configuration file to work // across operating systems. winit::event::MouseScrollDelta::PixelDelta(pos) => (pos.y / 16.0) as f32, }; y * (self.zoom_sensitivity as f32 / 100.0) * if self.zoom_inversion { -1.0 } else { 1.0 } * PLATFORM_FACTOR })) }, _ => {}, } } pub fn handle_window_event( &mut self, event: winit::event::WindowEvent, settings: &mut Settings, ) { use winit::event::WindowEvent; let controls = &mut settings.controls; match event { WindowEvent::CloseRequested => self.events.push(Event::Close), WindowEvent::Resized(physical) => { let (mut color_view, mut depth_view) = self.renderer.win_views_mut(); self.window.resize(physical); self.window.update_gfx(&mut color_view, &mut depth_view); self.renderer.on_resize().unwrap(); // TODO: update users of this event with the fact that it is now the physical // size let winit::dpi::PhysicalSize { width, height } = physical; self.events .push(Event::Resize(Vec2::new(width as u32, height as u32))); }, WindowEvent::ScaleFactorChanged { .. } => { // TODO: Handle properly! }, WindowEvent::ReceivedCharacter(c) => self.events.push(Event::Char(c)), WindowEvent::MouseInput { button, state, .. } => { if let (true, Some(game_inputs)) = // Mouse input not mapped to input if it is not grabbed ( self.cursor_grabbed, Window::map_input( KeyMouse::Mouse(button), controls, &mut self.remapping_keybindings, ), ) { for game_input in game_inputs { self.events.push(Event::InputUpdate( *game_input, state == winit::event::ElementState::Pressed, )); } } self.events.push(Event::MouseButton(button, state)); }, WindowEvent::ModifiersChanged(modifiers) => self.modifiers = modifiers, WindowEvent::KeyboardInput { input, is_synthetic, .. } => { // Ignore synthetic tab presses so that we don't get tabs when alt-tabbing back // into the window if matches!( input.virtual_keycode, Some(winit::event::VirtualKeyCode::Tab) ) && is_synthetic { return; } // Ignore Alt-F4 so we don't try to do anything heavy like take a screenshot // when the window is about to close if matches!(input, winit::event::KeyboardInput { state: winit::event::ElementState::Pressed, virtual_keycode: Some(winit::event::VirtualKeyCode::F4), .. }) && self.modifiers.alt() { return; } if let Some(key) = input.virtual_keycode { if let Some(game_inputs) = Window::map_input( KeyMouse::Key(key), controls, &mut self.remapping_keybindings, ) { for game_input in game_inputs { match game_input { GameInput::Fullscreen => { if input.state == winit::event::ElementState::Pressed && !Self::is_pressed( &mut self.keypress_map, GameInput::Fullscreen, ) { self.toggle_fullscreen = !self.toggle_fullscreen; } Self::set_pressed( &mut self.keypress_map, GameInput::Fullscreen, input.state, ); }, GameInput::Screenshot => { self.take_screenshot = input.state == winit::event::ElementState::Pressed && !Self::is_pressed( &mut self.keypress_map, GameInput::Screenshot, ); Self::set_pressed( &mut self.keypress_map, GameInput::Screenshot, input.state, ); }, _ => self.events.push(Event::InputUpdate( *game_input, input.state == winit::event::ElementState::Pressed, )), } } } } }, WindowEvent::Focused(state) => { self.focused = state; self.events.push(Event::Focused(state)); }, WindowEvent::CursorMoved { position, .. } => { self.cursor_position = position; }, _ => {}, } } /// Moves cursor by an offset pub fn offset_cursor(&self, d: Vec2) { if d != Vec2::zero() { if let Err(err) = self.window .window() .set_cursor_position(winit::dpi::LogicalPosition::new( d.x as f64 + self.cursor_position.x, d.y as f64 + self.cursor_position.y, )) { error!("Error setting cursor position: {:?}", err); } } } pub fn swap_buffers(&self) -> Result<(), Error> { self.window .swap_buffers() .map_err(|err| Error::BackendError(Box::new(err))) } pub fn is_cursor_grabbed(&self) -> bool { self.cursor_grabbed } pub fn grab_cursor(&mut self, grab: bool) { self.cursor_grabbed = grab; self.window.window().set_cursor_visible(!grab); let _ = self.window.window().set_cursor_grab(grab); } pub fn toggle_fullscreen(&mut self, settings: &mut Settings) { self.fullscreen( !self.is_fullscreen(), settings.graphics.resolution, settings.graphics.bit_depth, settings.graphics.refresh_rate, ); settings.graphics.fullscreen = self.is_fullscreen(); settings.save_to_file_warn(); } pub fn is_fullscreen(&self) -> bool { self.fullscreen } pub fn select_video_mode_rec( &self, resolution: [u16; 2], bit_depth: Option, refresh_rate: Option, correct_res: Option>, correct_depth: Option>, correct_rate: Option>, ) -> Option { // if a previous iteration of this method filtered the available video modes for // the correct resolution already, load that value, otherwise filter it // in this iteration let correct_res = correct_res.unwrap_or_else(|| { let window = self.window.window(); window .current_monitor() .video_modes() .filter(|mode| mode.size().width == resolution[0] as u32) .filter(|mode| mode.size().height == resolution[1] as u32) .collect() }); match bit_depth { // A bit depth is given Some(depth) => { // analogous to correct_res let correct_depth = correct_depth.unwrap_or_else(|| { correct_res .iter() .find(|mode| mode.bit_depth() == depth) .cloned() }); match refresh_rate { // A bit depth and a refresh rate is given Some(rate) => { // analogous to correct_res let correct_rate = correct_rate.unwrap_or_else(|| { correct_res .iter() .find(|mode| mode.refresh_rate() == rate) .cloned() }); // if no video mode with the given bit depth and refresh rate exists, fall // back to a video mode that fits the resolution and either bit depth or // refresh rate depending on which parameter was causing the correct video // mode not to be found correct_res .iter() .filter(|mode| mode.bit_depth() == depth) .find(|mode| mode.refresh_rate() == rate) .cloned() .or_else(|| { if correct_depth.is_none() && correct_rate.is_none() { warn!( "Bit depth and refresh rate specified in settings are \ incompatible with the monitor. Choosing highest bit \ depth and refresh rate possible instead." ); } self.select_video_mode_rec( resolution, correct_depth.is_some().then_some(depth), correct_rate.is_some().then_some(rate), Some(correct_res), Some(correct_depth), Some(correct_rate), ) }) }, // A bit depth and no refresh rate is given // if no video mode with the given bit depth exists, fall // back to a video mode that fits only the resolution None => match correct_depth { Some(mode) => Some(mode), None => { warn!( "Bit depth specified in settings is incompatible with the \ monitor. Choosing highest bit depth possible instead." ); self.select_video_mode_rec( resolution, None, None, Some(correct_res), Some(correct_depth), None, ) }, }, } }, // No bit depth is given None => match refresh_rate { // No bit depth and a refresh rate is given Some(rate) => { // analogous to correct_res let correct_rate = correct_rate.unwrap_or_else(|| { correct_res .iter() .find(|mode| mode.refresh_rate() == rate) .cloned() }); // if no video mode with the given bit depth exists, fall // back to a video mode that fits only the resolution match correct_rate { Some(mode) => Some(mode), None => { warn!( "Refresh rate specified in settings is incompatible with the \ monitor. Choosing highest refresh rate possible instead." ); self.select_video_mode_rec( resolution, None, None, Some(correct_res), None, Some(correct_rate), ) }, } }, // No bit depth and no refresh rate is given // get the video mode with the specified resolution and the max bit depth and // refresh rate None => correct_res .into_iter() // Prefer bit depth over refresh rate .sorted_by_key(|mode| mode.bit_depth()) .max_by_key(|mode| mode.refresh_rate()), }, } } pub fn select_video_mode( &self, resolution: [u16; 2], bit_depth: Option, refresh_rate: Option, ) -> VideoMode { // (resolution, bit depth, refresh rate) represents a video mode // spec: as specified // max: maximum value available // order of fallbacks as follows: // (spec, spec, spec) // (spec, spec, max), (spec, max, spec) // (spec, max, max) // (max, max, max) self.select_video_mode_rec(resolution, bit_depth, refresh_rate, None, None, None) // if there is no video mode with the specified resolution, fall back to the video mode with max resolution, bit depth and refresh rate .unwrap_or_else(|| { warn!( "Resolution specified in settings is incompatible with the monitor. Choosing \ highest resolution possible instead." ); self .window .window() .current_monitor() .video_modes() // Prefer bit depth over refresh rate .sorted_by_key(|mode| mode.refresh_rate()) .sorted_by_key(|mode| mode.bit_depth()) .max_by_key(|mode| mode.size().width) .expect("No video modes available!!") }) } pub fn fullscreen( &mut self, fullscreen: bool, resolution: [u16; 2], bit_depth: Option, refresh_rate: Option, ) { let window = self.window.window(); self.fullscreen = fullscreen; if fullscreen { window.set_fullscreen(Some(winit::window::Fullscreen::Exclusive( self.select_video_mode(resolution, bit_depth, refresh_rate), ))); } else { window.set_fullscreen(None); } } pub fn needs_refresh_resize(&mut self) { self.needs_refresh_resize = true; } #[allow(clippy::or_fun_call)] // TODO: Pending review in #587 pub fn logical_size(&self) -> Vec2 { let (w, h) = self .window .window() .inner_size() .to_logical::(self.window.window().scale_factor()) .into(); Vec2::new(w, h) } pub fn set_size(&mut self, new_size: Vec2) { self.window .window() .set_inner_size(glutin::dpi::LogicalSize::new( new_size.x as f64, new_size.y as f64, )); } pub fn send_event(&mut self, event: Event) { self.events.push(event) } pub fn take_screenshot(&mut self, settings: &Settings) { match self.renderer.create_screenshot() { Ok(img) => { let mut path = settings.screenshots_path.clone(); let sender = self.message_sender.clone(); std::thread::spawn(move || { use std::time::SystemTime; // Check if folder exists and create it if it does not if !path.exists() { if let Err(e) = std::fs::create_dir_all(&path) { warn!(?e, "Couldn't create folder for screenshot"); let _result = sender.send(String::from("Couldn't create folder for screenshot")); } } path.push(format!( "screenshot_{}.png", SystemTime::now() .duration_since(SystemTime::UNIX_EPOCH) .map(|d| d.as_millis()) .unwrap_or(0) )); if let Err(e) = img.save(&path) { warn!(?e, "Couldn't save screenshot"); let _result = sender.send(String::from("Couldn't save screenshot")); } else { let _result = sender.send(format!("Screenshot saved to {}", path.to_string_lossy())); } }); }, Err(e) => error!(?e, "Couldn't create screenshot due to renderer error"), } } fn is_pressed( map: &mut HashMap, input: GameInput, ) -> bool { *(map .entry(input) .or_insert(winit::event::ElementState::Released)) == winit::event::ElementState::Pressed } fn set_pressed( map: &mut HashMap, input: GameInput, state: winit::event::ElementState, ) { map.insert(input, state); } // Function used to handle Mouse and Key events. It first checks if we're in // remapping mode for a specific GameInput. If we are, we modify the binding // of that GameInput with the KeyMouse passed. Else, we return an iterator of // the GameInputs for that KeyMouse. fn map_input<'a>( key_mouse: KeyMouse, controls: &'a mut ControlSettings, remapping: &mut Option, ) -> Option> { match *remapping { // TODO: save settings Some(game_input) => { controls.modify_binding(game_input, key_mouse); *remapping = None; None }, None => { if let Some(game_inputs) = controls.get_associated_game_inputs(&key_mouse) { Some(game_inputs.iter()) } else { None } }, } } pub fn set_keybinding_mode(&mut self, game_input: GameInput) { self.remapping_keybindings = Some(game_input); } }