wip

.gitignore

@@ -2,5 +2,6 @@ Cargo.lock
 data/
 openvr/
 openvr32/
+out/
 target/
 *.bat

Cargo.toml

@@ -12,10 +12,18 @@ memmap = "~0.2"
 gl = "*"
 gfx = "*"
 gfx_device_gl = "*"
+image = "*"
+lzw = "*"
+nalgebra = "*"
+num-traits = "*"
 openvr = { git = "https://github.com/rust-openvr/rust-openvr" }
 openvr_sys = "*"
 piston = "*"
 piston_window = "*"
 
-sdl2 = "0.22"
+# for pose-relay
-sdl2_image = "0.22"
+byteorder = "*"
+
+[profile.release]
+lto = true
+panic = "abort"

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_x: [u8; 16],
-  monster_y: [u8; 16],
+  _monster_y: [u8; 16],
-  party_x: [u8; 8],
+  _party_x: [u8; 8],
-  party_y: [u8; 8],
+  _party_y: [u8; 8],
   _unknown1: [u8; 16],
   map: Field,
   _unknown2: [u8; 7],

src/bin/click.rs

@@ -0,0 +1,94 @@
+extern crate vrtue;
+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};
+
+pub type ColorFormat = gfx::format::Srgba8;
+pub type DepthFormat = gfx::format::DepthStencil;
+
+pub fn main() {
+  let mut vr = vr::VR::new().expect("VR init");
+
+  let mut window: PistonWindow =
+    WindowSettings::new("Click Test", [512; 2])
+    .exit_on_esc(true)
+    .vsync(false)
+    .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)
+    .expect("create left renderbuffer");
+  let right: vr::EyeBuffer<ColorFormat, DepthFormat> = vr::create_eyebuffer(&mut window.factory, render_size)
+    .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);
+  window.encoder.clear(&right.target, [0.0, 1.0, 0.0, 1.0]);
+  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();
+  'main: loop {
+    let _poses = vr.poses();
+    vr.submit(vr::Eye::Left, &left.tex);
+    vr.submit(vr::Eye::Right, &right.tex);
+
+    while let Some(ev) = vr.poll_next_event() {
+      match ev {
+        vr::Event::Press { dev_idx, controller } => {
+          println!("Press event on #{}: {:?}", dev_idx, controller);
+        },
+        vr::Event::Unpress { dev_idx, controller } => {
+          println!("Unpress event on #{}: {:?}", dev_idx, controller);
+        },
+        vr::Event::Touch { dev_idx, controller } => {
+          if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
+            pads.insert(dev_idx, None);
+          }
+          println!("Touch event on #{}: {:?}", dev_idx, controller);
+        },
+        vr::Event::Untouch { dev_idx, controller } => {
+          if controller.button == openvr_sys::EVRButtonId_k_EButton_SteamVR_Touchpad as u32 {
+            pads.remove(&dev_idx);
+          }
+          println!("Untouch event on #{}: {:?}", dev_idx, controller);
+        },
+        /*
+        t if t == openvr_sys::EVREventType::EVREventType_VREvent_TouchPadMove as u32 => {
+          let touch;
+          unsafe {
+            touch = *ev.data.touchPadMove();
+          }
+          println!("TouchPadMove event on #{}: {:?}", ev.trackedDeviceIndex, touch);
+        },
+        */
+        _ => ()
+      }
+    }
+
+    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 {
+            continue;
+          }
+        }
+        *old = Some(state);
+        println!("state for {}: {:?}", *pad, state);
+      }
+    }
+
+    // handle window events
+    while let Some(ev) = window.poll_event() {
+      match ev {
+        piston_window::Input::Text(_) => break 'main,
+        _ => debug!("\t{:?}", ev)
+      }
+    }
+  }
+}

src/bin/gl.rs

@@ -1,172 +0,0 @@
-extern crate vrtue;
-use vrtue::*;
-
-extern crate env_logger;
-#[macro_use] extern crate gfx;
-extern crate gl;
-#[macro_use] extern crate log;
-extern crate piston_window;
-
-use gfx::Device;
-use gfx::traits::FactoryExt;
-use piston_window::{PistonWindow, Window, WindowSettings};
-
-pub type ColorFormat = gfx::format::Srgba8;
-//pub type DepthFormat = gfx::format::DepthStencil;
-
-gfx_defines!{
-    vertex Vertex {
-        pos: [f32; 2] = "a_pos",
-        color: [f32; 3] = "a_color",
-    }
-
-    pipeline pipe {
-        vbuf: gfx::VertexBuffer<Vertex> = (),
-        pixcolor: gfx::RenderTarget<ColorFormat> = "pixcolor",
-    }
-}
-
-const TRIANGLE: [Vertex; 3] = [
-    Vertex { pos: [ -0.5, -0.5 ], color: [1.0, 0.0, 0.0] },
-    Vertex { pos: [  0.5, -0.5 ], color: [0.0, 1.0, 0.0] },
-    Vertex { pos: [  0.0,  0.5 ], color: [0.0, 0.0, 1.0] }
-];
-
-fn main() {
-    env_logger::init().expect("env logger");
-    let mut vr = vr::VR::new().expect("VR init");
-    let render_size = vr.recommended_render_target_size();
-
-    let mut window: PistonWindow =
-        WindowSettings::new("Hello Virtual World!", [512; 2])
-            .exit_on_esc(true)
-            .vsync(false)
-            //.vsync(true)
-        .build().expect("Building Window");
-
-    /*
-    let _sysleft = system.projection_matrix(vr::Eye::Left, 0.01, 1000.0);
-    let _eyeleft = system.eye_to_head_transform(vr::Eye::Left);
-    let _sysright = system.projection_matrix(vr::Eye::Right, 0.01, 1000.0);
-    let _eyeright = system.eye_to_head_transform(vr::Eye::Right);
-     */
-    let pso = window.factory.create_pipeline_simple(VERTEX_SHADER_SRC,
-                                                    FRAGMENT_SHADER_SRC,
-                                                    pipe::new())
-        .expect("create pipeline");
-
-    let (tex_left, tgt_left) = vr::create_eyebuffer(&mut window.factory, render_size)
-        .expect("create left renderbuffer");
-    let (tex_right, tgt_right) = vr::create_eyebuffer(&mut window.factory, render_size)
-        .expect("create right renderbuffer");
-    let (vertex_buffer, slice) = window.factory.create_vertex_buffer_with_slice(&TRIANGLE, ());
-
-    let pipe_monitor = pipe::Data {
-        vbuf: vertex_buffer.clone(),
-        pixcolor: window.output_color.clone(),
-    };
-    let pipe_left = pipe::Data {
-        vbuf: vertex_buffer.clone(),
-        pixcolor: tgt_left,
-    };
-    let pipe_right = pipe::Data {
-        vbuf: vertex_buffer.clone(),
-        pixcolor: tgt_right,
-    };
-
-    let mut frame = 0;
-    window.window.swap_buffers(); frame += 1; // To contain setup calls to Frame 0 in apitrace
-    'main:
-    //while let Some(_) = window.next() {
-    loop {
-        info!("Frame #{}", frame);
-        let _now = std::time::SystemTime::now();
-
-        // Get the current sensor state
-        let _poses = vr.poses();
-        trace!("\t{:?} got pose", _now.elapsed());
-        if frame % 90 == 0 {
-            warn!("\t#{}: poses: {:?}\n", frame, _poses.poses[0]);
-        }
-        frame += 1;
-
-        for pass in [(Some((vr::Eye::Left, &tex_left)),   &pipe_left),
-                     (Some((vr::Eye::Right, &tex_right)), &pipe_right),
-                     (None,                               &pipe_monitor),]
-            .into_iter() {
-                info!("\tpass for eye: {:?}", pass.0);
-                window.encoder.clear(&pass.1.pixcolor, [0.1, 0.5, 0.1, 1.0]);
-                window.encoder.draw(&slice, &pso, pass.1);
-                window.encoder.flush(&mut window.device);
-
-                // Submit eye textures
-                if let Some((eye, tex)) = pass.0 {
-                    vr.submit(eye, tex);
-                    trace!("\t\t{:?} submit {:?}", _now.elapsed(), eye);
-                } else {
-                    window.window.swap_buffers();
-                }
-            }
-        window.device.cleanup();
-
-        // handle window events
-        while let Some(ev) = window.poll_event() {
-            match ev {
-                piston_window::Input::Text(_) => break 'main,
-                _ => debug!("\t{:?}", ev)
-            }
-        }
-    }
-
-    info!("shutting down");
-}
-
-/*
-fn gl_debug(device: &mut gfx_device_gl::Device, msg: &'static [u8; 6]) {
-    unsafe {
-        device.with_gl_naked(|gl| {
-            gl.DebugMessageInsert(gl::DEBUG_SOURCE_APPLICATION,
-                                  gl::DEBUG_TYPE_OTHER,
-                                  0,
-                                  gl::DEBUG_SEVERITY_LOW,
-                                  msg.len() as i32,
-                                  ::std::mem::transmute(msg));
-        });
-    }
-}
-
-fn check_err(device: &mut gfx_device_gl::Device) {
-    unsafe {
-        device.with_gl_naked(|gl| {
-            let err: gl::types::GLenum = gl.GetError();
-            if err != gl::NO_ERROR {
-                panic!("GL Error! {:?}", err);
-            }
-        });
-    }
-}
-*/
-
-const VERTEX_SHADER_SRC: &'static [u8] = br#"
-    #version 140
-
-    in vec2 a_pos;
-    in vec3 a_color;
-    out vec3 v_color;
-
-    void main() {
-        v_color = a_color;
-        gl_Position = vec4(a_pos, 0.0, 1.0);
-    }
-"#;
-
-const FRAGMENT_SHADER_SRC: &'static [u8] = br#"
-    #version 140
-
-    in vec3 v_color;
-    out vec4 pixcolor;
-
-    void main() {
-        pixcolor = vec4(v_color, 1.0);
-    }
-"#;

