Port to glium 0.17 and glutin 0.9.

Involved a major rework of input handling.

diff --git a/Cargo.toml b/Cargo.toml
index 4d56af3aeb5f6c332da83121de4dd80aae099f3f..9c1bd7f403b2a2749f6bc1169d9323f868466027 100644 (file)
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,8 +12,8 @@ opt-level = 3
 
 [dependencies]
 cgmath = "*"
-glium = "0.16.0"
-glutin = "0.7.4"
+glium = "0.17.0"
+glutin = "0.9"
 genmesh = "0.4.1"
 image = { version = "0.14.0", features = ["png_codec"], optional = true }
 libxm = "1.0.0"

diff --git a/main.rs b/main.rs
index bd75e428df4b225cef9576fe13f51043f2ab7a59..5fc2ded11b78b2f7dcc95d1a598967e58bd32666 100644 (file)
--- a/main.rs
+++ b/main.rs
@@ -7,9 +7,9 @@ extern crate glutin;
 
 use cgmath::{Euler, Matrix4, Rad, SquareMatrix, Vector3, Vector4, Zero};
 use cgmath::conv::array4x4;
-use glium::{DisplayBuild, Surface};
+use glium::{Surface};
 use glutin::ElementState::Pressed;
-use glutin::Event::KeyboardInput;
+use glutin::WindowEvent::KeyboardInput;
 use glutin::VirtualKeyCode;
 use mandelwow_lib::*;
 use std::f32::consts::PI;
@@ -65,18 +65,17 @@ pub fn set_main_loop_callback<F>(callback : F) where F : FnMut() -> support::Act
 fn main() {
     let mut soundplayer = sound::start();
 
-    let display = glutin::WindowBuilder::new()
+    let mut events_loop = glutin::EventsLoop::new();
+    let window = glutin::WindowBuilder::new()
         .with_dimensions(1280, 720)
-        .with_gl_profile(glutin::GlProfile::Core)
         //.with_fullscreen(glutin::get_primary_monitor())
+        .with_title("MandelWow");
+    let context = glutin::ContextBuilder::new()
+        .with_gl_profile(glutin::GlProfile::Core)
         .with_depth_buffer(24)
-        .with_vsync()
-        .with_srgb(Some(true))
-        .with_title("MandelWow")
-        .build_glium()
-        //.build_glium_debug(glium::debug::DebugCallbackBehavior::PrintAll)
-        .unwrap();
-
+        .with_vsync(true)
+        .with_srgb(true);
+    let display = glium::Display::new(window, context, &events_loop).unwrap();
     gl_info(&display);
 
     let mut text = text::Text::new(&display, 'A');
@@ -193,47 +192,67 @@ fn main() {
 
         frame.finish().unwrap();
 
-        for ev in display.poll_events() {
-            match ev {
-                glutin::Event::Closed |
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::Escape)) |
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::Q)) => {
-                    return support::Action::Stop
-                },
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::B)) => {
-                    bounding_box_enabled ^= true;
-                },
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::P)) => {
-                    timer.pause ^= true;
-                },
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::PageUp)) => {
-                    timer.t += 0.01;
-                },
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::PageDown)) => {
-                    timer.t -= 0.01;
-                },
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::F10)) => {
-                    screenshot(&display);
-                },
-                KeyboardInput(Pressed, _, Some(VirtualKeyCode::F11)) => {
-                    fullscreen ^= true;
-                    if fullscreen {
-                        // Not implemented on Linux
-                        glutin::WindowBuilder::new()
-                            .with_fullscreen(glutin::get_primary_monitor())
-                            .with_depth_buffer(24)
-                            .rebuild_glium(&display).unwrap();
-                    } else {
-                        glutin::WindowBuilder::new()
-                            .rebuild_glium(&display).unwrap();
-                    }
-                },
-                ev => camera.process_input(&ev),
+        let mut action = support::Action::Continue;
+        events_loop.poll_events(|event| {
+            if let glutin::Event::WindowEvent { event, .. } = event {
+                camera.process_input(&event);
+                match event {
+                    glutin::WindowEvent::Closed => {
+                        action = support::Action::Stop
+                    },
+                    KeyboardInput { input, .. } => {
+                        if input.state == glutin::ElementState::Pressed {
+                            if let Some(key) = input.virtual_keycode {
+                                match key {
+                                    VirtualKeyCode::Escape | VirtualKeyCode::Q => {
+                                        action = support::Action::Stop;
+                                    },
+                                    _ => (),
+                                }
+                            }
+                        }
+                    },
+/*
+                    KeyboardInput { input: glutin::KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::Escape), .. } } |
+                    KeyboardInput { input: glutin::KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::Q), .. } } => {
+                        return support::Action::Stop
+                    },
+                    KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::B) } => {
+                        bounding_box_enabled ^= true;
+                    },
+                    KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::P) } => {
+                        timer.pause ^= true;
+                    },
+                    KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::PageUp) } => {
+                        timer.t += 0.01;
+                    },
+                    KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::PageDown) } => {
+                        timer.t -= 0.01;
+                    },
+                    KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::F10) } => {
+                        screenshot(&display);
+                    },
+                    KeyboardInput { state: Pressed, virtual_keycode: Some(VirtualKeyCode::F11) } => {
+                        fullscreen ^= true;
+                        if fullscreen {
+                            // Not implemented on Linux
+                            glutin::WindowBuilder::new()
+                                .with_fullscreen(glutin::get_primary_monitor())
+                                .with_depth_buffer(24)
+                                .rebuild_glium(&display).unwrap();
+                        } else {
+                            glutin::WindowBuilder::new()
+                                .rebuild_glium(&display).unwrap();
+                        }
+                    },
+*/
+                    _ => (),
+                }
             }
-        }
+        });
 
         timer.update();
 
