NO_VR env var for monitor only mode

src/bin/vrtue.rs

@@ -8,15 +8,20 @@ extern crate gfx_device_gl;
 extern crate piston_window;
 
 use self::piston_window::{PistonWindow, Window, WindowSettings};
+use std::env;
 
 pub fn main() {
   env_logger::init().expect("env logger");
-  let mut vr = vr::VR::new().expect("VR init");
+  let mut vr = if env::var("NO_VR").is_ok() {
+    None
+  } else {
+    Some(vr::VR::new().expect("VR init"))
+  };
 
   let mut window: PistonWindow =
     WindowSettings::new("Hello, Britannia!", [1024; 2])
         .exit_on_esc(true)
-        .vsync(false)
+        .vsync(vr.is_none())  // Let VR throttle framerate, if available
         .build().expect("Building Window");
 
   let mut aux_command = window.factory.create_command_buffer();
@@ -44,7 +49,7 @@ pub fn main() {
     }
 
     // handle VR events
-    while let Some(ev) = vr.poll_next_event() {
+    while let Some(ev) = vr.as_mut().and_then(|vr| vr.poll_next_event()) {
       scene.event(Event::Vr(ev));
     }
   }

src/scene.rs

@@ -10,7 +10,7 @@ pub trait Scene<D: gfx::Device,
                 F: gfx::Factory<D::Resources>> {
   fn event(&mut self, event: Event);
   fn update(&mut self,
-            vr: &mut vr::VR,
+            vr: &mut Option<vr::VR>,  // TODO: abstract this out
             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>);
   fn render(&self,
             factory: &mut F,

src/scenes/world.rs

@@ -201,7 +201,7 @@ impl<D: gfx::Device,
   }
 
   fn update(&mut self,
-            vr: &mut vr::VR,
+            vr: &mut Option<vr::VR>,
             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) {
     const NANOS_PER_MILLI: u32 = 1_000_000;
     const MILLIS_PER_SEC: u64 = 1_000;
@@ -210,7 +210,7 @@ impl<D: gfx::Device,
 
     for (pad, track) in self.pads.iter_mut() {
       let mode = track.0;
-      if let Some(state) = vr.get_controller_state(*pad) {
+      if let Some(state) = vr.as_ref().and_then(|vr| vr.get_controller_state(*pad)) {
         if let Some(old_state) = track.1 {
           match mode {
             TrackMode::Touch => {

src/view.rs

@@ -9,7 +9,7 @@ extern crate piston_window;
 use gfx;
 use gfx::Device;
 use gfx::traits::FactoryExt;
-use self::na::Inverse;
+use self::na::{Inverse, ToHomogeneous};
 use self::piston_window::{PistonWindow, Window};
 
 pub type ColorFormat = gfx::format::Srgba8;
@@ -29,62 +29,82 @@ pub struct ViewRoot<Dev, T, D>
         T: gfx::format::RenderFormat + gfx::format::TextureFormat,
         D: gfx::format::DepthFormat + gfx::format::TextureFormat {
 
-  left: vr::EyeBuffer<T, D>,
+  left: Option<vr::EyeBuffer<T, D>>,
-  right: vr::EyeBuffer<T, D>,
+  right: Option<vr::EyeBuffer<T, D>>,
   trans: gfx::handle::Buffer<Dev::Resources, Trans>,
 }
 
 impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
-  pub fn create_view(window: &mut PistonWindow, vr: &VR)
+  pub fn create_view(window: &mut PistonWindow, vr: &Option<VR>)
                      -> 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.recommended_render_target_size();
+      let render_size = vr::Size { width: render_size.width * 220 / 100,
+                                   height: render_size.height * 220 / 100 };
 
-    let render_size = vr::Size { width: render_size.width * 220 / 100,
+      let left = vr::create_eyebuffer(&mut window.factory, render_size)
-                                 height: render_size.height * 220 / 100 };
+          .expect("create left renderbuffer");
+      let right = vr::create_eyebuffer(&mut window.factory, render_size)
+          .expect("create right renderbuffer");
+      let trans = window.factory.create_constant_buffer(1);
 
-    let left = vr::create_eyebuffer(&mut window.factory, render_size)
+      window.window.swap_buffers(); // To contain setup calls to Frame 0 in apitrace
-        .expect("create left renderbuffer");
-    let right = vr::create_eyebuffer(&mut window.factory, render_size)
-        .expect("create right renderbuffer");
-    let trans = window.factory.create_constant_buffer(1);
 
-    window.window.swap_buffers(); // To contain setup calls to Frame 0 in apitrace
+      ViewRoot::<gfx_device_gl::Device, ColorFormat, DepthFormat> {
-
+        left: Some(left),
-    ViewRoot::<gfx_device_gl::Device, ColorFormat, DepthFormat> {
+        right: Some(right),
-      left: left,
+        trans: trans,
-      right: right,
+      }
-      trans: trans.clone(),
+    } else {
+      let trans = window.factory.create_constant_buffer(1);
+      ViewRoot::<gfx_device_gl::Device, ColorFormat, DepthFormat> {
+        left: None,
+        right: None,
+        trans: trans,
+      }
     }
   }
 
   pub fn draw(&self,
               window: &mut PistonWindow,
-              vr: &mut vr::VR,
+              vr: &mut Option<vr::VR>,
               scene: &::scene::Scene<gfx_device_gl::Device, gfx_device_gl::Factory>) {
-    // Get the current sensor state
+    if let &mut Some(ref mut vr) = vr {
-    let poses = vr.poses();
+      // Get the current sensor state
+      let poses = vr.poses();
 
-    let mut hmd_mat = poses.poses[0].to_device.as_matrix4();
+      let mut hmd_mat = poses.poses[0].to_device.as_matrix4();
-    hmd_mat.inverse_mut();
+      hmd_mat.inverse_mut();
 
-    for &(eye, buffers) in [(vr::Eye::Left, &self.left),
+      for &(eye, buffers) in [(vr::Eye::Left, &self.left),
-                            (vr::Eye::Right, &self.right)].into_iter() {
+                              (vr::Eye::Right, &self.right)].into_iter() {
-      window.encoder.clear(&buffers.target, [0.005, 0.005, 0.01, 1.0]);
+        let target = &buffers.as_ref().expect("vr color buffer").target;
+        let depth = &buffers.as_ref().expect("vr depth buffer").depth;
+        window.encoder.clear(target, [0.005, 0.005, 0.01, 1.0]);
+        window.encoder.clear_depth(depth, 1.0);
 
-      window.encoder.clear_depth(&buffers.depth, 1.0);
+        let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
+        let eye_mat = vr.head_to_eye_transform(eye);
+        let scene_mat = scene.origin();
+        let trans = Trans { matrix: *(proj_mat * eye_mat * hmd_mat * scene_mat).as_ref() };
+        window.encoder.update_constant_buffer(&self.trans, &trans);
 
-      let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
+        scene.render(&mut window.factory,
-      let eye_mat = vr.head_to_eye_transform(eye);
+                     &mut window.encoder,
+                     &self.trans,
+                     &target,
+                     &depth);
+      }
+    } else {
+      // If running without VR, just draw from some default projection near the scene origin
+      let head_mat = na::Similarity3::new(na::Vector3::new(0.0, -1.0, 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 scene_mat = scene.origin();
-      let trans = Trans { matrix: *(proj_mat * eye_mat * hmd_mat * scene_mat).as_ref() };
+      let trans = Trans { matrix: *(proj_mat * head_mat * scene_mat).as_ref() };
       window.encoder.update_constant_buffer(&self.trans, &trans);
-
-      scene.render(&mut window.factory,
-                   &mut window.encoder,
-                   &self.trans,
-                   &buffers.target,
-                   &buffers.depth);
     }
     // draw monitor window
     window.encoder.clear(&window.output_color, [0.005, 0.005, 0.01, 1.0]);
@@ -96,8 +116,12 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
                  &window.output_stencil);
 
     window.encoder.flush(&mut window.device);
-    vr.submit(vr::Eye::Left, &self.left.tex);
+    if let (&mut Some(ref mut vr),
-    vr.submit(vr::Eye::Right, &self.right.tex);
+            &Some(ref left),
+            &Some(ref right)) = (vr, &self.left, &self.right) {
+      vr.submit(vr::Eye::Left, &left.tex);
+      vr.submit(vr::Eye::Right, &right.tex);
+    }
     window.window.swap_buffers();
     window.device.cleanup();
   }