src/bin/printmap.rs

@@ -1,3 +1,6 @@
+extern crate vrtue;
+use vrtue::{arena, tile, town, world};
+
 extern crate itertools;
 extern crate memmap;
 
@@ -7,11 +10,6 @@ use std::env;
 use itertools::Itertools;
 use memmap::{Mmap, Protection};
 
-mod arena;
-mod tile;
-mod town;
-mod transpose;
-mod world;
 
 fn mmap_to_rows<'a, M: world::HasMap>(mmap: &memmap::Mmap) -> &'a world::HasMap
   where M: Copy + 'a

src/bin/tileview.rs

@@ -1,36 +1,14 @@
-extern crate itertools;
+extern crate vrtue;
-extern crate sdl2;
+use vrtue::ega;
-extern crate sdl2_image;
+use vrtue::ega::{Compression, Tiling};
+
+extern crate image;
 
 use std::env;
 use std::io::Read;
 use std::path::Path;
 
-use itertools::Itertools;
+fn main() {
-use sdl2::surface::Surface;
-use sdl2::pixels::PixelFormatEnum;
-use sdl2_image::SaveSurface;
-
-static EGA_PALETTE: [[u8; 4]; 16] = [[0x00u8, 0x00, 0x00, 0x00],
-                                     [0x00, 0xAA, 0x00, 0x00],
-                                     [0x00, 0x00, 0xAA, 0x00],
-                                     [0x00, 0xAA, 0xAA, 0x00],
-                                     [0x00, 0x00, 0x00, 0xAA],
-                                     [0x00, 0xAA, 0x00, 0xAA],
-                                     [0x00, 0x00, 0x55, 0xAA],
-                                     [0x00, 0xAA, 0xAA, 0xAA],
-                                     [0x00, 0x55, 0x55, 0x55],
-                                     [0x00, 0xFF, 0x55, 0x55],
-                                     [0x00, 0x55, 0xFF, 0x55],
-                                     [0x00, 0xFF, 0xFF, 0x55],
-                                     [0x00, 0x55, 0x55, 0xFF],
-                                     [0x00, 0xFF, 0x55, 0xFF],
-                                     [0x00, 0x55, 0xFF, 0xFF],
-                                     [0x00, 0xFF, 0xFF, 0xFF]];
-
-
-
-pub fn main() {
   let args: Vec<String> = env::args().collect();
   let filename;
   if args.len() > 1 {
@@ -39,28 +17,16 @@ pub fn main() {
     filename = "data/SHAPES.EGA";
   }
 
-  let _sdl_context = ::sdl2::init().unwrap();
+  let mut file = std::fs::File::open(Path::new(filename))
-  let _image_context = ::sdl2_image::init(::sdl2_image::INIT_PNG).unwrap();
+    .expect(&format!("failed opening EGA file: {}", filename));
+  let mut ega_vec = Vec::<u8>::new();
 
-  let mut file = std::fs::File::open(Path::new(filename)).unwrap();
+  file.read_to_end(&mut ega_vec).expect("Read EGA file");
-  let mut tile_buf = [0u8; 128];
+  let ega_page = ega::decode(&ega_vec, Compression::Uncompressed, Tiling::Tiled(16));
-  let mut surface = Surface::new(16, 16, PixelFormatEnum::RGBX8888).unwrap();
+  for (i, tilepixels) in ega_page.iter().enumerate() {
-  let mut i = 0;
-  while file.read_exact(&mut tile_buf).is_ok() {
-    surface.with_lock_mut(|pixel_bytes| {
-      pixel_bytes.iter_mut().set_from(tile_buf.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));
-
-
-    });
     let out_name = format!("out/{}.png", i);
-    surface.save(Path::new(&out_name)).ok();
+    let out_file = std::fs::File::create(Path::new(&out_name)).expect("open out file");
-    i += 1;
+    let enc = image::png::PNGEncoder::new(out_file);
+    enc.encode(&tilepixels, 16, 16, image::ColorType::RGBA(8)).expect("write png");
   }
 }

src/bin/vrtue.rs

@@ -0,0 +1,62 @@
+extern crate vrtue;
+use vrtue::{context, scenes, view, vr};
+use vrtue::engine::{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 = match env::var("NO_VR") {
+    Ok(ref no_vr) if no_vr != "0" => None,
+    _                             => Some(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
+        .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 aux_command);
+  let view = view::ViewRoot::<gfx_device_gl::Device, view::ColorFormat, view::DepthFormat>
+                           ::create_view(&mut window, &mut vr);
+
+  let mut game = context::VrtueRootContext::new(&mut window.device,
+                                                &mut window.factory,
+                                                &mut aux_command);
+  'main:
+  //while let Some(_) = window.next() {
+  loop {
+    scene.update(&mut game, &mut vr, &mut window.encoder);
+    view.draw(&mut game, &mut window, &mut vr, &scene);
+
+    // 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,
+        _ => debug!("\t{:?}", ev)
+      }
+
+      scene.event(Event::Piston(ev));
+    }
+
+    // handle VR events
+    while let Some(ev) = vr.as_mut().and_then(|vr| vr.poll_next_event()) {
+      scene.event(Event::Vr(ev));
+    }
+  }
+
+  debug!("shutting down");
+}

src/context.rs

@@ -0,0 +1,77 @@
+use ega;
+use engine;
+
+use std::io::Read;
+use std::marker::PhantomData;
+use std::path::Path;
+
+use gfx::{self, CommandBuffer};
+use gfx::memory::Typed;
+use gfx::texture;
+
+const TILEDIM: u16 = 16;
+
+pub struct VrtueRootContext<D, F, T>
+  where D: gfx::Device,
+        F: gfx::Factory<D::Resources>,
+        T: gfx::format::TextureFormat {
+
+  tiles: gfx::handle::ShaderResourceView<D::Resources, T::View>,
+  _factory: PhantomData<F>
+}
+
+impl<D, F, T> engine::GameContext for VrtueRootContext<D, F, T>
+  where D: gfx::Device,
+        F: gfx::Factory<D::Resources>,
+        T: gfx::format::TextureFormat {}
+
+impl<D, F, T> VrtueRootContext<D, F, T>
+  where D: gfx::Device,
+        F: gfx::Factory<D::Resources>,
+        T: gfx::format::TextureFormat,
+        T::View: Clone {
+
+  pub fn new(device: &mut D,
+             factory: &mut F,
+             command: &mut <D as gfx::Device>::CommandBuffer) -> VrtueRootContext<D, F, T> {
+    VrtueRootContext {
+      tiles: Self::make_tiles(device, factory, command),
+      _factory: PhantomData
+    }
+  }
+
+  pub fn tiles(&self) -> gfx::handle::ShaderResourceView<D::Resources, T::View> {
+    self.tiles.clone()
+  }
+
+  fn make_tiles(device: &mut D,
+                factory: &mut F,
+                command: &mut <D as gfx::Device>::CommandBuffer)
+                -> gfx::handle::ShaderResourceView<D::Resources, T::View> {
+    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_immutable_u8::<T>(texture::Kind::D2Array(mipmap.dim as u16,
+                                                                              mipmap.dim as u16,
+                                                                              mipmap.len as u16,
+                                                                              texture::AaMode::Single),
+                                                       &mipmap.slices())
+                     .expect("create tile texture");
+
+    {
+      let mut manager = gfx::handle::Manager::<D::Resources>::new();
+    // XXX: Find out if Textures need to be/can be fenced like Buffers,
+    //      Seems like I should mark tex.1 as being read/written, but it's not a Buffer?
+    let access = gfx::pso::AccessInfo::new();
+      let view = manager.ref_srv(tex.1.raw());
+      command.generate_mipmap(*view);
+      device.submit(command, &access);
+    }
+    tex.1
+  }
+}

src/ega.rs

@@ -0,0 +1,260 @@
+extern crate lzw;
+
+use std::cell::RefCell;
+
+use self::lzw::BitReader;
+
+static EGA_PALETTE: [[u8; 4]; 16] = [[0x00, 0x00, 0x00, 0xFF],
+                                     [0x00, 0x00, 0xAA, 0xFF],
+                                     [0x00, 0xAA, 0x00, 0xFF],
+                                     [0x00, 0xAA, 0xAA, 0xFF],
+                                     [0xAA, 0x00, 0x00, 0xFF],
+                                     [0xAA, 0x00, 0xAA, 0xFF],
+                                     [0xAA, 0x55, 0x00, 0xFF],
+                                     [0xAA, 0xAA, 0xAA, 0xFF],
+                                     [0x55, 0x55, 0x55, 0xFF],
+                                     [0x55, 0x55, 0xFF, 0xFF],
+                                     [0x55, 0xFF, 0x55, 0xFF],
+                                     [0x55, 0xFF, 0xFF, 0xFF],
+                                     [0xFF, 0x55, 0x55, 0xFF],
+                                     [0xFF, 0x55, 0xFF, 0xFF],
+                                     [0xFF, 0xFF, 0x55, 0xFF],
+                                     [0xFF, 0xFF, 0xFF, 0xFF]];
+
+pub enum Compression {
+  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
+  }
+}
+
+pub fn decode<'a>(buf: &[u8], compression: Compression, tiling: Tiling)
+                  -> EgaPage {
+  let out: Vec<u8>;
+
+  out = match compression {
+    Compression::Uncompressed => decode_uncompressed(buf),
+    Compression::Rle => {
+      decode_uncompressed(&decode_rle(buf))
+    },
+    Compression::Lzw => {
+      let mut decoder = U4Lzw::new();
+      decode_uncompressed(&decoder.decode(buf))
+    },
+  };
+  let dim = match tiling {
+    Tiling::Tiled(tiledim) => tiledim as usize,
+    Tiling::Untiled => out.len()
+  };
+  EgaPage { data: out, dim: dim}
+}
+
+fn decode_uncompressed(buf: &[u8]) -> Vec<u8> {
+  buf.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()
+}
+
+fn decode_rle(bytes: &[u8]) -> Vec<u8> {
+  let mut out = Vec::new();
+  let mut iter = bytes.iter();
+
+  while let Some(cmd) = iter.next() {
+    match cmd {
+      &0x02 => {
+        let len = *iter.next().expect("rle missing run length") as usize;
+        out.extend(::std::iter::repeat(*iter.next().expect("rle missing run value")).take(len));
+      },
+      val => out.push(*val),
+    }
+  }
+  out
+}
+
+struct U4Lzw {
+  table: Vec<RefCell<Vec<u8>>>,
+  load: u16,
+}
+
+const U4_CODE_SIZE: u8 = 12;
+impl U4Lzw {
+  fn new() -> U4Lzw {
+    let mut out = U4Lzw {
+      table: vec![RefCell::new(Vec::new()); 1 << U4_CODE_SIZE],
+      load: 0
+    };
+    for (i, entry) in out.table.iter_mut().take(256).enumerate() {
+      entry.borrow_mut().push(i as u8)
+    }
+    out
+  }
+
+  fn reset(&mut self) {
+    for i in 256..(1 << U4_CODE_SIZE) {
+      self.table[i].borrow_mut().clear();
+    }
+    self.load = 0;
+  }
+
+  fn decode(&mut self, bytes: &[u8]) -> Vec<u8> {
+    let mut out = Vec::new();
+    let mut iter = CodeIter::new(bytes);
+
+    let mut prev = iter.next().expect("empty lzw");
+    let mut ch = prev as u8;
+    out.push(ch);
+
+    for code in iter {
+      {
+        let mut new;
+        let mut seq = &*self.table[code as usize].borrow();
+        if seq.is_empty() {
+          new = self.table[prev as usize].borrow().clone();
+          new.push(ch);
+          seq = &new;
+        };
+        out.extend(seq.iter());
+        ch = seq[0];
+      }
+      let hash = self.hash(ch, prev);
+      {
+        let old = self.table[prev as usize].borrow();
+        let mut entry = self.table[hash].borrow_mut();
+        entry.extend(old.iter());
+        entry.push(ch);
+      }
+      prev = code;
+
+      self.load += 1;
+      if self.load > 0xccd { self.reset(); }
+    }
+    out
+  }
+
+  fn hash(&self, root: u8, code: u16) -> usize {
+    let hash = Self::hash_primary(root, code);
+    if self.table[hash].borrow().is_empty() { return hash; }
+
+    let mut hash = Self::hash_secondary(root, code);
+    while !self.table[hash].borrow().is_empty() {
+      hash = (hash + 509) & 0xfff
+    }
+
+    hash
+  }
+
+  fn hash_primary(root: u8, code: u16) -> usize {
+    ((root as (u16) << 4) ^ code) as usize
+  }
+
+  fn hash_secondary(root: u8, code: u16) -> usize {
+    let base = (((root as (u16) << 1) + code) | 0x800) as u32;
+    let squared = base * base;
+    ((squared & 0x0003ffc0) >> 6) as usize
+  }
+}
+
+struct CodeIter<'a> {
+  pos: usize,
+  bytes: &'a [u8],
+  reader: lzw::MsbReader,
+}
+
+impl<'a> CodeIter<'a> {
+  fn new(bytes: &[u8]) -> CodeIter {
+    CodeIter { pos: 0, bytes: bytes, reader: lzw::MsbReader::new() }
+  }
+}
+
+impl<'a> Iterator for CodeIter<'a> {
+  type Item = u16;
+  fn next(&mut self) -> Option<u16> {
+    match self.reader.read_bits(&self.bytes[self.pos..], U4_CODE_SIZE) {
+      lzw::Bits::Some(used, code) => {
+        self.pos += used;
+        Some(code)
+      },
+      lzw::Bits::None(used) => {
+        self.pos += used;
+        None
+      }
+    }
+  }
+}

