Update to glium 0.17

client/Cargo.toml

@@ -11,7 +11,7 @@ clap = "2"
 toml = "0.1"
 regex = "0.1"
 rand = "0.3"
-glium = "0.15"
+glium = "0.17"
 noise = "0.3"
 
 [dependencies.base]

client/src/control_switcher.rs

@@ -1,7 +1,7 @@
 use super::camera::*;
 use super::event_manager::*;
 use ghost::Ghost;
-use glium::glutin::{ElementState, Event, VirtualKeyCode};
+use glium::glutin::{ElementState, Event, VirtualKeyCode, WindowEvent, KeyboardInput};
 use player::Player;
 
 /// Switch between `ghost` and `player` cameras with `G` key
@@ -54,7 +54,17 @@ impl ControlSwitcher {
 impl EventHandler for ControlSwitcher {
     fn handle_event(&mut self, e: &Event) -> EventResponse {
         match *e {
-            Event::KeyboardInput(ElementState::Pressed, _, Some(VirtualKeyCode::G)) => {
+            Event::WindowEvent {
+                event: WindowEvent::KeyboardInput {
+                    input: KeyboardInput {
+                        state: ElementState::Pressed,
+                        virtual_keycode: Some(VirtualKeyCode::G),
+                        ..
+                    },
+                    ..
+                },
+                ..
+            } => {
                 self.switch_cam();
                 EventResponse::Continue
             }

client/src/daytime.rs

@@ -1,6 +1,6 @@
 use super::event_manager::*;
 use base::math::*;
-use glium::glutin::{ElementState, Event, VirtualKeyCode};
+use glium::glutin::{ElementState, Event, VirtualKeyCode, WindowEvent, KeyboardInput};
 use std::f32::consts;
 
 #[derive(Debug)]
@@ -178,12 +178,25 @@ impl DayTime {
 /// Handler to speed up time with use of '+' key
 impl EventHandler for DayTime {
     fn handle_event(&mut self, e: &Event) -> EventResponse {
-        match *e {
-            Event::KeyboardInput(ElementState::Pressed, _, Some(VirtualKeyCode::Add)) => {
+        let input = match e {
+            Event::WindowEvent { event: WindowEvent::KeyboardInput { input, .. }, .. } => input,
+            _ => return EventResponse::NotHandled,
+        };
+
+        match input {
+            KeyboardInput {
+                state: ElementState::Pressed,
+                virtual_keycode: Some(VirtualKeyCode::Add),
+                ..
+            } => {
                 self.speed = PLUS_TIME_SPEED;
                 EventResponse::Continue
             }
-            Event::KeyboardInput(ElementState::Released, _, Some(VirtualKeyCode::Add)) => {
+            KeyboardInput {
+                state: ElementState::Released,
+                virtual_keycode: Some(VirtualKeyCode::Add),
+                ..
+            } => {
                 self.speed = DEFAULT_TIME_SPEED;
                 EventResponse::Continue
             }

client/src/event_manager.rs

@@ -1,5 +1,4 @@
-use glium::backend::glutin_backend::GlutinFacade;
-use glium::glutin::{Event, VirtualKeyCode};
+use glium::glutin::{Event, EventsLoop, VirtualKeyCode, WindowEvent, KeyboardInput};
 
 /// Every event receiver has to return a response for each event received.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -15,27 +14,28 @@ pub enum EventResponse {
 }
 
 pub struct EventManager {
-    facade: GlutinFacade,
+    events_loop: EventsLoop,
 }
 
 impl EventManager {
-    pub fn new(facade: GlutinFacade) -> Self {
-        EventManager { facade: facade }
+    pub fn new(events_loop: EventsLoop) -> Self {
+        EventManager { events_loop }
     }
 
-    pub fn poll_events(&self, mut handlers: Vec<&mut dyn EventHandler>) -> EventResponse {
-        for ev in self.facade.poll_events() {
+    pub fn poll_events(&mut self, mut handlers: Vec<&mut dyn EventHandler>) -> EventResponse {
+        let mut quit = false;
+        self.events_loop.poll_events(|ev| {
             for i in 0..handlers.len() {
                 let response = handlers[i].handle_event(&ev);
                 match response {
                     EventResponse::NotHandled | EventResponse::Continue => (),
                     EventResponse::Break => break,
-                    EventResponse::Quit => return EventResponse::Quit,
+                    EventResponse::Quit => quit = true,
                 }
             }
-        }
-        // Just for the sake of return value
-        EventResponse::NotHandled
+        });
+
+        if quit { EventResponse::Quit } else { EventResponse::NotHandled }
     }
 }
 
@@ -55,9 +55,18 @@ pub struct CloseHandler;
 /// *pressing 'Escape'
 impl EventHandler for CloseHandler {
     fn handle_event(&mut self, e: &Event) -> EventResponse {
-        match *e {
-            Event::Closed => EventResponse::Quit,
-            Event::KeyboardInput(_, _, Some(VirtualKeyCode::Escape)) => EventResponse::Quit,
+        let e = match e {
+            Event::WindowEvent { event, .. } => event,
+            _ => return EventResponse::NotHandled,
+        };
+
+        match e {
+            WindowEvent::Closed
+            | WindowEvent::KeyboardInput {
+                input: KeyboardInput { virtual_keycode: Some(VirtualKeyCode::Escape), .. },
+                ..
+             }
+                => EventResponse::Quit,
             _ => EventResponse::NotHandled,
         }
     }

client/src/game.rs

@@ -15,8 +15,7 @@ use config::WindowMode;
 use control_switcher::ControlSwitcher;
 use event_manager::{CloseHandler, EventManager, EventResponse};
 use ghost::Ghost;
-use glium::backend::glutin_backend::GlutinFacade;
-use glium::{self, glutin, DisplayBuild};
+use glium::{self, glutin, Display};
 use player::Player;
 use std::error::Error;
 use std::net::{SocketAddr, TcpStream};
@@ -41,15 +40,16 @@ impl Game {
     pub fn new(config: Config, server: SocketAddr) -> Result<Self, Box<dyn Error>> {
         info!("connecting to {}", server);
         let server = TcpStream::connect(server)?;
-        let facade = create_context(&config)?;
+        let events_loop = glutin::EventsLoop::new();
+        let facade = create_context(&events_loop, &config)?;
         let context = Rc::new(GameContext::new(facade, config.clone()));
         let world_manager =
             WorldManager::new(create_chunk_provider(context.get_config()), context.clone());
         let world_weather = Weather::new(context.clone());
 
         Ok(Game {
             renderer: Renderer::new(context.clone()),
-            event_manager: EventManager::new(context.get_facade().clone()),
+            event_manager: EventManager::new(events_loop),
             world_manager: world_manager.clone(),
             server: server,
             sun: Sun::new(context.clone()),
@@ -215,7 +215,7 @@ fn create_chunk_provider(config: &Config) -> Box<dyn ChunkProvider> {
 
 /// Creates the OpenGL context and prints useful information about the
 /// success or failure of said action.
-fn create_context(config: &Config) -> Result<GlutinFacade, Box<dyn Error>> {
+fn create_context(events_loop: &glutin::EventsLoop, config: &Config) -> Result<Display, Box<dyn Error>> {
     // initialize window builder
     let mut window_builder = glutin::WindowBuilder::new();
     // check for window mode and set params
@@ -228,15 +228,17 @@ fn create_context(config: &Config) -> Result<GlutinFacade, Box<dyn Error>> {
             window_builder = window_builder.with_decorations(false);
         }
     }
-    // check for vsync
-    if config.vsync {
-        window_builder = window_builder.with_vsync();
-    }
     // set title, resolution & create glium context
     window_builder = window_builder.with_title(config.window_title.clone());
     window_builder =
         window_builder.with_dimensions(config.resolution.width, config.resolution.height);
-    let context = window_builder.with_depth_buffer(24).build_glium();
+
+    let context_builder = glutin::ContextBuilder::new()
+        .with_depth_buffer(24)
+        .with_vsync(config.vsync);
+
+
+    let context = glium::Display::new(window_builder, context_builder, &events_loop);
 
     match context {
         Err(e) => {

client/src/game_context.rs

@@ -1,26 +1,26 @@
 use super::Config;
-use glium::backend::glutin_backend::GlutinFacade;
 use glium::program;
+use glium::Display;
 use glium::Program;
 use std::error::Error;
 use std::fs::File;
 use std::io::{self, Read};
 
 #[derive(Clone)]
 pub struct GameContext {
-    facade: GlutinFacade,
+    facade: Display,
     config: Config, // TODO: we might want to wrap it into `Rc` (performance)
 }
 
 impl GameContext {
-    pub fn new(facade: GlutinFacade, config: Config) -> Self {
+    pub fn new(facade: Display, config: Config) -> Self {
         GameContext {
             facade: facade,
             config: config,
         }
     }
 
-    pub fn get_facade(&self) -> &GlutinFacade {
+    pub fn get_facade(&self) -> &Display {
         &self.facade
     }