remove bitrot, update and set versions of all deps, notably gfx & nalgebra

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "vrtue"
 version = "0.1.0"
-authors = ["Jared Roberts <jaredr@gmail.com>"]
+authors = ["Jared Burce <jaredr@gmail.com>"]
 
 [dependencies]
 env_logger = "0.3"
@@ -9,17 +9,16 @@ itertools = ">=0.4"
 log = "0.3"
 memmap = "~0.2"
 
-gl = "*"
+gl = "0.10"
-gfx = "*"
+gfx = "0.17"
-gfx_device_gl = "*"
+gfx_device_gl = "0.15"
-image = "*"
+image = "0.19"
-lzw = "*"
+lzw = "0.10"
-nalgebra = "*"
+nalgebra = "0.16"
-num-traits = "*"
+openvr = "0.5"
-openvr = { git = "https://github.com/rust-openvr/rust-openvr" }
+openvr_sys = "2"
-openvr_sys = "*"
+piston = "0.37"
-piston = "*"
+piston_window = "0.80"
-piston_window = "*"
 
 [profile.release]
 lto = true

src/bin/click.rs

@@ -4,7 +4,6 @@ use vrtue::vr;
 extern crate env_logger;
 extern crate gfx;
 #[macro_use] extern crate log;
-extern crate openvr_sys;
 extern crate piston_window;
 
 use self::piston_window::{PistonWindow, Window, WindowSettings};
@@ -22,9 +21,9 @@ pub fn main() {
     .build().expect("Building Window");
 
   let render_size = vr.recommended_render_target_size();
-  let left: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size)
+  let left: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
     .expect("create left renderbuffer");
-  let right: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size)
+  let right: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
     .expect("create right renderbuffer");
   window.encoder.clear(&left.target, [1.0, 0.0, 0.0, 1.0]);
   window.encoder.clear_depth(&left.depth, 1.0);