src/engine.rs

@@ -0,0 +1,30 @@
+use gfx;
+use na;
+use piston;
+use view;
+use vr;
+
+pub trait GameContext {}
+
+pub trait Scene<G: GameContext,
+                D: gfx::Device,
+                F: gfx::Factory<D::Resources>> {
+  fn event(&mut self, event: Event);
+  fn update(&mut self,
+            game: &mut G,
+            vr: &mut Option<vr::VR>,  // TODO: abstract this out
+            encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>);
+  fn render(&self,
+            game: &mut G,
+            trans: &gfx::handle::Buffer<D::Resources, view::Trans>,
+            target: &gfx::handle::RenderTargetView<D::Resources, view::ColorFormat>,
+            depth: &gfx::handle::DepthStencilView<D::Resources, view::DepthFormat>,
+            factory: &mut F,
+            encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>);
+  fn origin(&self) -> na::Matrix4<f32>;
+}
+
+pub enum Event {
+  Vr(vr::Event),
+  Piston(piston::input::Input),
+}

src/lib.rs

@@ -1,3 +1,20 @@
-#[macro_use] extern crate log;
+#![feature(conservative_impl_trait)]
 
+#[macro_use] extern crate gfx;
+#[macro_use] extern crate log;
+extern crate nalgebra as na;
+extern crate num_traits;
+extern crate piston;
+
+pub mod arena;
+pub mod context;
+pub mod ega;
+pub mod engine;
+pub mod scenes;
+pub mod tile;
+pub mod town;
+pub mod view;
 pub mod vr;
