use image crate for tiles instead of custom type

src/arena.rs

@@ -11,10 +11,10 @@ use tile::Tile;
 // 0x40   121  11x11 map matrix
 // 0xB9   7    ???
 pub struct Arena {
-  _monster_x: [u8; 16],
-  _monster_y: [u8; 16],
-  _party_x: [u8; 8],
-  _party_y: [u8; 8],
+  monster_x: [u8; 16],
+  monster_y: [u8; 16],
+  party_x: [u8; 8],
+  party_y: [u8; 8],
   _unknown1: [u8; 16],
   map: Field,
   _unknown2: [u8; 7],

src/bin/tileview.rs

@@ -22,11 +22,9 @@ fn main() {
   let mut ega_vec = Vec::<u8>::new();
 
   file.read_to_end(&mut ega_vec).expect("Read EGA file");
-  let ega_page = ega::decode(&ega_vec, Compression::Uncompressed, Tiling::Tiled(16));
-  for (i, tilepixels) in ega_page.iter().enumerate() {
+  let tiles = ega::decode(&ega_vec, Compression::UNCOMPRESSED, Tiling::TILED(16));
+  for (i, tile) in tiles.iter().enumerate() {
     let out_name = format!("out/{}.png", i);
-    let out_file = std::fs::File::create(Path::new(&out_name)).expect("open out file");
-    let enc = image::png::PNGEncoder::new(out_file);
-    enc.encode(&tilepixels, 16, 16, image::ColorType::RGBA(8)).expect("write png");
+    tile.save(out_name).expect("save png");
   }
 }

src/bin/vrtue.rs

@@ -5,33 +5,21 @@ use vrtue::scene::{Event, Scene};
 extern crate env_logger;
 extern crate gfx_device_gl;
 #[macro_use] extern crate log;
-extern crate piston;
 extern crate piston_window;
 
-use self::piston::input::{Button, Input, Key};
 use self::piston_window::{PistonWindow, Window, WindowSettings};
-use std::env;
-
 
 pub fn main() {
   env_logger::init().expect("env logger");
-  let mut vr = if env::var("NO_VR").is_ok() {
-    None
-  } else {
-    Some(vr::VR::new().expect("VR init"))
-  };
+  let mut vr = vr::VR::new().expect("VR init");
 
   let mut window: PistonWindow =
     WindowSettings::new("Hello, Britannia!", [1024; 2])
         .exit_on_esc(true)
-        .vsync(vr.is_none())  // Let VR throttle framerate, if available
+        .vsync(false)
         .build().expect("Building Window");
 
-  let mut aux_command = window.factory.create_command_buffer();
-  let mut scene = scenes::world::WorldScene::new(&mut window.device,
-                                                 &mut window.factory,
-                                                 &mut window.encoder,
-                                                 &mut aux_command);
+  let mut scene = scenes::world::WorldScene::new(&mut window.factory, &mut window.encoder);
   let view = view::ViewRoot::<gfx_device_gl::Device, view::ColorFormat, view::DepthFormat>
                            ::create_view(&mut window, &mut vr);
 
@@ -44,8 +32,7 @@ pub fn main() {
     // handle window events
     while let Some(ev) = window.poll_event() {
       match ev {
-        Input::Press(Button::Keyboard(Key::Space)) |
-        Input::Press(Button::Keyboard(Key::Escape)) => break'main,
+        piston_window::Input::Text(_) => break 'main,
         _ => debug!("\t{:?}", ev)
       }
 
@@ -53,7 +40,7 @@ pub fn main() {
     }
 
     // handle VR events
-    while let Some(ev) = vr.as_mut().and_then(|vr| vr.poll_next_event()) {
+    while let Some(ev) = vr.poll_next_event() {
       scene.event(Event::Vr(ev));
     }
   }

src/ega.rs

@@ -1,3 +1,7 @@
+extern crate image;
+
+use self::image::{ImageBuffer, Rgba};
+
 static EGA_PALETTE: [[u8; 4]; 16] = [[0x00, 0x00, 0x00, 0x00],
                                      [0x00, 0x00, 0xAA, 0x00],
                                      [0x00, 0xAA, 0x00, 0x00],
@@ -16,102 +20,37 @@ static EGA_PALETTE: [[u8; 4]; 16] = [[0x00, 0x00, 0x00, 0x00],
                                      [0xFF, 0xFF, 0xFF, 0x00]];
 
 pub enum Compression {
-  Uncompressed,
-  Rle,
-  Lzw
+  UNCOMPRESSED,
+  RLE,
+  LZW
 }
 
 pub enum Tiling {
-  Untiled,
-  Tiled(u16)
-}
-
-pub struct EgaPage {
-  pub data: Vec<u8>,
-  pub dim: usize,
-}
-
-impl EgaPage {
-  pub fn iter<'a>(&'a self) -> impl Iterator<Item=&'a [u8]> {
-    self.data.chunks(4 * self.dim * self.dim)
-  }
-
-  pub fn mipmap(&self, scale_levels: u8) -> Mipmap {
-    let scale = 1 << scale_levels;
-    let scaled: Vec<Vec<u8>> = self.iter().map(|tile| {
-      let mut tilevec = Vec::new();
-      for row in tile.chunks(4 * self.dim) {
-        for _ in 0..scale {
-          for px in row.chunks(4) {
-            for subpx in px.iter().cycle().take(4 * scale) {
-              tilevec.push(*subpx);
-            }
-          }
-        }
-      }
-      tilevec
-    }).collect();
-
-    // dummy buffers just to provide proper sizing on texture for mips
-    let dim = self.dim << scale_levels;
-    let mut dummies = Vec::new();
-
-    let mut level = 1;
-    loop {
-      let mipdim = dim >> level;
-      if mipdim == 0 { break; }
-      dummies.push(vec![0; 4 * mipdim * mipdim]);
-      level += 1;
-    }
-
-    Mipmap {
-      len: self.data.len() / (4 * self.dim * self.dim),
-      dim: dim,
-      backing: scaled,
-      dummies: dummies,
-    }
-  }
-}
-
-pub struct Mipmap {
-  pub len: usize,
-  pub dim: usize,
-  backing: Vec<Vec<u8>>,
-  dummies: Vec<Vec<u8>>,
-}
-
-impl Mipmap {
-  pub fn slices(&self) -> Vec<&[u8]> {
-    let mut slices: Vec<&[u8]> = Vec::with_capacity((1 + self.dummies.len()) * self.len);
-    for tile in self.backing.iter() {
-      slices.push(tile);
-      for dummy in self.dummies.iter() {
-        slices.push(&dummy);
-      }
-    }
-    slices
-  }
+  UNTILED,
+  TILED(u32)
 }
 
 pub fn decode<'a>(buf: &[u8], compression: Compression, tiling: Tiling)
-                  -> EgaPage {
-  let out: Vec<u8>;
-
-  out = match compression {
-    Compression::Uncompressed => buf.iter()
+                  -> Vec<ImageBuffer<Rgba<u8>, Vec<u8>>> {
+  let (tiledim, iter) = match tiling {
+    Tiling::TILED(tiledim) => (tiledim, buf.chunks((tiledim * tiledim / 2) as usize)),
+    Tiling::UNTILED => (buf.len() as u32, buf.chunks(buf.len()))
+  };
+  match compression {
+    Compression::UNCOMPRESSED =>
+      iter.map(|chunk| {
+        ImageBuffer::from_raw(tiledim,
+                              tiledim,
+                              chunk.into_iter()
                                    .flat_map(|tile_byte| {
                                      EGA_PALETTE[(tile_byte >> 4u8 & 0xF) as usize]
                                       .into_iter()
                                       .chain(EGA_PALETTE[(tile_byte & 0xF) as usize]
                                              .into_iter())
-                                    })
-                                    .map(|x| *x)
-                                    .collect(),
+                                   }).map(|x| *x)
+                                   .collect())
+          .expect("decode ega")
+      }).collect(),
     _ => unimplemented!()
-  };
-  let dim = match tiling {
-    Tiling::Tiled(tiledim) => tiledim as usize,
-    Tiling::Untiled => out.len()
-  };
-  EgaPage { data: out, dim: dim}
+  }
 }

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 Option<vr::VR>,  // TODO: abstract this out
+            vr: &mut vr::VR,
             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>);
   fn render(&self,
             factory: &mut F,

src/scenes/shader/tile_frag.glsl

@@ -10,9 +10,9 @@ uniform b_constants {
   uvec4 anim;
   float R1;
   float R2;
-  float R3;
 };
 uniform b_locals {
+  mat4 camera;
   uint millis;
   float treadmill_x;
   float treadmill_y;

src/scenes/shader/torus_vertex.glsl

@@ -15,9 +15,9 @@ uniform b_constants {
   uvec4 anim;
   float R1;
   float R2;
-  float R3;
 };
 uniform b_locals {
+  mat4 camera;
   uint millis;
   float treadmill_x;
   float treadmill_y;
@@ -35,8 +35,8 @@ void main() {
 
   vec2 thetaphi = vec2(TWO_PI_CIRC * (a_pos.x + treadmill_x),
                        TWO_PI_CIRC * (a_pos.y + treadmill_y));
-  float height = R2 * 4 * TWO_PI_CIRC;
-  vec3 normal = vec3(toroid(thetaphi, 0, height, height)) *
-                vec3(R2 / R3, 1.0, 1.0);
-  gl_Position = u_matrix * vec4(toroid(thetaphi, R1, R2, R3) + a_pos.z * normal, 1.0);
+  float height = R1 * TWO_PI_CIRC;
+  vec3 normal = vec3(toroid(thetaphi, 0, height, height));
+  gl_Position = u_matrix * camera *
+      vec4(toroid(thetaphi, R1, R2, R1) + a_pos.z * normal, 1.0);
 }

src/scenes/world.rs

@@ -9,7 +9,6 @@ extern crate gfx;
 extern crate nalgebra as na;
 extern crate num_traits;
 extern crate openvr_sys;
-extern crate piston;
 extern crate piston_window;
 
 use std::collections::BTreeMap;
@@ -20,14 +19,13 @@ use gfx::tex;
 use gfx::traits::FactoryExt;
 use self::na::ToHomogeneous;
 use self::num_traits::identities::One;
-use self::piston::input::{Button, Input, Key};
 
+//const R1: f32 = 4096.0;
+//const R2: f32 = 1024.0;
+//const R1: f32 = 4.0;
+//const R2: f32 = 1.0;
 const R1: f32 = 256.0;
 const R2: f32 = 64.0;
-const R3: f32 = 128.0;
-const PI: f32 = ::std::f32::consts::PI;
-const TWO_PI: f32 = 2.0 * PI;
-const TWO_PI_CIRC: f32 = TWO_PI / 256.0;
 
 gfx_defines! {
   vertex Vertex {
@@ -40,10 +38,10 @@ gfx_defines! {
     anim: [u32; 4] = "anim",
     r1: f32 = "R1",
     r2: f32 = "R2",
-    r3: f32 = "R3",
   }
 
   constant Locals {
+    camera: [[f32; 4]; 4] = "camera",
     millis: u32 = "millis",
     treadmill_x: f32 = "treadmill_x",
     treadmill_y: f32 = "treadmill_y",
@@ -78,7 +76,8 @@ fn get_model(world: &model::World) -> (Vec<Vertex>, Vec<u32>) {
         10 | 11 | 12 => 1.0,
         _ => 0.0,
       };
-      let (rf, cf) = (r as f32, c as f32);
+      let rf = (((r + 90) % 256) as i16 - 128) as f32;
+      let cf = (((c + 144) % 256) as i16 - 128) as f32;
       if alt == 0.0 {
         verticies.extend_from_slice(
           &[Vertex { pos: [ cf + 0., -rf - 1., 0. ], uv: [0., 0.], tileidx: tileidx },
@@ -113,8 +112,8 @@ fn get_model(world: &model::World) -> (Vec<Vertex>, Vec<u32>) {
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum TrackMode {
-  Touch,
-  Press
+  TOUCH,
+  PRESS
 }
 
 pub struct WorldScene<D: gfx::Device,
@@ -134,15 +133,11 @@ pub struct WorldScene<D: gfx::Device,
   start_time: SystemTime,
   treadmills: (f32, f32),
   pads: BTreeMap<u32, (TrackMode, Option<openvr_sys::VRControllerState_t>)>,
-
-  pos: (u8, u8),
 }
 
 impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
-  pub fn new(device: &mut D,
-             factory: &mut F,
-             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>,
-             aux_command: &mut <D as gfx::Device>::CommandBuffer) -> WorldScene<D, F> {
+  pub fn new(factory: &mut F,
+             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) -> WorldScene<D, F> {
     let (model, model_idx) = get_model(&get_data_model());
     let (vertex_buffer, slice) =
         factory.create_vertex_buffer_with_slice(&model, &model_idx[..]);
@@ -150,8 +145,7 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
     let constants = factory.create_constant_buffer(1);
     encoder.update_constant_buffer(&constants, &Constants { anim: ANIMDATA,
                                                             r1: R1,
-                                                            r2: R2,
-                                                            r3: R3});
+                                                            r2: R2 });
 
     WorldScene {
       pso: factory.create_pipeline_simple(VERTEX_SHADER_SRC,
@@ -161,8 +155,8 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
       camera: na::Matrix4::one(),
       constants: constants,
       locals: factory.create_constant_buffer(1),
-      atlas: tile::get_tiles::<_, _, view::ColorFormat>(device, factory, aux_command),
-      sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Jrd,
+      atlas: tile::get_tiles::<_, _, view::ColorFormat>(factory),
+      sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Scale,
                                                             tex::WrapMode::Tile)),
       f: PhantomData,
 
@@ -171,19 +165,8 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
       start_time: SystemTime::now(),
       treadmills: (0.0, 0.0),
       pads: BTreeMap::new(),
-
-      pos: (90, 144),
     }
   }
-
-  fn toroid((x, y): (u8, u8), r1: f32, r2: f32, r3: f32) -> na::Vector3<f32>
-  {
-    let x: f32 = TWO_PI_CIRC * x as f32;
-    let y: f32 = TWO_PI_CIRC * y as f32;
-    na::Vector3::<f32>::new(r3 * -1.0f32 * x.sin(), // use r3 instead of r2 for "deflated" torus
-                            (r1 + r2 * x.cos()) * y.cos(),
-                            (r1 + r2 * x.cos()) * y.sin())
-  }
 }
 
 const ANIMDATA: [u32; 4] =
@@ -199,40 +182,24 @@ impl<D: gfx::Device,
     use scene::Event::*;
     use vr::Event::*;
     match event {
-      Vr(Touch { dev_idx, .. }) => {
-        self.pads.insert(dev_idx, (TrackMode::Touch, None));
+      Vr(Touch { dev_idx, controller }) => {
+        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
       },
-      Vr(Press { dev_idx, .. }) => {
-        self.pads.insert(dev_idx, (TrackMode::Press, None));
+      Vr(Press { dev_idx, controller }) => {
+        self.pads.insert(dev_idx, (TrackMode::PRESS, None));
       },
-      Vr(Unpress { dev_idx, .. }) => {
-        self.pads.insert(dev_idx, (TrackMode::Touch, None));
+      Vr(Unpress { dev_idx, controller }) => {
+        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
       },
-      Vr(Untouch { dev_idx, .. }) => {
+      Vr(Untouch { dev_idx, controller }) => {
         self.pads.remove(&dev_idx);
       },
-      Piston(Input::Press(Button::Keyboard(Key::Left))) => {
-        self.pos = (self.pos.0.wrapping_sub(1), self.pos.1);
-        println!("x: {}, y: {}", self.pos.0, self.pos.1);
-      },
-      Piston(Input::Press(Button::Keyboard(Key::Right))) => {
-        self.pos = (self.pos.0.wrapping_add(1), self.pos.1);
-        println!("x: {}, y: {}", self.pos.0, self.pos.1);
-      },
-      Piston(Input::Press(Button::Keyboard(Key::Up))) => {
-        self.pos = (self.pos.0, self.pos.1.wrapping_sub(1));
-        println!("x: {}, y: {}", self.pos.0, self.pos.1);
-      },
-      Piston(Input::Press(Button::Keyboard(Key::Down))) => {
-        self.pos = (self.pos.0, self.pos.1.wrapping_add(1));
-        println!("x: {}, y: {}", self.pos.0, self.pos.1);
-      },
       _ => ()
     }
   }
 
   fn update(&mut self,
-            vr: &mut Option<vr::VR>,
+            vr: &mut 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;
@@ -241,10 +208,10 @@ impl<D: gfx::Device,
 
     for (pad, track) in self.pads.iter_mut() {
       let mode = track.0;
-      if let Some(state) = vr.as_ref().and_then(|vr| vr.get_controller_state(*pad)) {
+      if let Some(state) = vr.get_controller_state(*pad) {
         if let Some(old_state) = track.1 {
           match mode {
-            TrackMode::Touch => {
+            TrackMode::TOUCH => {
               const THRESHOLD: f32 = 0.005;
               const SCALE: f32 = 32.0;
               let xdiff = state.rAxis[0].x - old_state.rAxis[0].x;
@@ -252,9 +219,9 @@ impl<D: gfx::Device,
               if xdiff.abs() > THRESHOLD { self.treadmills.0 += SCALE * xdiff; }
               if ydiff.abs() > THRESHOLD { self.treadmills.1 += SCALE * ydiff; }
             },
-            TrackMode::Press => {
+            TrackMode::PRESS => {
               let rot = na::Vector3::new(0.0, 0.0, 0.0);
-              let speed = R2 * 0.005;
+              let speed = R2 * 0.01;
               if state.rAxis[0].x > 0.5 {
                 self.camera = na::Similarity3::new(na::Vector3::new(-speed,  0.0, 0.0),
                                                    rot, 1.0).to_homogeneous() * self.camera;
@@ -279,7 +246,8 @@ impl<D: gfx::Device,
       }
     }
 
-    encoder.update_constant_buffer(&self.locals, &Locals { millis: millis,
+    encoder.update_constant_buffer(&self.locals, &Locals { camera: *(self.camera).as_ref(),
+                                                           millis: millis,
                                                            treadmill_x: self.treadmills.0,
                                                            treadmill_y: self.treadmills.1 });
   }
@@ -304,14 +272,9 @@ impl<D: gfx::Device,
   }
 
   fn origin(&self) -> na::Matrix4<f32> {
-    let (x, y) = (self.pos.0, self.pos.1);
-    let eye = Self::toroid((x, y), R1, R2, R3);
-    let looktgt = Self::toroid((x, y.wrapping_add(1)), R1, R2, R3);
-    let normal = Self::toroid((x, y), 0.0, R2, R2) * na::Vector3::new(R2 / R3, 1.0, 1.0);
-    self.camera * na::Isometry3::look_at_rh(eye.as_point(),
-                                            looktgt.as_point(),
-                                            &normal,
-                                           ).to_homogeneous()
+    na::Similarity3::new(na::Vector3::new(0.0, R1 - R2, 0.0),
+                         na::Vector3::new(0.0, 0.0, 0.0), 1.0).to_homogeneous()
+
   }
 }
 

src/tile.rs

@@ -6,45 +6,29 @@ use ::std;
 use std::io::Read;
 use std::path::Path;
 
-use self::gfx::{CommandBuffer, Typed};
 use self::gfx::tex;
 
-const TILEDIM: u16 = 16;
-
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct Tile {
   pub val: u8,
 }
 
-pub fn get_tiles<D, F, T>(device: &mut D,
-                          factory: &mut F,
-                          command: &mut <D as gfx::Device>::CommandBuffer)
-                          -> gfx::handle::ShaderResourceView<D::Resources, T::View>
-  where D: gfx::Device,
-        F: gfx::Factory<D::Resources>,
+pub fn get_tiles<R, F, T>(factory: &mut F) -> gfx::handle::ShaderResourceView<R, T::View>
+  where R: gfx::Resources,
+        F: gfx::Factory<R>,
         T: gfx::format::TextureFormat {
   let filename = "data/SHAPES.EGA";
   let mut file = std::fs::File::open(Path::new(filename))
     .expect(&format!("failed opening tiles file: {}", filename));
   let mut ega_bytes = Vec::new();
   file.read_to_end(&mut ega_bytes).expect("Read tiles file");
-  let ega_page = ega::decode(&ega_bytes, ega::Compression::Uncompressed, ega::Tiling::Tiled(TILEDIM));
-  let mipmap = ega_page.mipmap(2);
-
-  let tex = factory.create_texture_const_u8::<T>(tex::Kind::D2Array(mipmap.dim as u16,
-                                                                    mipmap.dim as u16,
-                                                                    mipmap.len as u16,
+  let tiles = ega::decode(&ega_bytes, ega::Compression::UNCOMPRESSED, ega::Tiling::TILED(16));
+  let tiles_raw: Vec<&[u8]> = tiles.iter().map(|t| &*t as &[u8]).collect();
+  let tex = factory.create_texture_const_u8::<T>(tex::Kind::D2Array(16, 16, 256,
                                                                     tex::AaMode::Single),
-                                                 &mipmap.slices())
+                                                 &tiles_raw)
                    .expect("create tile texture");
-
-  {
-    let mut manager = gfx::handle::Manager::<D::Resources>::new();
-    let view = manager.ref_srv(tex.1.raw());
-    command.generate_mipmap(*view);
-    device.submit(command);
-  }
   tex.1
 }
 

src/town.rs

@@ -6,23 +6,23 @@ use tile::Tile;
 #[allow(dead_code)]
 #[derive(Clone, Copy, Debug)]
 enum Behavior {
-  Fixed = 0x00,
-  Wander = 0x01,
-  Follow = 0x80,
-  Attack = 0xFF,
+  FIXED = 0x00,
+  WANDER = 0x01,
+  FOLLOW = 0x80,
+  ATTACK = 0xFF,
 }
 
 #[derive(Clone, Copy)]
 pub struct Town {
   map: Chunk,
-  _npc_tile1: [Tile; 32],
-  _npc_x1: [u8; 32],
-  _npc_y1: [u8; 32],
-  _npc_tile2: [Tile; 32],
-  _npc_x2: [u8; 32],
-  _npc_y2: [u8; 32],
-  _npc_behavior: [Behavior; 32],
-  _npc_talk_idx: [u8; 32],
+  npc_tile1: [Tile; 32],
+  npc_x1: [u8; 32],
+  npc_y1: [u8; 32],
+  npc_tile2: [Tile; 32],
+  npc_x2: [u8; 32],
+  npc_y2: [u8; 32],
+  npc_behavior: [Behavior; 32],
+  npc_talk_idx: [u8; 32],
 }
 
 impl HasMap for Town {

src/view.rs

@@ -9,7 +9,7 @@ extern crate piston_window;
 use gfx;
 use gfx::Device;
 use gfx::traits::FactoryExt;
-use self::na::{Inverse, ToHomogeneous};
+use self::na::Inverse;
 use self::piston_window::{PistonWindow, Window};
 
 pub type ColorFormat = gfx::format::Srgba8;
@@ -29,15 +29,15 @@ pub struct ViewRoot<Dev, T, D>
         T: gfx::format::RenderFormat + gfx::format::TextureFormat,
         D: gfx::format::DepthFormat + gfx::format::TextureFormat {
 
-  left: Option<vr::EyeBuffer<T, D>>,
-  right: Option<vr::EyeBuffer<T, D>>,
+  left: vr::EyeBuffer<T, D>,
+  right: 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: &Option<VR>)
+  pub fn create_view(window: &mut PistonWindow, vr: &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::Size { width: render_size.width * 220 / 100,
@@ -52,25 +52,16 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
     window.window.swap_buffers(); // To contain setup calls to Frame 0 in apitrace
 
     ViewRoot::<gfx_device_gl::Device, ColorFormat, DepthFormat> {
-        left: Some(left),
-        right: Some(right),
-        trans: trans,
-      }
-    } else {
-      let trans = window.factory.create_constant_buffer(1);
-      ViewRoot::<gfx_device_gl::Device, ColorFormat, DepthFormat> {
-        left: None,
-        right: None,
-        trans: trans,
-      }
+      left: left,
+      right: right,
+      trans: trans.clone(),
     }
   }
 
   pub fn draw(&self,
               window: &mut PistonWindow,
-              vr: &mut Option<vr::VR>,
+              vr: &mut vr::VR,
               scene: &::scene::Scene<gfx_device_gl::Device, gfx_device_gl::Factory>) {
-    if let &mut Some(ref mut vr) = vr {
     // Get the current sensor state
     let poses = vr.poses();
 
@@ -79,10 +70,9 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
 
     for &(eye, buffers) in [(vr::Eye::Left, &self.left),
                             (vr::Eye::Right, &self.right)].into_iter() {
-        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(&buffers.target, [0.005, 0.005, 0.01, 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);
@@ -93,18 +83,8 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
       scene.render(&mut window.factory,
                    &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.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 scene_mat = scene.origin();
-      let trans = Trans { matrix: *(proj_mat * head_mat * scene_mat).as_ref() };
-      window.encoder.update_constant_buffer(&self.trans, &trans);
+                   &buffers.target,
+                   &buffers.depth);
     }
     // draw monitor window
     window.encoder.clear(&window.output_color, [0.005, 0.005, 0.01, 1.0]);
@@ -116,12 +96,8 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
                  &window.output_stencil);
 
     window.encoder.flush(&mut window.device);
-    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::Right, &right.tex);
-    }
+    vr.submit(vr::Eye::Left, &self.left.tex);
+    vr.submit(vr::Eye::Right, &self.right.tex);
     window.window.swap_buffers();
     window.device.cleanup();
   }