no all caps for enum variants

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,7 +22,7 @@ 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));
+  let ega_page = ega::decode(&ega_vec, Compression::Uncompressed, Tiling::Tiled(16));
   for (i, tilepixels) in ega_page.iter().enumerate() {
     let out_name = format!("out/{}.png", i);
     let out_file = std::fs::File::create(Path::new(&out_name)).expect("open out file");

src/bin/vrtue.rs

@@ -19,7 +19,11 @@ pub fn main() {
         .vsync(false)
         .build().expect("Building Window");
 
-  let mut scene = scenes::world::WorldScene::new(&mut window.factory, &mut window.encoder);
+  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 view = view::ViewRoot::<gfx_device_gl::Device, view::ColorFormat, view::DepthFormat>
                            ::create_view(&mut window, &mut vr);
 

src/ega.rs

@@ -16,24 +16,80 @@ 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)
+  Untiled,
+  Tiled(u16)
 }
 
 pub struct EgaPage {
   pub data: Vec<u8>,
-  pub tilesize: u16,
+  pub dim: usize,
 }
 
 impl EgaPage {
   pub fn iter<'a>(&'a self) -> impl Iterator<Item=&'a [u8]> {
-    self.data.chunks(self.tilesize as usize)
+    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
   }
 }
 
@@ -42,7 +98,7 @@ pub fn decode<'a>(buf: &[u8], compression: Compression, tiling: Tiling)
   let out: Vec<u8>;
 
   out = match compression {
-    Compression::UNCOMPRESSED => buf.iter()
+    Compression::Uncompressed => buf.iter()
                                     .flat_map(|tile_byte| {
                                       EGA_PALETTE[(tile_byte >> 4u8 & 0xF) as usize]
                                         .into_iter()
@@ -53,9 +109,9 @@ pub fn decode<'a>(buf: &[u8], compression: Compression, tiling: Tiling)
                                     .collect(),
     _ => unimplemented!()
   };
-  let tilesize = match tiling {
-    Tiling::TILED(tiledim) => 4 * tiledim * tiledim,
-    Tiling::UNTILED => out.len() as u16
+  let dim = match tiling {
+    Tiling::Tiled(tiledim) => tiledim as usize,
+    Tiling::Untiled => out.len()
   };
-  EgaPage { data: out, tilesize: tilesize}
+  EgaPage { data: out, dim: dim}
 }

src/scenes/world.rs

@@ -112,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,
@@ -136,8 +136,10 @@ pub struct WorldScene<D: gfx::Device,
 }
 
 impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
-  pub fn new(factory: &mut F,
-             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) -> 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> {
     let (model, model_idx) = get_model(&get_data_model());
     let (vertex_buffer, slice) =
         factory.create_vertex_buffer_with_slice(&model, &model_idx[..]);
@@ -155,8 +157,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>(factory),
-      sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Scale,
+      atlas: tile::get_tiles::<_, _, view::ColorFormat>(device, factory, aux_command),
+      sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Jrd,
                                                             tex::WrapMode::Tile)),
       f: PhantomData,
 
@@ -182,16 +184,16 @@ impl<D: gfx::Device,
     use scene::Event::*;
     use vr::Event::*;
     match event {
-      Vr(Touch { dev_idx, controller }) => {
-        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
+      Vr(Touch { dev_idx, .. }) => {
+        self.pads.insert(dev_idx, (TrackMode::Touch, None));
       },
-      Vr(Press { dev_idx, controller }) => {
-        self.pads.insert(dev_idx, (TrackMode::PRESS, None));
+      Vr(Press { dev_idx, .. }) => {
+        self.pads.insert(dev_idx, (TrackMode::Press, None));
       },
-      Vr(Unpress { dev_idx, controller }) => {
-        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
+      Vr(Unpress { dev_idx, .. }) => {
+        self.pads.insert(dev_idx, (TrackMode::Touch, None));
       },
-      Vr(Untouch { dev_idx, controller }) => {
+      Vr(Untouch { dev_idx, .. }) => {
         self.pads.remove(&dev_idx);
       },
       _ => ()
@@ -211,7 +213,7 @@ impl<D: gfx::Device,
       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;
@@ -219,7 +221,7 @@ 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.01;
               if state.rAxis[0].x > 0.5 {

src/tile.rs

@@ -6,30 +6,45 @@ 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<R, F, T>(factory: &mut F) -> (//gfx::handle::Texture<R, T::Surface>,
-                                               gfx::handle::ShaderResourceView<R, T::View>)
-  where R: gfx::Resources,
-        F: gfx::Factory<R>,
+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>,
         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(16));
-  let tiles: Vec<&[u8]> = ega_page.iter().collect();
-  let tex = factory.create_texture_const_u8::<T>(tex::Kind::D2Array(16, 16, 256,
+  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,
                                                                     tex::AaMode::Single),
-                                                 &tiles)
+                                                 &mipmap.slices())
                    .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 {