+pub mod world;
+
+mod transpose;

src/scene.rs

@@ -0,0 +1,26 @@
+use gfx;
+use na;
+use piston;
+use view;
+use vr;
+
+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
+            encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>);
+  fn render(&self,
+            factory: &mut F,
+            encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>,
+            trans: &gfx::handle::Buffer<D::Resources, view::Trans>,
+            target: &gfx::handle::RenderTargetView<D::Resources, view::ColorFormat>,
+            depth: &gfx::handle::DepthStencilView<D::Resources, view::DepthFormat>);
+
+  fn origin(&self) -> na::Matrix4<f32>;
+}
+
+pub enum Event {
+  Vr(vr::Event),
+  Piston(piston::input::Input),
+}

src/scenes/mod.rs

@@ -0,0 +1 @@
+pub mod world;

src/scenes/shader/tile_frag.glsl

@@ -0,0 +1,32 @@
+#version 150
+
+#define MILLIS_PER_TILE 3000u
+
+in vec2 v_uv;
+flat in uint v_tileidx;
+in float v_fade;
+out vec4 pixcolor;
+uniform sampler2DArray t_tiles;
+uniform b_constants {
+  uvec4 anim;
+  float R1;
+  float R2;
+  float R3;
+  float haze;
+  vec4 hazecolor;
+};
+uniform b_locals {
+  uint millis;
+  float treadmill_x;
+  float treadmill_y;
+};
+
+void main() {
+  vec2 anim_uv = v_uv;
+  if (v_tileidx < 128u && bool(anim[v_tileidx / 32u] & 1u << v_tileidx % 32u)) {
+    anim_uv = vec2(v_uv.x, v_uv.y + float(millis % MILLIS_PER_TILE) / MILLIS_PER_TILE);
+  }
+
+  vec4 texcolor = texture(t_tiles, vec3(anim_uv.x, 1.0 - anim_uv.y, v_tileidx));
+  pixcolor = mix(texcolor, hazecolor, v_fade);
+}

src/scenes/shader/torus_vertex.glsl