-        support::Action::Continue
+        action
     });
 }

diff --git a/support/camera.rs b/support/camera.rs
index c036abff537281412fc90fa1b085d6269d02a627..69e3bb5388447df98326398edabd3d01f13833e0 100644 (file)
--- a/support/camera.rs
+++ b/support/camera.rs
@@ -2,18 +2,13 @@ extern crate glutin;
 
 use cgmath::{Matrix4, Vector4};
 use cgmath::conv::array4x4;
-use glutin::ElementState::{Pressed, Released};
-use glutin::Event::{KeyboardInput, MouseMoved};
+use glutin::WindowEvent::{KeyboardInput, MouseMoved};
 use glutin::VirtualKeyCode;
+use std::f32;
 use std::f32::consts::PI;
 use support::vec3::Vec3;
 use support::vec3::norm;
 
-use std::f32;
-
-//use glutin::Event;
-//use VirtualKeyCode;
-
 #[derive(Default)]
 pub struct CameraState {
     aspect: f32,
@@ -170,9 +165,10 @@ impl CameraState {
         //println!("camera_dir = {:?}", self.dir);
     }
 
-    pub fn process_input(&mut self, event: &glutin::Event) {
+    pub fn process_input(&mut self, event: &glutin::WindowEvent) {
         match event {
-            &MouseMoved(x, y) => {
+            &MouseMoved { position: (x, y), .. }  => {
+                let (x, y) = (x as i32, y as i32);
                 if self.mouse_x == -1 {
                     // Set initial absolute position.
                     self.mouse_x = x;
@@ -183,67 +179,27 @@ impl CameraState {
                 self.mouse_x = x;
                 self.mouse_y = y;
             }
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Up)) => {
-                self.moving_up = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::Up)) => {
-                self.moving_up = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Down)) => {
-                self.moving_down = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::Down)) => {
-                self.moving_down = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Left)) => {
-                self.moving_left = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::Left)) => {
-                self.moving_left = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::Right)) => {
-                self.moving_right = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::Right)) => {
-                self.moving_right = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::A)) => {
-                self.turning_left = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::A)) => {
-                self.turning_left = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::D)) => {
-                self.turning_right = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::D)) => {
-                self.turning_right = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::W)) => {
-                self.moving_forward = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::W)) => {
-                self.moving_forward = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::S)) => {
-                self.moving_backward = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::S)) => {
-                self.moving_backward = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::R)) => {
-                self.turning_up = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::R)) => {
-                self.turning_up = false;
-            },
-            &KeyboardInput(Pressed, _, Some(VirtualKeyCode::F)) => {
-                self.turning_down = true;
-            },
-            &KeyboardInput(Released, _, Some(VirtualKeyCode::F)) => {
-                self.turning_down = false;
+            &KeyboardInput { input, .. } => {
+                let pressed = input.state == glutin::ElementState::Pressed;
+                let key = match input.virtual_keycode {
+                    Some(key) => key,
+                    None => return,
+                };
+                match key {
+                    VirtualKeyCode::Left => self.moving_left = pressed,
+                    VirtualKeyCode::Right => self.moving_right = pressed,
+                    VirtualKeyCode::Up => self.moving_up = pressed,
+                    VirtualKeyCode::Down => self.moving_down = pressed,
+                    VirtualKeyCode::W => self.moving_forward = pressed,
+                    VirtualKeyCode::S => self.moving_backward = pressed,
+                    VirtualKeyCode::A => self.turning_left = pressed,
+                    VirtualKeyCode::D => self.turning_right = pressed,
+                    VirtualKeyCode::R => self.turning_up = pressed,
+                    VirtualKeyCode::F => self.turning_down = pressed,
+                    _ => (),
+                }
             },
-            _ => {}
+            _ => (),
         }
     }
 }