Update glutin and gfx_window_glutin versions.

Author: rukai

Cargo.toml

@@ -44,8 +44,8 @@ vec_map = "0.8"
 
 # OpenGL
 gfx_device_gl = { version = "0.15", optional = true }
-gfx_window_glutin = { version = "0.20", optional = true }
-glutin = { version = "0.12", optional = true }
+gfx_window_glutin = { version = "0.28", optional = true }
+glutin = { version = "0.19", optional = true }
 
 [dev-dependencies]
 env_logger = "0.6"

src/input/mod.rs

@@ -245,7 +245,7 @@ impl Input {
     ) {
         self.delta.mouse_wheel.push(match delta {
             MouseScrollDelta::LineDelta(_, y) => y * PIXELS_PER_LINE,
-            MouseScrollDelta::PixelDelta(_, y) => y,
+            MouseScrollDelta::PixelDelta(delta) => delta.y as f32,
         });
     }
 

src/lib.rs

@@ -358,4 +358,4 @@ pub use texture::{CubeMap, CubeMapPath, FilterMethod, Sampler, Texture, WrapMode
 
 #[cfg(feature = "opengl")]
 #[doc(inline)]
-pub use window::{CursorState, Window};
+pub use window::Window;

src/render/mod.rs

@@ -526,7 +526,8 @@ pub struct Renderer {
     map_default: Texture<[f32; 4]>,
     shadow_default: Texture<f32>,
     debug_quads: froggy::Storage<DebugQuad>,
-    size: (u32, u32),
+    size: glutin::dpi::LogicalSize,
+    dpi: f64,
     font_cache: HashMap<String, Font>,
     instance_cache: HashMap<InstanceCacheKey, InstanceData>,
     /// `ShadowType` of this `Renderer`.
@@ -543,7 +544,7 @@ impl Renderer {
     ) -> (Self, glutin::GlWindow, Factory) {
         use gfx::texture as t;
 
-        let (window, device, mut gl_factory, out_color, out_depth) = gfx_window_glutin::init(builder, context, event_loop);
+        let (window, device, mut gl_factory, out_color, out_depth) = gfx_window_glutin::init(builder, context, event_loop).unwrap();
         let (_, srv_white) = gl_factory
             .create_texture_immutable::<gfx::format::Rgba8>(
                 t::Kind::D2(1, 1, t::AaMode::Single),
@@ -634,6 +635,7 @@ impl Renderer {
             debug_quads: froggy::Storage::new(),
             font_cache: HashMap::new(),
             size: window.get_inner_size().unwrap(),
+            dpi: window.get_hidpi_factor(),
         };
         let factory = Factory::new(gl_factory);
         (renderer, window, factory)
@@ -650,22 +652,30 @@ impl Renderer {
     pub(crate) fn resize(
         &mut self,
         window: &glutin::GlWindow,
+        size: glutin::dpi::LogicalSize,
     ) {
-        let size = window.get_inner_size().unwrap();
-
         // skip updating view and self size if some
         // of the sides equals to zero (fixes crash on minimize on Windows machines)
-        if size.0 == 0 || size.1 == 0 {
+        if size.width == 0.0 || size.height == 0.0 {
             return;
         }
 
         self.size = size;
         gfx_window_glutin::update_views(window, &mut self.out_color, &mut self.out_depth);
     }
 
+    pub(crate) fn dpi_change(
+        &mut self,
+        window: &glutin::GlWindow,
+        dpi: f64,
+    ) {
+        self.dpi = dpi;
+        gfx_window_glutin::update_views(window, &mut self.out_color, &mut self.out_depth);
+    }
+
     /// Returns current viewport aspect ratio, i.e. width / height.
     pub fn aspect_ratio(&self) -> f32 {
-        self.size.0 as f32 / self.size.1 as f32
+        self.size.to_physical(self.dpi).width as f32 / self.size.to_physical(self.dpi).height as f32
     }
 
     /// Map screen pixel coordinates to Normalized Display Coordinates.
@@ -677,8 +687,8 @@ impl Renderer {
     ) -> mint::Point2<f32> {
         let point = point.into();
         mint::Point2 {
-            x: 2.0 * point.x / self.size.0 as f32 - 1.0,
-            y: 1.0 - 2.0 * point.y / self.size.1 as f32,
+            x: 2.0 * point.x / self.size.to_physical(self.dpi).width as f32 - 1.0,
+            y: 1.0 - 2.0 * point.y / self.size.to_physical(self.dpi).height as f32,
         }
     }
 
@@ -1113,12 +1123,12 @@ impl Renderer {
                 if quad.pos[0] >= 0 {
                     quad.pos[0]
                 } else {
-                    self.size.0 as i32 + quad.pos[0] - quad.size[0]
+                    self.size.to_physical(self.dpi).width as i32 + quad.pos[0] - quad.size[0]
                 },
                 if quad.pos[1] >= 0 {
                     quad.pos[1]
                 } else {
-                    self.size.1 as i32 + quad.pos[1] - quad.size[1]
+                    self.size.to_physical(self.dpi).height as i32 + quad.pos[1] - quad.size[1]
                 },
             ];
             let p0 = self.map_to_ndc([pos[0] as f32, pos[1] as f32]);

src/window.rs

@@ -1,7 +1,6 @@
 //! Primitives for creating and controlling [`Window`](struct.Window.html).
 
 use glutin;
-use glutin::GlContext;
 use mint;
 use render;
 
@@ -12,15 +11,14 @@ use render::Renderer;
 use scene::Scene;
 use std::path::PathBuf;
 
-pub use glutin::CursorState;
-
 /// `Window` is the core entity of every `three-rs` application.
 ///
 /// It provides [user input](struct.Window.html#method.update),
 /// [`Factory`](struct.Factory.html) and [`Renderer`](struct.Renderer.html).
 pub struct Window {
     event_loop: glutin::EventsLoop,
     window: glutin::GlWindow,
+    dpi: f64,
     /// See [`Input`](struct.Input.html).
     pub input: Input,
     /// See [`Renderer`](struct.Renderer.html).
@@ -38,7 +36,7 @@ pub struct Window {
 /// Builder for creating new [`Window`](struct.Window.html) with desired parameters.
 #[derive(Debug, Clone)]
 pub struct Builder {
-    dimensions: (u32, u32),
+    dimensions: glutin::dpi::LogicalSize,
     fullscreen: bool,
     multisampling: u16,
     shader_directory: Option<PathBuf>,
@@ -47,13 +45,15 @@ pub struct Builder {
 }
 
 impl Builder {
-    /// Set the size of the viewport (the resolution) in pixels. Defaults to 1024x768.
+    /// Set the size of the viewport (the resolution) in logical pixels.
+    /// That is the dpi setting affects the amount of pixels used but the window will
+    /// take up the same amount of space regardless of dpi. Defaults to 1024x768.
     pub fn dimensions(
         &mut self,
-        width: u32,
-        height: u32,
+        width: f64,
+        height: f64,
     ) -> &mut Self {
-        self.dimensions = (width, height);
+        self.dimensions = glutin::dpi::LogicalSize::new(width, height);
         self
     }
 
@@ -105,7 +105,7 @@ impl Builder {
 
         let builder = glutin::WindowBuilder::new()
             .with_fullscreen(monitor_id)
-            .with_dimensions(self.dimensions.0, self.dimensions.1)
+            .with_dimensions(self.dimensions)
             .with_title(self.title.clone());
 
         let context = glutin::ContextBuilder::new()
@@ -146,10 +146,12 @@ impl Builder {
         }
 
         let (renderer, window, mut factory) = Renderer::new(builder, context, &event_loop, &source_set);
+        let dpi = window.get_hidpi_factor();
         let scene = factory.scene();
         Window {
             event_loop,
             window,
+            dpi,
             input: Input::new(),
             renderer,
             factory,
@@ -168,7 +170,7 @@ impl Window {
     /// Create new `Builder` with standard parameters.
     pub fn builder<T: Into<String>>(title: T) -> Builder {
         Builder {
-            dimensions: (1024, 768),
+            dimensions: glutin::dpi::LogicalSize::new(1024.0, 768.0),
             fullscreen: false,
             multisampling: 0,
             shader_directory: None,
@@ -188,30 +190,30 @@ impl Window {
 
         self.window.swap_buffers().unwrap();
         let window = &self.window;
+        let dpi = self.dpi;
 
         self.event_loop.poll_events(|event| {
-            use glutin::WindowEvent::{Closed, Focused, KeyboardInput, MouseInput, CursorMoved, MouseWheel, Resized};
+            use glutin::WindowEvent;
             match event {
                 glutin::Event::WindowEvent { event, .. } => match event {
-                    Resized(..) => renderer.resize(window),
-                    Focused(state) => input.window_focus(state),
-                    Closed => running = false,
-                    KeyboardInput {
+                    WindowEvent::Resized(size) => renderer.resize(window, size),
+                    WindowEvent::HiDpiFactorChanged(dpi) => renderer.dpi_change(window, dpi),
+                    WindowEvent::Focused(state) => input.window_focus(state),
+                    WindowEvent::CloseRequested | WindowEvent::Destroyed => running = false,
+                    WindowEvent::KeyboardInput {
                         input: glutin::KeyboardInput {
                             state,
                             virtual_keycode: Some(keycode),
                             ..
                         },
                         ..
                     } => input.keyboard_input(state, keycode),
-                    MouseInput { state, button, .. } => input.mouse_input(state, button),
-                    CursorMoved {
-                        position: (x, y), ..
-                    } => input.mouse_moved(
-                        [x as f32, y as f32].into(),
-                        renderer.map_to_ndc([x as f32, y as f32]),
-                    ),
-                    MouseWheel { delta, .. } => input.mouse_wheel_input(delta),
+                    WindowEvent::MouseInput { state, button, .. } => input.mouse_input(state, button),
+                    WindowEvent::CursorMoved { position, .. } => {
+                        let pos = position.to_physical(dpi);
+                        input.mouse_moved([pos.x as f32, pos.y as f32].into(), renderer.map_to_ndc([pos.x as f32, pos.y as f32]));
+                    }
+                    WindowEvent::MouseWheel { delta, .. } => input.mouse_wheel_input(delta),
                     _ => {}
                 },
                 glutin::Event::DeviceEvent { event, .. } => match event {
@@ -239,24 +241,9 @@ impl Window {
     pub fn size(&self) -> mint::Vector2<f32> {
         let size = self.window
             .get_inner_size()
-            .expect("Can't get window size");
-        [size.0 as f32, size.1 as f32].into()
-    }
-
-    /// Sets how the cursor should be handled.
-    ///
-    /// See the documentation for [`CursorState`] for the possible cursor states.
-    ///
-    /// Note that if you use [`CursorState::Grab`], you should use [`Input::mouse_delta_raw`] for
-    /// detecting mouse movement, as [`Input::mouse_delta`] will only report movement of the cursor
-    /// within the window.
-    ///
-    /// [`CursorState`]: enum.CursorState.html
-    /// [`CursorState::Grab`]: enum.CursorState.html#variant.Grab
-    /// [`Input::mouse_delta_raw`]: struct.Input.html#method.mouse_delta_raw
-    /// [`Input::mouse_delta`]: struct.Input.html#method.mouse_delta_raw
-    pub fn set_cursor_state(&self, state: CursorState) {
-        let _ = self.window.set_cursor_state(state);
+            .expect("Can't get window size")
+            .to_physical(self.dpi);
+        [size.width as f32, size.height as f32].into()
     }
 
     /// Returns underlaying `glutin::GlWindow`.