@@ -0,0 +1,50 @@
+#version 150
+#define PI 3.1415926538
+#define PI_CIRC (PI / 256.0)
+#define TWO_PI_CIRC (2.0 * PI / 256.0)
+
+in vec3 a_pos;
+in vec2 a_uv;
+in uint a_tileidx;
+out vec2 v_uv;
+flat out uint v_tileidx;
+out float v_fade;
+uniform b_trans {
+  mat4 u_viewmodel;
+  mat4 u_matrix;
+};
+uniform b_constants {
+  uvec4 anim;
+  float R1;
+  float R2;
+  float R3;
+  float haze;
+  vec4 hazecolor;
+};
+uniform b_locals {
+  uint millis;
+  float treadmill_x;
+  float treadmill_y;
+};
+
+vec3 toroid(vec2 src, float r1, float r2, float r3) {
+  return vec3(r3 * sin(src.x), // use r3 instead of r2 for "deflated" torus
+              (r1 + r2 * cos(src.x)) * cos(src.y),
+              (r1 + r2 * cos(src.x)) * sin(src.y));
+}
+
+void main() {
+  v_uv = a_uv;
+  v_tileidx = a_tileidx;
+
+  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);
+  vec4 model_pos = vec4(toroid(thetaphi, R1, R2, R3) + a_pos.z * normal, 1.0);
+  gl_Position = u_matrix * model_pos;
+
+  vec4 view_pos = u_viewmodel * model_pos;
+  v_fade = min(1.0, length(view_pos.xyz) / R1 / 2 * haze);
+}

src/scenes/world.rs

