Merge pull request glium#1736 from est31/master

Update dependencies, unbreak examples

Author: mitchmindtree

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## Version 0.24.0 (2019-04-08)
+
+ - Updated glutin to version 0.20. See the glutin release notes [here](https://github.com/tomaka/glutin/blob/master/CHANGELOG.md#version-0200-2019-03-09).
+ - Depth comparison and shadow mapping ([#1679](https://github.com/glium/glium/pull/1679)).
+
 ## Version 0.23.0 (2018-12-05)
 
  - Updated glutin to version 0.19. See the glutin release notes [here](https://github.com/tomaka/glutin/blob/master/CHANGELOG.md#version-0190-2018-11-09).

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "glium"
-version = "0.23.0"
+version = "0.24.0"
 authors = ["Pierre Krieger <[email protected]>"]
 description = """
 Elegant and safe OpenGL wrapper.
@@ -35,7 +35,7 @@ unstable = [] # used for benchmarks
 test_headless = []  # used for testing headless display
 
 [dependencies.glutin]
-version = "0.19"
+version = "0.20"
 features = []
 optional = true
 
@@ -46,11 +46,11 @@ smallvec = "0.6"
 fnv = "1.0.5"
 
 [build-dependencies]
-gl_generator = "0.10"
+gl_generator = "0.11"
 
 [dev-dependencies]
-cgmath = "0.16"
+cgmath = "0.17"
 genmesh = "0.6"
-image = "0.20"
+image = "0.21"
 obj = { version = "0.9", features = ["genmesh"] }
 rand = "0.6"

examples/gpgpu.rs

@@ -2,11 +2,16 @@
 extern crate glium;
 extern crate rand;
 use glium::glutin;
+use glutin::dpi::PhysicalSize;
 
 fn main() {
     let event_loop = glium::glutin::EventsLoop::new();
     let context_builder = glutin::ContextBuilder::new();
-    let context = glutin::Context::new(&event_loop, context_builder, false).unwrap();
+    let size = PhysicalSize {
+        width: 800.0,
+        height: 600.0,
+    };
+    let context = context_builder.build_headless(&event_loop, size).unwrap();
     let display = glium::backend::glutin::headless::Headless::new(context).unwrap();
 
     let program = glium::program::ComputeShader::from_source(&display, r#"\

examples/manual-creation.rs

@@ -19,7 +19,7 @@ There are three concepts in play:
 extern crate glium;
 
 use glium::Surface;
-use glium::glutin::{self, GlContext};
+use glium::glutin::{self, ContextTrait};
 
 use std::rc::Rc;
 use std::os::raw::c_void;
@@ -29,13 +29,13 @@ fn main() {
     // note that it's just `build` and not `build_glium`
     let mut events_loop = glutin::EventsLoop::new();
     let window = glutin::WindowBuilder::new();
-    let context = glutin::ContextBuilder::new();
-    let gl_window = Rc::new(glutin::GlWindow::new(window, context, &events_loop).unwrap());
+    let context_builder = glutin::ContextBuilder::new();
+    let gl_window = Rc::new(context_builder.build_windowed(window, &events_loop).unwrap());
 
     // in order to create our context, we will need to provide an object which implements
     // the `Backend` trait
     struct Backend {
-        gl_window: Rc<glutin::GlWindow>,
+        gl_window: Rc<glutin::WindowedContext>,
     }
 
     unsafe impl glium::backend::Backend for Backend {

examples/shadow_mapping.rs

@@ -5,15 +5,19 @@ extern crate cgmath;
 use cgmath::SquareMatrix;
 use glium::{glutin, Surface};
 use std::time::Instant;
+use glutin::dpi::LogicalSize;
 
 fn main() {
-    let win_size = (800, 600);
+    let win_size = LogicalSize {
+        width: 800.0,
+        height: 600.0,
+    };
     let shadow_map_size = 1024;
 
     // Create the main window
     let mut events_loop = glutin::EventsLoop::new();
     let window = glutin::WindowBuilder::new()
-        .with_dimensions(win_size.0, win_size.1)
+        .with_dimensions(win_size)
         .with_title("Shadow Mapping");
     let context = glutin::ContextBuilder::new().with_vsync(true);
     let display = glium::Display::new(window, context, &events_loop).unwrap();
@@ -161,7 +165,7 @@ fn main() {
         // Handle events
         events_loop.poll_events(|event| match event {
             glutin::Event::WindowEvent { event, .. } => match event {
-                glutin::WindowEvent::Closed => exit = true,
+                glutin::WindowEvent::CloseRequested => exit = true,
                 glutin::WindowEvent::KeyboardInput { input, .. } => if input.state == glutin::ElementState::Pressed {
                     if let Some(key) = input.virtual_keycode {
                         match key {
@@ -227,7 +231,7 @@ fn main() {
 
         // Render the scene from the camera's point of view
         // ===============================================================================
-        let screen_ratio = (win_size.0 as f32) / (win_size.1 as f32);
+        let screen_ratio = (win_size.width / win_size.height) as f32;
         let perspective_matrix: cgmath::Matrix4<f32> = cgmath::perspective(cgmath::Deg(45.0), screen_ratio, 0.0001, 100.0);
         let camera_x = 3.0 * camera_t.cos();
         let camera_z = 3.0 * camera_t.sin();

src/backend/glutin/headless.rs

@@ -4,12 +4,11 @@ use {Frame, IncompatibleOpenGl, SwapBuffersError};
 use debug;
 use context;
 use backend::{self, Backend};
+use backend::glutin::glutin::ContextTrait;
 use std::rc::Rc;
 use std::ops::Deref;
 use std::os::raw::c_void;
 use super::glutin;
-use super::glutin::GlContext;
-
 
 /// A headless glutin context.
 pub struct Headless {

src/backend/glutin/mod.rs

@@ -18,7 +18,7 @@ use context;
 use backend;
 use backend::Context;
 use backend::Backend;
-use glutin::GlContext;
+use backend::glutin::glutin::ContextTrait;
 use std;
 use std::cell::{Cell, RefCell, Ref};
 use std::error::Error;
@@ -37,15 +37,15 @@ pub struct Display {
     // contains everything related to the current context and its state
     context: Rc<context::Context>,
     // The glutin Window alongside its associated GL Context.
-    gl_window: Rc<RefCell<glutin::GlWindow>>,
+    gl_window: Rc<RefCell<glutin::WindowedContext>>,
     // Used to check whether the framebuffer dimensions have changed between frames. If they have,
     // the glutin context must be resized accordingly.
     last_framebuffer_dimensions: Cell<(u32, u32)>,
 }
 
 /// An implementation of the `Backend` trait for glutin.
 #[derive(Clone)]
-pub struct GlutinBackend(Rc<RefCell<glutin::GlWindow>>);
+pub struct GlutinBackend(Rc<RefCell<glutin::WindowedContext>>);
 
 /// Error that can happen while creating a glium display.
 #[derive(Debug)]
@@ -67,44 +67,44 @@ impl Display {
         events_loop: &glutin::EventsLoop,
     ) -> Result<Self, DisplayCreationError>
     {
-        let gl_window = try!(glutin::GlWindow::new(window_builder, context_builder, events_loop));
+        let gl_window = glutin::WindowedContext::new_windowed(window_builder, context_builder, events_loop)?;
         Self::from_gl_window(gl_window).map_err(From::from)
     }
 
     /// Create a new glium `Display`.
     ///
     /// Performs a compatibility check to make sure that all core elements of glium are supported
     /// by the implementation.
-    pub fn from_gl_window(gl_window: glutin::GlWindow) -> Result<Self, IncompatibleOpenGl> {
+    pub fn from_gl_window(gl_window: glutin::WindowedContext) -> Result<Self, IncompatibleOpenGl> {
         Self::with_debug(gl_window, Default::default())
     }
 
     /// Create a new glium `Display`.
     ///
     /// This function does the same as `build_glium`, except that the resulting context
     /// will assume that the current OpenGL context will never change.
-    pub unsafe fn unchecked(gl_window: glutin::GlWindow) -> Result<Self, IncompatibleOpenGl> {
+    pub unsafe fn unchecked(gl_window: glutin::WindowedContext) -> Result<Self, IncompatibleOpenGl> {
         Self::unchecked_with_debug(gl_window, Default::default())
     }
 
     /// The same as the `new` constructor, but allows for specifying debug callback behaviour.
-    pub fn with_debug(gl_window: glutin::GlWindow, debug: debug::DebugCallbackBehavior)
+    pub fn with_debug(gl_window: glutin::WindowedContext, debug: debug::DebugCallbackBehavior)
         -> Result<Self, IncompatibleOpenGl>
     {
         Self::new_inner(gl_window, debug, true)
     }
 
     /// The same as the `unchecked` constructor, but allows for specifying debug callback behaviour.
     pub unsafe fn unchecked_with_debug(
-        gl_window: glutin::GlWindow,
+        gl_window: glutin::WindowedContext,
         debug: debug::DebugCallbackBehavior,
     ) -> Result<Self, IncompatibleOpenGl>
     {
         Self::new_inner(gl_window, debug, false)
     }
 
     fn new_inner(
-        gl_window: glutin::GlWindow,
+        gl_window: glutin::WindowedContext,
         debug: debug::DebugCallbackBehavior,
         checked: bool,
     ) -> Result<Self, IncompatibleOpenGl>
@@ -120,10 +120,10 @@ impl Display {
         })
     }
 
-    /// Rebuilds the Display's `GlWindow` with the given window and context builders.
+    /// Rebuilds the Display's `WindowedContext` with the given window and context builders.
     ///
-    /// This method ensures that the new `GlWindow`'s `Context` will share the display lists of the
-    /// original `GlWindow`'s `Context`.
+    /// This method ensures that the new `WindowedContext`'s `Context` will share the display lists of the
+    /// original `WindowedContext`'s `Context`.
     pub fn rebuild(
         &self,
         window_builder: glutin::WindowBuilder,
@@ -135,11 +135,11 @@ impl Display {
         let new_gl_window = {
             let gl_window = self.gl_window.borrow();
             let context_builder = context_builder.with_shared_lists(gl_window.context());
-            try!(glutin::GlWindow::new(window_builder, context_builder, events_loop))
+            glutin::WindowedContext::new_windowed(window_builder, context_builder, events_loop)?
         };
 
         {
-            // Replace the stored GlWindow with the new one.
+            // Replace the stored WindowedContext with the new one.
             let mut gl_window = self.gl_window.borrow_mut();
             std::mem::replace(&mut (*gl_window), new_gl_window);
         }
@@ -151,9 +151,9 @@ impl Display {
         Ok(())
     }
 
-    /// Borrow the inner glutin GlWindow.
+    /// Borrow the inner glutin WindowedContext.
     #[inline]
-    pub fn gl_window(&self) -> Ref<glutin::GlWindow> {
+    pub fn gl_window(&self) -> Ref<glutin::WindowedContext> {
         self.gl_window.borrow()
     }
 
@@ -234,9 +234,9 @@ impl backend::Facade for Display {
 }
 
 impl Deref for GlutinBackend {
-    type Target = Rc<RefCell<glutin::GlWindow>>;
+    type Target = Rc<RefCell<glutin::WindowedContext>>;
     #[inline]
-    fn deref(&self) -> &Rc<RefCell<glutin::GlWindow>> {
+    fn deref(&self) -> &Rc<RefCell<glutin::WindowedContext>> {
         &self.0
     }
 }

src/lib.rs

@@ -4,7 +4,7 @@ Easy-to-use, high-level, OpenGL3+ wrapper.
 Glium is based on glutin - a cross-platform crate for building an OpenGL window and handling
 application events.
 
-Glium provides a **Display** which extends the **glutin::GlWindow** with a high-level, safe API.
+Glium provides a **Display** which extends the **glutin::WindowedContext** with a high-level, safe API.
 
 # Initialization