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_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/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));
+  let tiles = ega::decode(&ega_vec, Compression::UNCOMPRESSED, Tiling::TILED(16));
-  for (i, tilepixels) in ega_page.iter().enumerate() {
+  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");
+    tile.save(out_name).expect("save png");
-    let enc = image::png::PNGEncoder::new(out_file);
-    enc.encode(&tilepixels, 16, 16, image::ColorType::RGBA(8)).expect("write png");
   }
 }

src/bin/vrtue.rs

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

@@ -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,
+  UNCOMPRESSED,
-  Rle,
+  RLE,
-  Lzw
+  LZW
 }
 
 pub enum Tiling {
-  Untiled,
+  UNTILED,
-  Tiled(u16)
+  TILED(u32)
-}
-
-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 {
+                  -> Vec<ImageBuffer<Rgba<u8>, Vec<u8>>> {
-  let out: Vec<u8>;
+  let (tiledim, iter) = match tiling {
-
+    Tiling::TILED(tiledim) => (tiledim, buf.chunks((tiledim * tiledim / 2) as usize)),
-  out = match compression {
+    Tiling::UNTILED => (buf.len() as u32, buf.chunks(buf.len()))
-    Compression::Uncompressed => buf.iter()
+  };
+  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)
-                                    .map(|x| *x)
+                                   .collect())
-                                    .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/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,
+  TOUCH,
-  Press
+  PRESS
 }
 
 pub struct WorldScene<D: gfx::Device,
@@ -136,10 +136,8 @@ pub struct WorldScene<D: gfx::Device,
 }
 
 impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
-  pub fn new(device: &mut D,
+  pub fn new(factory: &mut F,
-             factory: &mut F,
+             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) -> WorldScene<D, 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[..]);
@@ -157,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),
+      atlas: tile::get_tiles::<_, _, view::ColorFormat>(factory),
-      sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Jrd,
+      sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Scale,
                                                             tex::WrapMode::Tile)),
       f: PhantomData,
 
@@ -184,16 +182,16 @@ impl<D: gfx::Device,
     use scene::Event::*;
     use vr::Event::*;
     match event {
-      Vr(Touch { dev_idx, .. }) => {
+      Vr(Touch { dev_idx, controller }) => {
-        self.pads.insert(dev_idx, (TrackMode::Touch, None));
+        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
       },
-      Vr(Press { dev_idx, .. }) => {
+      Vr(Press { dev_idx, controller }) => {
-        self.pads.insert(dev_idx, (TrackMode::Press, None));
+        self.pads.insert(dev_idx, (TrackMode::PRESS, None));
       },
-      Vr(Unpress { dev_idx, .. }) => {
+      Vr(Unpress { dev_idx, controller }) => {
-        self.pads.insert(dev_idx, (TrackMode::Touch, None));
+        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
       },
-      Vr(Untouch { dev_idx, .. }) => {
+      Vr(Untouch { dev_idx, controller }) => {
         self.pads.remove(&dev_idx);
       },
       _ => ()
@@ -213,7 +211,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;
@@ -221,7 +219,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,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,
+pub fn get_tiles<R, F, T>(factory: &mut F) -> gfx::handle::ShaderResourceView<R, T::View>
-                          factory: &mut F,
+  where R: gfx::Resources,
-                          command: &mut <D as gfx::Device>::CommandBuffer)
+        F: gfx::Factory<R>,
-                          -> 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(TILEDIM));
+  let tiles = ega::decode(&ega_bytes, ega::Compression::UNCOMPRESSED, ega::Tiling::TILED(16));
-  let mipmap = ega_page.mipmap(2);
+  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,
-  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),
-                                                 &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,
+  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 {