@@ -0,0 +1,389 @@
+use context::VrtueRootContext;
+use engine;
+use view;
+use vr;
+use world as model;
+use world::HasMap;
+
+extern crate memmap;
+
+use std::collections::BTreeMap;
+use std::marker::PhantomData;
+use std::time::SystemTime;
+
+use gfx::{self, texture};
+use gfx::traits::FactoryExt;
+use na::{self, ToHomogeneous};
+use num_traits::identities::One;
+use piston::input::{Button, Input, Key};
+
+const PI: f32 = ::std::f32::consts::PI;
+const TWO_PI_CIRC: f32 = 2.0 * PI / 256.0;
+
+const R1: f32 = 256.0;
+const R2: f32 = 64.0;
+const R3: f32 = 128.0;
+
+//const SKY_COLOR: [f32; 4] = [0.15, 0.15, 0.75, 1.0];
+const SKY_COLOR: [f32; 4] = [0.005, 0.005, 0.01, 1.0];
+
+gfx_defines! {
+  vertex Vertex {
+    pos: [f32; 3] = "a_pos",
+    uv: [f32; 2] = "a_uv",
+    tileidx: u32 = "a_tileidx",
+  }
+
+  constant Constants {
+    anim: [u32; 4] = "anim",
+    r1: f32 = "R1",
+    r2: f32 = "R2",
+    r3: f32 = "R3",
+    haze: f32 = "haze",
+    hazecolor: [f32; 4] = "hazecolor",
+  }
+
+  constant Locals {
+    millis: u32 = "millis",
+    treadmill_x: f32 = "treadmill_x",
+    treadmill_y: f32 = "treadmill_y",
+  }
+
+  pipeline pipe {
+    vbuf: gfx::VertexBuffer<Vertex> = (),
+    trans: gfx::ConstantBuffer<::view::Trans> = "b_trans",
+    constants: gfx::ConstantBuffer<Constants> = "b_constants",
+    locals: gfx::ConstantBuffer<Locals> = "b_locals",
+    tiles: gfx::TextureSampler<[f32; 4]> = "t_tiles",
+    pixcolor: gfx::RenderTarget<::view::ColorFormat> = "pixcolor",
+    depth: gfx::DepthTarget<::view::DepthFormat> = gfx::preset::depth::LESS_EQUAL_WRITE,
+  }
+}
+
+
+fn get_model(world: &model::World) -> (Vec<Vertex>, Vec<u32>) {
+  let mut verticies = Vec::new();
+  let mut indicies = Vec::new();
+  let mut v = 0;
+
+  for (r, row) in world.map().rows().enumerate() {
+    for (c, tile) in row.into_iter().enumerate() {
+      let tileidx = tile.val as u32;
+      let alt = match tileidx {
+        5 => 0.1,
+        6 => 0.8,
+        7 => 0.2,
+        8 => 1.5,
+        9 => 1.0,
+        10 | 11 | 12 => 1.0,
+        _ => 0.0,
+      };
+      let (rf, cf) = (r as f32, c as f32);
+      if alt == 0.0 {
+        verticies.extend_from_slice(
+          &[Vertex { pos: [ cf + 0., rf + 1., 0. ], uv: [0., 0.], tileidx: tileidx },
+            Vertex { pos: [ cf + 1., rf + 1., 0. ], uv: [1., 0.], tileidx: tileidx },
+            Vertex { pos: [ cf + 1., rf + 0., 0. ], uv: [1., 1.], tileidx: tileidx },
+            Vertex { pos: [ cf + 0., rf + 0., 0. ], uv: [0., 1.], tileidx: tileidx },]);
+        indicies.extend_from_slice(
+          &[ v + 0, v + 1, v + 2,
+             v + 2, v + 3, v + 0 ]);
+        v += 4;
+      } else {
+        verticies.extend_from_slice(
+          &[Vertex { pos: [ cf + 0., rf + 1., 0. ], uv: [0., 0.], tileidx: tileidx },
+            Vertex { pos: [ cf + 1., rf + 1., 0. ], uv: [1., 0.], tileidx: tileidx },
+            Vertex { pos: [ cf + 1., rf + 0., 0. ], uv: [1., 1.], tileidx: tileidx },
+            Vertex { pos: [ cf + 0., rf + 0., 0. ], uv: [0., 1.], tileidx: tileidx },
+            Vertex { pos: [ cf + 0., rf, 0. ], uv: [0., 0.], tileidx: tileidx },
+            Vertex { pos: [ cf + 1., rf, 0. ], uv: [1., 0.], tileidx: tileidx },
+            Vertex { pos: [ cf + 1., rf, alt ], uv: [1., 1.], tileidx: tileidx },
+            Vertex { pos: [ cf + 0., rf, alt ], uv: [0., 1.], tileidx: tileidx },]);
+        indicies.extend_from_slice(
+          &[ v + 0, v + 1, v + 2,
+             v + 2, v + 3, v + 0,
+             v + 4, v + 5, v + 6,
+             v + 6, v + 7, v + 4 ]);
+        v += 8;
+      }
+    }
+  }
+  (verticies, indicies)
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum TrackMode {
+  Touch,
+  Press
+}
+
+pub struct WorldScene<D: gfx::Device,
+                      F: gfx::Factory<D::Resources>> {
+  pso: gfx::PipelineState<D::Resources, pipe::Meta>,
+  camera: na::Matrix4<f32>,
+  constants: Constants,
+  constants_buffer: gfx::handle::Buffer<D::Resources, Constants>,
+  constants_dirty: bool,
+  locals: gfx::handle::Buffer<D::Resources, Locals>,
+  sampler: gfx::handle::Sampler<D::Resources>,
+  f: PhantomData<F>,
+
+  vbuf: gfx::handle::Buffer<D::Resources, Vertex>,
+  slice: gfx::Slice<D::Resources>,
+
+  start_time: SystemTime,
+  treadmills: (f32, f32),
+  pads: BTreeMap<u32, (TrackMode, Option<vr::VRControllerState_t>)>,
+
+  _worldmap: model::World,
+  lat: u8,
+  lng: u8,
+}
+
+impl<D: gfx::Device,
+     F: gfx::Factory<D::Resources>> WorldScene<D, F> {
+  pub fn new(_device: &mut D,
+             factory: &mut F,
+             _aux_command: &mut <D as gfx::Device>::CommandBuffer) -> WorldScene<D, F> {
+    let worldmap = get_data_model();
+    let (model, model_idx) = get_model(&worldmap);
+    let (vertex_buffer, slice) =
+        factory.create_vertex_buffer_with_slice(&model, &model_idx[..]);
+
+    WorldScene {
+      pso: factory.create_pipeline_simple(VERTEX_SHADER_SRC,
+                                          FRAGMENT_SHADER_SRC,
+                                          pipe::new())
+                  .expect("create pipeline"),
+      camera: na::Matrix4::one(),
+      constants: Constants { anim: ANIMDATA,
+                             r1: R1, r2: R2, r3: R3,
+                             haze: 1.0/2.0f32.sqrt(), hazecolor: SKY_COLOR },
+      constants_buffer: factory.create_constant_buffer(1),
+      constants_dirty: true,
+      locals: factory.create_constant_buffer(1),
+      sampler: factory.create_sampler(texture::SamplerInfo::new(texture::FilterMethod::Jrd,
+                                                                texture::WrapMode::Tile)),
+      f: PhantomData,
+
+      vbuf: vertex_buffer,
+      slice: slice,
+      start_time: SystemTime::now(),
+      treadmills: (0.0, 0.0),
+      pads: BTreeMap::new(),
+
+      _worldmap: worldmap,
+      lat: 144,
+      lng: 90,
+    }
+  }
+
+  fn toroid((x, y): (f32, f32), 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 * 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] =
+  [1 << 0 | 1 << 1 | 1 << 2,
+   0,
+   1 << (68 % 32) | 1 << (69 % 32) | 1 << (70 % 32) | 1 << (71 % 32) | 1 << (76 % 32),
+   0];
+
+impl<D: gfx::Device,
+     F: gfx::Factory<D::Resources>>
+  engine::Scene<VrtueRootContext<D, F, view::ColorFormat>, D, F>
+  for WorldScene<D, F> {
+
+  fn event(&mut self, event: engine::Event) {
+    use engine::Event::*;
+    use vr::Event::*;
+    match event {
+      // treadmill / camera movement registration
+      Vr(Touch { dev_idx, .. }) => {
+        self.pads.insert(dev_idx, (TrackMode::Touch, None));
+      },
+      Vr(Press { dev_idx, .. }) => {
+        self.pads.insert(dev_idx, (TrackMode::Press, None));
+      },
+      Vr(Unpress { dev_idx, .. }) => {
+        self.pads.insert(dev_idx, (TrackMode::Touch, None));
+      },
+      Vr(Untouch { dev_idx, .. }) => {
+        self.pads.remove(&dev_idx);
+      },
+
+      // treadmill / camera reset
+      Piston(Input::Press(Button::Keyboard(Key::Backspace))) => {
+        self.treadmills = (0.0, 0.0);
+      },
+      Piston(Input::Press(Button::Keyboard(Key::D0))) => {
+        self.camera = na::Matrix4::one();
+      },
+
+      // player movement
+      Piston(Input::Press(Button::Keyboard(Key::Up))) => {
+        self.lat = self.lat.wrapping_sub(1);
+      },
+      Piston(Input::Press(Button::Keyboard(Key::Down))) => {
+        self.lat = self.lat.wrapping_add(1);
+      },
+      Piston(Input::Press(Button::Keyboard(Key::Left))) => {
+        self.lng = self.lng.wrapping_sub(1);
+      },
+      Piston(Input::Press(Button::Keyboard(Key::Right))) => {
+        self.lng = self.lng.wrapping_add(1);
+      },
+
+      // scale adjustment
+      Piston(Input::Press(Button::Keyboard(Key::Q))) => {
+        self.constants = Constants { r1: R1 / 2.0, r2: R2 / 2.0, r3: R3 / 2.0, ..self.constants };
+        self.constants_dirty = true;
+      },
+      Piston(Input::Press(Button::Keyboard(Key::D1))) => {
+        self.constants = Constants { r1: R1, r2: R2, r3: R3, ..self.constants };
+        self.constants_dirty = true;
+      },
+      Piston(Input::Press(Button::Keyboard(Key::D2))) => {
+        self.constants = Constants { r1: R1 * 2.0, r2: R2 * 2.0, r3: R3 * 2.0, ..self.constants };
+        self.constants_dirty = true;
+      },
+      Piston(Input::Press(Button::Keyboard(Key::D3))) => {
+        self.constants = Constants { r1: R1 * 4.0, r2: R2 * 4.0, r3: R3 * 4.0, ..self.constants };
+        self.constants_dirty = true;
+      },
+      Piston(Input::Press(Button::Keyboard(Key::D4))) => {
+        self.constants = Constants { r1: R1 * 16.0, r2: R2 * 16.0, r3: R3 * 16.0, ..self.constants };
+        self.constants_dirty = true;
+      },
+
+      Piston(Input::Press(Button::Keyboard(Key::H))) => {
+        self.constants = Constants { haze: self.constants.haze * 2.0f32.sqrt().sqrt(), ..self.constants };
+        println!("haze: {}", self.constants.haze);
+        self.constants_dirty = true;
+      },
+      Piston(Input::Press(Button::Keyboard(Key::N))) => {
+        self.constants = Constants { haze: self.constants.haze / 2.0f32.sqrt().sqrt(), ..self.constants };
+        println!("haze: {}", self.constants.haze);
+        self.constants_dirty = true;
+      },
+      _ => ()
+    }
+  }
+
+  fn update(&mut self,
+            _game: &mut VrtueRootContext<D, F, view::ColorFormat>,
+            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;
+    let elapsed = self.start_time.elapsed().expect("scene timer");
+    let millis = elapsed.subsec_nanos() / NANOS_PER_MILLI + (elapsed.as_secs() * MILLIS_PER_SEC) as u32;
+
+    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(old_state) = track.1 {
+          match mode {
+            TrackMode::Touch => {
+              const THRESHOLD: f32 = 0.005;
+              const SCALE: f32 = 32.0;
+              let xdiff = state.rAxis[0].x - old_state.rAxis[0].x;
+              let ydiff = state.rAxis[0].y - old_state.rAxis[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 {
+                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 {
+                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 {
+                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 {
+                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 {
+            continue;
+          }
+        }
+        *track = (mode, Some(state));
+      }
+    }
+
+    if self.constants_dirty {
+      self.constants_dirty = false;
+      encoder.update_constant_buffer(&self.constants_buffer, &self.constants);
+    }
+
+    encoder.update_constant_buffer(&self.locals, &Locals { millis: millis,
+                                                           treadmill_x: self.treadmills.0,
+                                                           treadmill_y: self.treadmills.1 });
+  }
+
+  fn render(&self,
+            game: &mut VrtueRootContext<D, F, view::ColorFormat>,
+            trans: &gfx::handle::Buffer<D::Resources, view::Trans>,
+            target: &gfx::handle::RenderTargetView<D::Resources, view::ColorFormat>,
+            depth: &gfx::handle::DepthStencilView<D::Resources, view::DepthFormat>,
+            _factory: &mut F,
+            encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) {
+
+    encoder.clear(&target, SKY_COLOR);
+    encoder.clear_depth(&depth, 1.0);
+    let pipe = pipe::Data {
+      vbuf: self.vbuf.clone(),
+      trans: trans.clone(),
+      constants: self.constants_buffer.clone(),
+      locals: self.locals.clone(),
+      tiles: (game.tiles(), self.sampler.clone()),
+      pixcolor: target.clone(),
+      depth: depth.clone(),
+    };
+    encoder.draw(&self.slice, &self.pso, &pipe);
+  }
+
+  fn origin(&self) -> na::Matrix4<f32> {
+    let (r1, r2, r3) = (self.constants.r1, self.constants.r2, self.constants.r3);
+    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);
+    self.camera * na::Isometry3::look_at_rh(eye.as_point(),
+                                            looktgt.as_point(),
+                                            &normal,
+                                           ).to_homogeneous()
+  }
+}
+
+fn get_data_model() -> model::World {
+  use self::memmap::{Mmap, Protection};
+  use std::mem::transmute;
+
+  fn mmap_to_rows<'a, M: model::HasMap>(mmap: &memmap::Mmap) -> &'a M
+    where M: Copy + 'a
+  {
+    assert_eq!(::std::mem::size_of::<M>(), mmap.len());
+    unsafe { transmute::<*const u8, &M>(mmap.ptr()) }
+  }
+
+  let filename = "data/WORLD.MAP";
+  let file_mmap = Mmap::open_path(filename, Protection::Read).unwrap();
+  mmap_to_rows::<model::World>(&file_mmap).clone()
+}
+
+const VERTEX_SHADER_SRC: &'static [u8] = include_bytes!("shader/torus_vertex.glsl");
+const FRAGMENT_SHADER_SRC: &'static [u8] = include_bytes!("shader/tile_frag.glsl");

src/tile.rs

@@ -1,8 +1,10 @@
+#[repr(C)]
 #[derive(Clone, Copy)]
 pub struct Tile {
-  val: u8,
+  pub val: u8,
 }
 
+
 impl Tile {
   pub fn as_char(&self) -> char {
     match self.val {

src/town.rs

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

src/view.rs

@@ -0,0 +1,130 @@
+use engine::{GameContext, Scene};
+use vr::{self, AsMatrix4, VR};
+
+extern crate gfx_device_gl;
+extern crate piston_window;
+
+use gfx;
+use gfx::Device;
+use gfx::traits::FactoryExt;
+use na::{self, Inverse, ToHomogeneous};
+use self::piston_window::{PistonWindow, Window};
+
+pub type ColorFormat = gfx::format::Srgba8;
+pub type DepthFormat = gfx::format::DepthStencil;
+
+const NEAR: f32 = 0.01;
+const FAR: f32 = 3072.0;
+
+gfx_constant_struct! {
+  Trans {
+    viewmodel: [[f32; 4]; 4] = "u_viewmodel",
+    matrix: [[f32; 4]; 4] = "u_matrix",
+  }
+}
+
+pub struct ViewRoot<Dev, T, D>
+  where Dev: gfx::Device,
+        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>>,
+  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>)
+                     -> 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,
+                                   height: render_size.height * 100 / 100 };
+
+      let left = vr::create_eyebuffer(&mut window.factory, render_size)
+          .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),
+        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,
+      }
+    }
+  }
+
+  pub fn draw<G: GameContext>(&self,
+                              game: &mut G,
+                              window: &mut PistonWindow,
+                              vr: &mut Option<vr::VR>,
+                              scene: &Scene<G, 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();
+
+      let mut hmd_mat = poses.poses[0].to_device.as_matrix4();
+      hmd_mat.inverse_mut();
+
+      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;
+
+        let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
+        let 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(),
+                            matrix: *(proj_mat * viewmodel_mat).as_ref() };
+        window.encoder.update_constant_buffer(&self.trans, &trans);
+
+        scene.render(game,
+                     &self.trans,
+                     &target,
+                     &depth,
+                     &mut window.factory,
+                     &mut window.encoder);
+      }
+    } 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 viewmodel_mat = head_mat * scene_mat;
+      let trans = Trans { viewmodel: *viewmodel_mat.as_ref(),
+                          matrix: *(proj_mat * viewmodel_mat).as_ref() };
+      window.encoder.update_constant_buffer(&self.trans, &trans);
+    }
+    // draw monitor window
+    scene.render(game,
+                 &self.trans,
+                 &window.output_color,
+                 &window.output_stencil,
+                 &mut window.factory,
+                 &mut window.encoder);
+
+    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);
+    }
+    window.window.swap_buffers();
+    window.device.cleanup();
+  }
+}