@@ -32,31 +31,31 @@ pub fn main() {
   window.encoder.clear_depth(&right.depth, 1.0);
   window.encoder.flush(&mut window.device);
 
-  let mut pads = ::std::collections::BTreeMap::<_, Option<openvr_sys::VRControllerState_t>>::new();
+  let mut pads = ::std::collections::BTreeMap::<_, Option<vr::ControllerState>>::new();
   'main: loop {
     let _poses = vr.poses();
-    vr.submit(vr::Eye::Left, &left.tex);
+    vr.submit(vr::Eye::Left, &left.tex).expect("submit left eye");
-    vr.submit(vr::Eye::Right, &right.tex);
+    vr.submit(vr::Eye::Right, &right.tex).expect("submit right eye");
 
     while let Some(ev) = vr.poll_next_event() {
       match ev {
-        vr::Event::Press { dev_idx, controller } => {
+        vr::Event::Press { dev_idx, button } => {
-          println!("Press event on #{}: {:?}", dev_idx, controller);
+          println!("Press event on #{}: {}", dev_idx, button);
         },
-        vr::Event::Unpress { dev_idx, controller } => {
+        vr::Event::Unpress { dev_idx, button } => {
-          println!("Unpress event on #{}: {:?}", dev_idx, controller);
+          println!("Unpress event on #{}: {}", dev_idx, button);
         },
-        vr::Event::Touch { dev_idx, controller } => {
+        vr::Event::Touch { dev_idx, button } => {
-          if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
+          if button == vr::button_id::STEAM_VR_TOUCHPAD as u32 {
             pads.insert(dev_idx, None);
           }
-          println!("Touch event on #{}: {:?}", dev_idx, controller);
+          println!("Touch event on #{}: {}", dev_idx, button);
         },
-        vr::Event::Untouch { dev_idx, controller } => {
+        vr::Event::Untouch { dev_idx, button } => {
-          if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
+          if button == vr::button_id::STEAM_VR_TOUCHPAD as u32 {
             pads.remove(&dev_idx);
           }
-          println!("Untouch event on #{}: {:?}", dev_idx, controller);
+          println!("Untouch event on #{}: {}", dev_idx, button);
         },
         /*
         t if t == openvr_sys::EVREventType::EVREventType_VREvent_TouchPadMove as u32 => {
@@ -74,7 +73,7 @@ pub fn main() {
     for (pad, old) in pads.iter_mut() {
       if let Some(state) = vr.get_controller_state(*pad) {
         if let Some(old_state) = *old {
-          if state.unPacketNum == old_state.unPacketNum {
+          if state.packet_num == old_state.packet_num {
             continue;
           }
         }

src/bin/vrtue.rs

@@ -8,7 +8,7 @@ extern crate gfx_device_gl;
 extern crate piston;
 extern crate piston_window;
 
-use self::piston::input::{Button, Input, Key};
+use self::piston::input::{Button, ButtonArgs, Input, Key};
 use self::piston_window::{PistonWindow, Window, WindowSettings};
 use std::env;
 
@@ -37,13 +37,13 @@ pub fn main() {
   //while let Some(_) = window.next() {
   loop {
     scene.update(&mut vr, &mut window.encoder);
-    view.draw(&mut window, &mut vr, &scene);
+    view.draw(&mut window, &mut vr, &scene).expect("main draw");
 
     // handle window events
     while let Some(ev) = window.poll_event() {
       match ev {
-        Input::Press(Button::Keyboard(Key::Space)) |
+        Input::Button(ButtonArgs { button: Button::Keyboard(Key::Space), .. }) |
-        Input::Press(Button::Keyboard(Key::Escape)) => break 'main,
+        Input::Button(ButtonArgs { button: Button::Keyboard(Key::Escape), .. }) => break 'main,
         _ => debug!("\t{:?}", ev)
       }
 

src/lib.rs

@@ -1,9 +1,8 @@
-#![feature(conservative_impl_trait)]
+#![feature(iterator_flatten)]
 
 #[macro_use] extern crate gfx;
-#[macro_use] extern crate log;
+#[allow(unused_imports)] #[macro_use] extern crate log;
 extern crate nalgebra as na;
-extern crate num_traits;
 extern crate piston;
 
 pub mod arena;

src/scenes/world.rs

@@ -13,9 +13,8 @@ use std::time::SystemTime;
 
 use gfx::{self, texture};
 use gfx::traits::FactoryExt;
-use na::{self, ToHomogeneous};
+use na;
-use num_traits::identities::One;
+use piston::input::{Button, ButtonArgs, ButtonState, Input, Key};
-use piston::input::{Button, Input, Key};
 
 const PI: f32 = ::std::f32::consts::PI;
 const TWO_PI_CIRC: f32 = 2.0 * PI / 256.0;
@@ -135,7 +134,7 @@ pub struct WorldScene<D: gfx::Device,
 
   start_time: SystemTime,
   treadmills: (f32, f32),
-  pads: BTreeMap<u32, (TrackMode, Option<vr::VRControllerState_t>)>,
+  pads: BTreeMap<u32, (TrackMode, Option<vr::ControllerState>)>,
 
   _worldmap: model::World,
   lat: u8,
@@ -156,7 +155,7 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
                                           FRAGMENT_SHADER_SRC,
                                           pipe::new())
                   .expect("create pipeline"),
-      camera: na::Matrix4::one(),
+      camera: na::Matrix4::identity(),
       constants: Constants { anim: ANIMDATA,
                              r1: R1, r2: R2, r3: R3,
                              haze: 1.0/2.0f32.sqrt(), hazecolor: SKY_COLOR },
@@ -164,7 +163,7 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
       constants_dirty: true,
       locals: factory.create_constant_buffer(1),
       atlas: tile::get_tiles::<_, _, view::ColorFormat>(device, factory, aux_command),
-      sampler: factory.create_sampler(texture::SamplerInfo::new(texture::FilterMethod::Jrd,
+      sampler: factory.create_sampler(texture::SamplerInfo::new(texture::FilterMethod::Trilinear, //::Jrd
                                                                 texture::WrapMode::Tile)),
       f: PhantomData,
 
@@ -217,60 +216,67 @@ impl<D: gfx::Device,
         self.pads.remove(&dev_idx);
       },
 
-      // treadmill / camera reset
+      Piston(Input::Button(ButtonArgs { state: ButtonState::Press,
-      Piston(Input::Press(Button::Keyboard(Key::Backspace))) => {
+                                        button: Button::Keyboard(key),
-        self.treadmills = (0.0, 0.0);
+                                        .. })) => {
-      },
+        match key {
-      Piston(Input::Press(Button::Keyboard(Key::D0))) => {
+          // treadmill / camera reset
-        self.camera = na::Matrix4::one();
+          Key::Backspace => {
-      },
+            self.treadmills = (0.0, 0.0);
+          },
+          Key::D0 => {
+            self.camera = na::Matrix4::identity();
+          },
 
-      // player movement
+          // player movement
-      Piston(Input::Press(Button::Keyboard(Key::Up))) => {
+          Key::Up => {
-        self.lat = self.lat.wrapping_sub(1);
+            self.lat = self.lat.wrapping_sub(1);
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::Down))) => {
+          Key::Down => {
-        self.lat = self.lat.wrapping_add(1);
+            self.lat = self.lat.wrapping_add(1);
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::Left))) => {
+          Key::Left => {
-        self.lng = self.lng.wrapping_sub(1);
+            self.lng = self.lng.wrapping_sub(1);
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::Right))) => {
+          Key::Right => {
-        self.lng = self.lng.wrapping_add(1);
+            self.lng = self.lng.wrapping_add(1);
-      },
+          },
 
-      // scale adjustment
+          // scale adjustment
-      Piston(Input::Press(Button::Keyboard(Key::Q))) => {
+          Key::Q => {
-        self.constants = Constants { r1: R1 / 2.0, r2: R2 / 2.0, r3: R3 / 2.0, ..self.constants };
+            self.constants = Constants { r1: R1 / 2.0, r2: R2 / 2.0, r3: R3 / 2.0, ..self.constants };
-        self.constants_dirty = true;
+            self.constants_dirty = true;
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::D1))) => {
+          Key::D1 => {
-        self.constants = Constants { r1: R1, r2: R2, r3: R3, ..self.constants };
+            self.constants = Constants { r1: R1, r2: R2, r3: R3, ..self.constants };
-        self.constants_dirty = true;
+            self.constants_dirty = true;
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::D2))) => {
+          Key::D2 => {
-        self.constants = Constants { r1: R1 * 2.0, r2: R2 * 2.0, r3: R3 * 2.0, ..self.constants };
+            self.constants = Constants { r1: R1 * 2.0, r2: R2 * 2.0, r3: R3 * 2.0, ..self.constants };
-        self.constants_dirty = true;
+            self.constants_dirty = true;
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::D3))) => {
+          Key::D3 => {
-        self.constants = Constants { r1: R1 * 4.0, r2: R2 * 4.0, r3: R3 * 4.0, ..self.constants };
+            self.constants = Constants { r1: R1 * 4.0, r2: R2 * 4.0, r3: R3 * 4.0, ..self.constants };
-        self.constants_dirty = true;
+            self.constants_dirty = true;
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::D4))) => {
+          Key::D4 => {
-        self.constants = Constants { r1: R1 * 16.0, r2: R2 * 16.0, r3: R3 * 16.0, ..self.constants };
+            self.constants = Constants { r1: R1 * 16.0, r2: R2 * 16.0, r3: R3 * 16.0, ..self.constants };
-        self.constants_dirty = true;
+            self.constants_dirty = true;
-      },
+          },
 
-      Piston(Input::Press(Button::Keyboard(Key::H))) => {
+          Key::H => {
-        self.constants = Constants { haze: self.constants.haze * 2.0f32.sqrt().sqrt(), ..self.constants };
+            self.constants = Constants { haze: self.constants.haze * 2.0f32.sqrt().sqrt(), ..self.constants };
-        println!("haze: {}", self.constants.haze);
+            println!("haze: {}", self.constants.haze);
-        self.constants_dirty = true;
+            self.constants_dirty = true;
-      },
+          },
-      Piston(Input::Press(Button::Keyboard(Key::N))) => {
+          Key::N => {
-        self.constants = Constants { haze: self.constants.haze / 2.0f32.sqrt().sqrt(), ..self.constants };
+            self.constants = Constants { haze: self.constants.haze / 2.0f32.sqrt().sqrt(), ..self.constants };
-        println!("haze: {}", self.constants.haze);
+            println!("haze: {}", self.constants.haze);
-        self.constants_dirty = true;
+            self.constants_dirty = true;
-      },
+          },
+          _ => ()
+        }
+      }
       _ => ()
     }
   }
@@ -291,31 +297,31 @@ impl<D: gfx::Device,
             TrackMode::Touch => {
               const THRESHOLD: f32 = 0.005;
               const SCALE: f32 = 32.0;
-              let xdiff = state.rAxis[0].x - old_state.rAxis[0].x;
+              let xdiff = state.axis[0].x - old_state.axis[0].x;
-              let ydiff = state.rAxis[0].y - old_state.rAxis[0].y;
+              let ydiff = state.axis[0].y - old_state.axis[0].y;
               if xdiff.abs() > THRESHOLD { self.treadmills.0 += SCALE * xdiff; }
               if ydiff.abs() > THRESHOLD { self.treadmills.1 += SCALE * ydiff; }
             },
             TrackMode::Press => {
               let rot = na::Vector3::new(0.0, 0.0, 0.0);
               let speed = R2 * 0.005;
-              if state.rAxis[0].x > 0.5 {
+              if state.axis[0].x > 0.5 {
                 self.camera = na::Similarity3::new(na::Vector3::new(-speed,  0.0, 0.0),
                                                    rot, 1.0).to_homogeneous() * self.camera;
-              } if state.rAxis[0].x < -0.5 {
+              } if state.axis[0].x < -0.5 {
                 self.camera = na::Similarity3::new(na::Vector3::new( speed,  0.0, 0.0),
                                                     rot, 1.0).to_homogeneous() * self.camera;
-              } if state.rAxis[0].y >  0.5 {
+              } if state.axis[0].y >  0.5 {
                 self.camera = na::Similarity3::new(na::Vector3::new( 0.0, -speed, 0.0),
                                                     rot, 1.0).to_homogeneous() * self.camera;
-              } if state.rAxis[0].y < -0.5 {
+              } if state.axis[0].y < -0.5 {
                 self.camera = na::Similarity3::new(na::Vector3::new( 0.0,  speed, 0.0),
                                                     rot, 1.0).to_homogeneous() * self.camera;
               }
             },
           }
 
-          if state.unPacketNum == old_state.unPacketNum {
+          if state.packet_num == old_state.packet_num {
             continue;
           }
         }
@@ -359,9 +365,9 @@ impl<D: gfx::Device,
     let (y, x) = (self.lat as f32 + 0.5, self.lng as f32 + 0.5);  // center of tile
     let eye = Self::toroid((x, y), r1, r2, r3);
     let looktgt = Self::toroid((x, y - 1.0), r1, r2, r3);  // look ahead = north
-    let normal = Self::toroid((x, y), 0.0, r2, r2) * na::Vector3::new(r2 / r3, 1.0, 1.0);
+    let normal = Self::toroid((x, y), 0.0, r2, r2).component_mul(&na::Vector3::new(r2 / r3, 1.0, 1.0));
-    self.camera * na::Isometry3::look_at_rh(eye.as_point(),
+    self.camera * na::Isometry3::look_at_rh(&na::Point3::from_coordinates(eye),
-                                            looktgt.as_point(),
+                                            &na::Point3::from_coordinates(looktgt),
                                             &normal,
                                            ).to_homogeneous()
   }

src/tile.rs

@@ -34,6 +34,7 @@ pub fn get_tiles<D, F, T>(device: &mut D,
                                                                             mipmap.dim as u16,
                                                                             mipmap.len as u16,
                                                                             texture::AaMode::Single),
+                                                     texture::Mipmap::Provided,
                                                      &mipmap.slices())
       .expect("create tile texture");
 
@@ -44,7 +45,7 @@ pub fn get_tiles<D, F, T>(device: &mut D,
     let access = gfx::pso::AccessInfo::new();
     let view = manager.ref_srv(tex.1.raw());
     command.generate_mipmap(*view);
-    device.submit(command, &access);
+    device.submit(command, &access).expect("generate tile mipmaps");
   }
   tex.1
 }

src/view.rs

@@ -2,11 +2,12 @@ use vr::{self, AsMatrix4, VR};
 
 extern crate gfx_device_gl;
 extern crate piston_window;
+extern crate openvr_sys;
 
 use gfx;
 use gfx::Device;
 use gfx::traits::FactoryExt;
-use na::{self, Inverse, ToHomogeneous};
+use na;
 use self::piston_window::{PistonWindow, Window};
 
 pub type ColorFormat = gfx::format::Srgba8;
@@ -38,12 +39,12 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
     if let &Some(ref vr) = vr {
       let render_size = vr.recommended_render_target_size();
 
-      let render_size = vr::Size { width: render_size.width * 100 / 100,
+      let render_size = (render_size.0 * 100 / 100,
-                                   height: render_size.height * 100 / 100 };
+                         render_size.1 * 100 / 100);
 
-      let left = vr::create_eyebuffer(&mut window.factory, render_size)
+      let left = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
           .expect("create left renderbuffer");
-      let right = vr::create_eyebuffer(&mut window.factory, render_size)
+      let right = vr::create_eyebuffer(&mut window.factory, render_size.0, render_size.1)
           .expect("create right renderbuffer");
       let trans = window.factory.create_constant_buffer(1);
 
@@ -67,13 +68,16 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
   pub fn draw(&self,
               window: &mut PistonWindow,
               vr: &mut Option<vr::VR>,
-              scene: &::scene::Scene<gfx_device_gl::Device, gfx_device_gl::Factory>) {
+              scene: &::scene::Scene<gfx_device_gl::Device, gfx_device_gl::Factory>)
+              -> Result<(), vr::Error>
+  {
     if let &mut Some(ref mut vr) = vr {
       // Get the current sensor state
-      let poses = vr.poses();
+      let poses = vr.poses().expect("vr poses");
 
-      let mut hmd_mat = poses.poses[0].to_device.as_matrix4();
+      let mut hmd_mat = poses[0].device_to_absolute_tracking().as_matrix4();
-      hmd_mat.inverse_mut();
+      let inv_worked = hmd_mat.try_inverse_mut();
+      assert!(inv_worked, "hmd matrix invert");
 
       for &(eye, buffers) in [(vr::Eye::Left, &self.left),
                               (vr::Eye::Right, &self.right)].into_iter() {
@@ -81,7 +85,7 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
         let depth = &buffers.as_ref().expect("vr depth buffer").depth;
 
         let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
-        let eye_mat = vr.head_to_eye_transform(eye);
+        let mut eye_mat = vr.head_to_eye_transform(eye);
         let scene_mat = scene.origin();
         let viewmodel_mat = eye_mat * hmd_mat * scene_mat;
         let trans = Trans { viewmodel: *viewmodel_mat.as_ref(),
@@ -99,11 +103,11 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
       let head_mat = na::Similarity3::new(na::Vector3::new(0.0, -1.5, 0.0),
                                           na::Vector3::new(0.0, 0.0, 0.0),
                                           1.0).to_homogeneous();
-      let proj_mat = na::PerspectiveMatrix3::new(1.0, 90.0, NEAR, FAR).to_matrix();
+      let proj_mat = na::geometry::Perspective3::new(1.0, 90.0, NEAR, FAR);
       let scene_mat = scene.origin();
       let viewmodel_mat = head_mat * scene_mat;
       let trans = Trans { viewmodel: *viewmodel_mat.as_ref(),
-                          matrix: *(proj_mat * viewmodel_mat).as_ref() };
+                          matrix: *(proj_mat.as_matrix() * viewmodel_mat).as_ref() };
       window.encoder.update_constant_buffer(&self.trans, &trans);
     }
     // draw monitor window
@@ -117,10 +121,11 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
     if let (&mut Some(ref mut vr),
             &Some(ref left),
             &Some(ref right)) = (vr, &self.left, &self.right) {
-      vr.submit(vr::Eye::Left, &left.tex);
+      vr.submit(vr::Eye::Left, &left.tex)?;
-      vr.submit(vr::Eye::Right, &right.tex);
+      vr.submit(vr::Eye::Right, &right.tex)?;
     }
     window.window.swap_buffers();
     window.device.cleanup();
+    Ok(())
   }
 }

src/vr.rs

@@ -1,60 +1,84 @@
 extern crate gfx_device_gl;
 extern crate openvr as vr;
-extern crate openvr_sys;
 
-pub use self::vr::Eye;
+use std::fmt::Debug;
-pub use self::vr::common::Size;
+
-pub use self::openvr_sys::VRControllerState_t;
+pub use self::vr::{compositor::texture::{ColorSpace, Handle, Texture},
+                   ControllerState,
+                   Eye,
+                   system::Event as OvrEvent};
 
 use gfx::{self, texture, Factory};
 use gfx::memory::Typed;
-use na::{self, Inverse};
+use na;
-use num_traits::identities::Zero;
-use num_traits::identities::One;
 
 use self::gfx_device_gl::Resources as GLResources;
-use self::openvr_sys::{VREvent_Controller_t, VREvent_t};
 
 pub struct VR {
-  system: vr::IVRSystem,
+  _context: vr::Context,
-  compositor: vr::IVRCompositor,
+  system: vr::System,
+  compositor: vr::Compositor,
+  origin: vr::TrackingUniverseOrigin,
   gfx_handles: gfx::handle::Manager<GLResources>,
 }
 
 #[derive(Debug)]
 pub enum Event {
-  Touch { dev_idx: u32, controller: VREvent_Controller_t },
+  Touch { dev_idx: u32, button: u32 },
-  Press { dev_idx: u32, controller: VREvent_Controller_t },
+  Press { dev_idx: u32, button: u32 },
-  Unpress { dev_idx: u32, controller: VREvent_Controller_t },
+  Unpress { dev_idx: u32, button: u32 },
-  Untouch { dev_idx: u32, controller: VREvent_Controller_t },
+  Untouch { dev_idx: u32, button: u32 },
-  Other(VREvent_t),
+  Other { dev_idx: u32, event: OvrEvent },
+}
+
+pub use self::vr::button_id;
+
+#[derive(Debug)]
+pub enum Error {
+  Init(Box<Debug>),
+  Poses(Box<Debug>),
+  Submit(Box<Debug>)
+}
+
+impl From<vr::InitError> for Error {
+  fn from(e: vr::InitError) -> Self {
+    Error::Init(Box::new(e))
+  }
 }
 
 impl VR {
-  pub fn new() -> Result<VR, vr::Error<openvr_sys::EVRInitError>> {
+  pub fn new() -> Result<VR, vr::InitError> {
+    let context = unsafe { vr::init(vr::ApplicationType::Scene)? };
     Ok(VR {
-      system: vr::init()?,
+      system: context.system()?,
-      compositor: vr::compositor()?,
+      compositor: context.compositor()?,
+      _context: context,
+      origin: vr::TrackingUniverseOrigin::Standing,
       gfx_handles: gfx::handle::Manager::new(),
     })
   }
 
-  pub fn poses(&mut self) -> vr::tracking::TrackedDevicePoses {
+  pub fn poses(&mut self) -> Result<vr::TrackedDevicePoses, Error> {
     self.gfx_handles.clear();
-    self.compositor.wait_get_poses()
+    self.compositor.wait_get_poses().map(|p| p.render).map_err(|e| Error::Poses(Box::new(e)))
   }
 
-  pub fn submit<T>(&mut self, eye: Eye, tex: &gfx::handle::Texture<GLResources, T>) {
+  pub fn submit<T>(&mut self, eye: Eye, tex: &gfx::handle::Texture<GLResources, T>)
+                   -> Result<(), Error> {
     let tex_id = match self.gfx_handles.ref_texture(tex.raw()) {
       &gfx_device_gl::NewTexture::Surface(id) => id,
       _ => panic!("Not a surface")
     };
-    self.compositor.submit(eye,
+    unsafe {
-                           tex_id as usize,
+      self.compositor.submit(eye,
-                           vr::common::TextureBounds::new((0.0, 1.0), (0.0, 1.0)));
+                             &Texture { handle: Handle::OpenGLRenderBuffer(tex_id as usize),
+                                        color_space: ColorSpace::Linear },
+                             None,
+                             None).map_err(|e| Error::Submit(Box::new(e)))
+    }
   }
 
-  pub fn recommended_render_target_size(&self) -> Size {
+  pub fn recommended_render_target_size(&self) -> (u32, u32) {
     self.system.recommended_render_target_size()
   }
 
@@ -64,74 +88,52 @@ impl VR {
 
   pub fn head_to_eye_transform(self: &Self, eye: Eye) -> na::Matrix4<f32> {
     let mut mat = self.system.eye_to_head_transform(eye).as_matrix4();
-    assert!(mat.inverse_mut(), "inverse eye matrix");
+    let inv_worked = mat.try_inverse_mut();
+    assert!(inv_worked, "head_to_eye matrix invert");
     mat
   }
 
   pub fn poll_next_event(&mut self) -> Option<Event> {
-    use self::openvr_sys::EVREventType as EvType;
+    let (event, _) = self.system.poll_next_event_with_pose(self.origin)?;
-    unsafe {
-      let system = * { self.system.0 as *mut openvr_sys::VR_IVRSystem_FnTable };
-      let mut event: openvr_sys::VREvent_t = ::std::mem::zeroed();
 
-      if system.PollNextEvent.unwrap()(&mut event,
+    let dev_idx = event.tracked_device_index as u32;
-                                       ::std::mem::size_of::<openvr_sys::VREvent_t>() as u32
+    Some(match event.event {
-      ) == 0 {
+      OvrEvent::ButtonTouch(controller) => Event::Touch { dev_idx: dev_idx,
-        return None;
+                                                          button: controller.button },
-      }
+      OvrEvent::ButtonPress(controller) => Event::Press { dev_idx: dev_idx,
-
+                                                          button: controller.button },
-      let dev_idx = event.trackedDeviceIndex;
+      OvrEvent::ButtonUnpress(controller) => Event::Unpress { dev_idx: dev_idx,
-      Some(match ::std::mem::transmute(event.eventType) {
+                                                              button: controller.button },
-        EvType::EVREventType_VREvent_ButtonTouch =>
+      OvrEvent::ButtonUntouch(controller) => Event::Untouch { dev_idx: dev_idx,
-          Event::Touch { dev_idx: dev_idx as u32, controller: *event.data.controller() },
+                                                              button: controller.button },
-        EvType::EVREventType_VREvent_ButtonPress =>
+      _ => Event::Other { dev_idx: dev_idx, event: event.event },
-          Event::Press { dev_idx: dev_idx as u32, controller: *event.data.controller() },
+    })
-        EvType::EVREventType_VREvent_ButtonUnpress =>
-          Event::Unpress { dev_idx: dev_idx as u32, controller: *event.data.controller() },
-        EvType::EVREventType_VREvent_ButtonUntouch =>
-          Event::Untouch { dev_idx: dev_idx as u32, controller: *event.data.controller() },
-        _ => Event::Other(event),
-      })
-    }
   }
 
-  pub fn get_controller_state(&self, index: u32) -> Option<openvr_sys::VRControllerState_t> {
+  pub fn get_controller_state(&self, index: u32) -> Option<ControllerState> {
-    unsafe {
+    self.system.controller_state(index)
-      let system = * { self.system.0 as *const openvr_sys::VR_IVRSystem_FnTable };
-      let mut state: openvr_sys::VRControllerState_t = ::std::mem::zeroed();
-
-      match system.GetControllerState.unwrap()(
-          index,
-          &mut state,
-      ) {
-        0 => None,
-        _ => Some(state)
-      }
-    }
   }
 }
 
-impl Drop for VR {
+pub trait AsMatrix4<N: na::Real> {
-  fn drop(&mut self) {
-    vr::shutdown()
-  }
-}
-
-pub trait AsMatrix4<N> {
   fn as_matrix4(self) -> na::Matrix4<N>;
 }
-impl<N: Copy + Zero + One> AsMatrix4<N> for [[N; 4]; 3] {
+impl<N: na::Real> AsMatrix4<N> for [[N; 4]; 3] {
   #[inline]
   fn as_matrix4(self) -> na::Matrix4<N> {
+
     na::Matrix4::new(self[0][0], self[0][1], self[0][2], self[0][3],
                      self[1][0], self[1][1], self[1][2], self[1][3],
                      self[2][0], self[2][1], self[2][2], self[2][3],
                      N::zero(),  N::zero(),  N::zero(),  N::one())
   }
 }
-impl<N: Copy> AsMatrix4<N> for [[N; 4]; 4] {
+
+
+impl<N: na::Real> AsMatrix4<N> for [[N; 4]; 4] {
   #[inline]
   fn as_matrix4(self) -> na::Matrix4<N> {
+
     na::Matrix4::new(self[0][0], self[0][1], self[0][2], self[0][3],
                      self[1][0], self[1][1], self[1][2], self[1][3],
                      self[2][0], self[2][1], self[2][2], self[2][3],
@@ -139,6 +141,7 @@ impl<N: Copy> AsMatrix4<N> for [[N; 4]; 4] {
   }
 }
 
+
 pub struct EyeBuffer<T, D>
   where T: gfx::format::RenderFormat + gfx::format::TextureFormat,
         D: gfx::format::DepthFormat + gfx::format::TextureFormat {
@@ -149,20 +152,21 @@ pub struct EyeBuffer<T, D>
 }
 
 pub fn create_eyebuffer<T, D>(factory: &mut gfx_device_gl::Factory,
-                              size: Size)
+                              width: u32,
+                              height: u32)
                               -> Result<EyeBuffer<T, D>, gfx::CombinedError>
   where T: gfx::format::RenderFormat + gfx::format::TextureFormat,
         D: gfx::format::DepthFormat + gfx::format::TextureFormat {
   let tex = factory
-      .create_texture(texture::Kind::D2(size.width as texture::Size,
+      .create_texture(texture::Kind::D2(width as texture::Size,
-                                        size.height as texture::Size,
+                                        height as texture::Size,
                                         texture::AaMode::Single),
                       1, // levels
-                      gfx::RENDER_TARGET, // bind
+                      gfx::memory::Bind::RENDER_TARGET, // bind
-                      gfx::memory::Usage::GpuOnly, // Usage
+                      gfx::memory::Usage::Data, // Usage
                       Some(<T::Channel as gfx::format::ChannelTyped>::get_channel_type()))?; // hint: format::ChannelType?
   let tgt = factory.view_texture_as_render_target(&tex, 0, None)?;
-  let depth = factory.create_depth_stencil_view_only(size.width as texture::Size,
+  let depth = factory.create_depth_stencil_view_only(width as texture::Size,
-                                                     size.height as texture::Size)?;
+                                                     height as texture::Size)?;
   Ok(EyeBuffer { tex: tex, target: tgt, depth: depth })
 }

src/world.rs

@@ -1,7 +1,3 @@
-extern crate itertools;
-
-use self::itertools::Itertools;
-
 use tile::Tile;
 use transpose::TransposableIterator;