src/vr.rs

@@ -1,67 +1,168 @@
-extern crate gfx;
 extern crate gfx_device_gl;
 extern crate openvr as vr;
 extern crate openvr_sys;
 
-use self::gfx::{tex, Factory, Typed};
-
 pub use self::vr::Eye;
+pub use self::vr::common::Size;
+pub use self::openvr_sys::VRControllerState_t;
+
+use gfx::{self, texture, Factory};
+use gfx::memory::Typed;
+use na::{self, Inverse};
+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,
+  system: vr::IVRSystem,
-    compositor: vr::IVRCompositor,
+  compositor: vr::IVRCompositor,
-    gfx_handles: gfx::handle::Manager<gfx_device_gl::Resources>,
+  gfx_handles: gfx::handle::Manager<GLResources>,
+}
+
+#[derive(Debug)]
+pub enum Event {
+  Touch { dev_idx: u32, controller: VREvent_Controller_t },
+  Press { dev_idx: u32, controller: VREvent_Controller_t },
+  Unpress { dev_idx: u32, controller: VREvent_Controller_t },
+  Untouch { dev_idx: u32, controller: VREvent_Controller_t },
+  Other(VREvent_t),
 }
 
 impl VR {
-    pub fn new() -> Result<VR, vr::Error<openvr_sys::EVRInitError>> {
+  pub fn new() -> Result<VR, vr::Error<openvr_sys::EVRInitError>> {
-        Ok(VR {
+    Ok(VR {
-            system: try!(vr::init()),
+      system: vr::init()?,
-            compositor: try!(vr::compositor()),
+      compositor: vr::compositor()?,
-            gfx_handles: gfx::handle::Manager::new(),
+      gfx_handles: gfx::handle::Manager::new(),
-        })
+    })
-    }
+  }
 
-    pub fn poses(&mut self) -> vr::tracking::TrackedDevicePoses {
+  pub fn poses(&mut self) -> vr::tracking::TrackedDevicePoses {
-        self.gfx_handles.clear();
+    self.gfx_handles.clear();
-        self.compositor.wait_get_poses()
+    self.compositor.wait_get_poses()
-    }
+  }
 
-    pub fn submit<T>(&mut self, eye: Eye, tex: &gfx::handle::Texture<gfx_device_gl::Resources, T>) {
+  pub fn submit<T>(&mut self, eye: Eye, tex: &gfx::handle::Texture<GLResources, T>) {
-        let tex_id = match self.gfx_handles.ref_texture(tex.raw()) {
+    let tex_id = match self.gfx_handles.ref_texture(tex.raw()) {
-            &gfx_device_gl::NewTexture::Surface(id) => id,
+      &gfx_device_gl::NewTexture::Surface(id) => id,
-            _ => panic!("Not a surface")
+      _ => panic!("Not a surface")
-        };
+    };
-        self.compositor.submit(eye,
+    self.compositor.submit(eye,
-                               tex_id as usize,
+                           tex_id as usize,
-                               vr::common::TextureBounds::new((0.0, 1.0), (0.0, 1.0)));
+                           vr::common::TextureBounds::new((0.0, 1.0), (0.0, 1.0)));
-    }
+  }
 
-    pub fn recommended_render_target_size(&self) -> vr::common::Size {
+  pub fn recommended_render_target_size(&self) -> Size {
-        self.system.recommended_render_target_size()
+    self.system.recommended_render_target_size()
+  }
+
+  pub fn projection_matrix(self: &Self, eye: Eye, near: f32, far: f32) -> na::Matrix4<f32> {
+    self.system.projection_matrix(eye, near, far).as_matrix4()
+  }
+
+  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");
+    mat
+  }
+
+  pub fn poll_next_event(&mut self) -> Option<Event> {
+    use self::openvr_sys::EVREventType as EvType;
+    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,
+                                       ::std::mem::size_of::<openvr_sys::VREvent_t>() as u32
+      ) == 0 {
+        return None;
+      }
+
+      let dev_idx = event.trackedDeviceIndex;
+      Some(match ::std::mem::transmute(event.eventType) {
+        EvType::EVREventType_VREvent_ButtonTouch =>
+          Event::Touch { dev_idx: dev_idx as u32, controller: *event.data.controller() },
+        EvType::EVREventType_VREvent_ButtonPress =>
+          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> {
+    unsafe {
+      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 {
-    fn drop(&mut self) {
+  fn drop(&mut self) {
-        vr::shutdown()
+    vr::shutdown()
-    }
+  }
 }
 
-pub fn create_eyebuffer<T>(factory: &mut gfx_device_gl::Factory,
+pub trait AsMatrix4<N> {
-                           size: vr::common::Size)
+  fn as_matrix4(self) -> na::Matrix4<N>;
-                           -> Result<(gfx::handle::Texture<gfx_device_gl::Resources,
+}
-                                                           T::Surface>,
+impl<N: Copy + Zero + One> AsMatrix4<N> for [[N; 4]; 3] {
-                                      gfx::handle::RenderTargetView<gfx_device_gl::Resources,
+  #[inline]
-                                                                    T>),
+  fn as_matrix4(self) -> na::Matrix4<N> {
-                                     gfx::CombinedError>
+    na::Matrix4::new(self[0][0], self[0][1], self[0][2], self[0][3],
-    where T: gfx::format::RenderFormat + gfx::format::TextureFormat {
+                     self[1][0], self[1][1], self[1][2], self[1][3],
-    let tex = try!(factory.create_texture(
+                     self[2][0], self[2][1], self[2][2], self[2][3],
-        tex::Kind::D2(size.width as tex::Size, size.height as tex::Size, tex::AaMode::Single),
+                     N::zero(),  N::zero(),  N::zero(),  N::one())
-        1, // levels
+  }
-        gfx::RENDER_TARGET, // bind
+}
-        gfx::Usage::GpuOnly, // Usage
+impl<N: Copy> AsMatrix4<N> for [[N; 4]; 4] {
-        Some(<T::Channel as gfx::format::ChannelTyped>::get_channel_type()))); // hint: format::ChannelType?
+  #[inline]
-    let tgt = try!(factory.view_texture_as_render_target(&tex, 0, None));
+  fn as_matrix4(self) -> na::Matrix4<N> {
-    Ok((tex, tgt))
+    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],
+                     self[3][0], self[3][1], self[3][2], self[3][3])
+  }
+}
+
+pub struct EyeBuffer<T, D>
+  where T: gfx::format::RenderFormat + gfx::format::TextureFormat,
+        D: gfx::format::DepthFormat + gfx::format::TextureFormat {
+
+  pub tex: gfx::handle::Texture<GLResources, T::Surface>,
+  pub target: gfx::handle::RenderTargetView<GLResources, T>,
+  pub depth: gfx::handle::DepthStencilView<GLResources, D>,
+}
+
+pub fn create_eyebuffer<T, D>(factory: &mut gfx_device_gl::Factory,
+                              size: Size)
+                              -> 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,
+                                        size.height as texture::Size,
+                                        texture::AaMode::Single),
+                      1, // levels
+                      gfx::RENDER_TARGET, // bind
+                      gfx::memory::Usage::GpuOnly, // 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,
+                                                     size.height as texture::Size)?;
+  Ok(EyeBuffer { tex: tex, target: tgt, depth: depth })
 }

src/world.rs

@@ -1,4 +1,3 @@
-extern crate core;
 extern crate itertools;
 
 use self::itertools::Itertools;
@@ -21,6 +20,7 @@ pub trait HasMap {
 const CHUNKDIM: usize = 32;
 pub type ChunkRow = [Tile; CHUNKDIM];
 pub type ChunkRect = [ChunkRow; CHUNKDIM];
+#[repr(C)]
 #[derive(Clone, Copy)]
 pub struct Chunk {
   pub rect: ChunkRect,
@@ -53,6 +53,7 @@ impl<'a> IntoIterator for &'a Chunk {
 const WORLDDIM: usize = 8;
 pub type WorldRow = [Chunk; WORLDDIM];
 pub type WorldRect = [WorldRow; WORLDDIM];
+#[repr(C)]
 #[derive(Clone, Copy)]
 pub struct World {
   pub rect: WorldRect,