WIP: show overworld map

src/scenes/world.rs

@@ -1,6 +1,8 @@
 use scene;
 use tile;
 use view;
+use world as model;
+use world::HasMap;
 
 extern crate gfx;
 extern crate piston_window;
@@ -27,14 +29,28 @@ gfx_defines! {
 }
 
 
-fn get_model(/*x: u16, y: u16,*/ tile: &tile::Tile) -> ([Vertex; 4], [u16; 6]) {
+fn get_model(world: &model::World) -> (Vec<Vertex>, Vec<u32>) {
-  let tileidx = tile.val as u32;
+  let mut verticies = Vec::new();
-  ([Vertex { pos: [ 0., 0., 0. ], uv: [0., 0.], tileidx: tileidx },
+  let mut indicies = Vec::new();
-    Vertex { pos: [ 1., 0., 0. ], uv: [1., 0.], tileidx: tileidx },
+  let mut v = 0;
-    Vertex { pos: [ 1., 0., 1. ], uv: [1., 1.], tileidx: tileidx },
+
-    Vertex { pos: [ 0., 0., 1. ], uv: [0., 1.], tileidx: tileidx },],
+  for (r, row) in world.map().rows().enumerate() {
-   [ 0, 1, 2,
+    for (c, tile) in row.into_iter().enumerate() {
-     2, 3, 0 ])
+      let tileidx = tile.val as u32;
+      let rf = (((r + 32) % 256) as i16 - 128) as f32;
+      let cf = (((c + 32) % 256)as i16 - 128) as f32;
+      verticies.extend_from_slice(
+        &[Vertex { pos: [ cf + 0., -rf - 1., -20.0 ], uv: [0., 0.], tileidx: tileidx },
+          Vertex { pos: [ cf + 1., -rf - 1., -20.0 ], uv: [1., 0.], tileidx: tileidx },
+          Vertex { pos: [ cf + 1., -rf - 0., -20.0 ], uv: [1., 1.], tileidx: tileidx },
+          Vertex { pos: [ cf + 0., -rf - 0., -20.0 ], uv: [0., 1.], tileidx: tileidx },]);
+      indicies.extend_from_slice(
+        &[ v + 0, v + 1, v + 2,
+           v + 2, v + 3, v + 0 ]);
+      v += 4;
+    }
+  }
+  (verticies, indicies)
 }
 
 pub struct WorldScene<D: gfx::Device,
@@ -43,11 +59,18 @@ pub struct WorldScene<D: gfx::Device,
   atlas: gfx::handle::ShaderResourceView<D::Resources,
                                          <view::ColorFormat as gfx::format::Formatted>::View>,
   sampler: gfx::handle::Sampler<D::Resources>,
-  f: PhantomData<F>
+  f: PhantomData<F>,
+
+  vbuf: gfx::handle::Buffer<D::Resources, Vertex>,
+  slice: gfx::Slice<D::Resources>,
 }
 
 impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
   pub fn new(factory: &mut F) -> 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[..]);
+
     WorldScene {
       pso: factory.create_pipeline_simple(VERTEX_SHADER_SRC,
                                           FRAGMENT_SHADER_SRC,
@@ -57,6 +80,9 @@ impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
       sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Scale,
                                                             tex::WrapMode::Clamp)),
       f: PhantomData,
+
+      vbuf: vertex_buffer,
+      slice: slice,
     }
   }
 }
@@ -71,26 +97,40 @@ impl<D: gfx::Device,
   }
 
   fn render(&self,
-            factory: &mut F,
+            _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>) {
-    let (model, model_idx) = get_model(&tile::Tile { val: 31 });
-    let (vertex_buffer, slice) =
-        factory.create_vertex_buffer_with_slice(&model, &model_idx[..]);
 
     let pipe = pipe::Data {
-      vbuf: vertex_buffer.clone(),
+      vbuf: self.vbuf.clone(),
       trans: trans.clone(),
       atlas: (self.atlas.clone(), self.sampler.clone()),
       pixcolor: target.clone(),
       depth: depth.clone(),
     };
-    encoder.draw(&slice, &self.pso, &pipe);
+    encoder.draw(&self.slice, &self.pso, &pipe);
   }
 }
 
+extern crate memmap;
+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] = br#"
     #version 150
 

src/view.rs

@@ -67,32 +67,24 @@ impl ViewRoot<gfx_device_gl::Device, ColorFormat, DepthFormat> {
 
     for &(eye, buffers) in [(vr::Eye::Left, &self.left),
                             (vr::Eye::Right, &self.right)].into_iter() {
-      window.encoder.clear(&buffers.target, [0.1, 0.2, 0.3, 1.0]);
+      window.encoder.clear(&buffers.target, [0.05, 0.05, 0.1, 1.0]);
 
       window.encoder.clear_depth(&buffers.depth, 1.0);
 
         // Submit eye textures
       let proj_mat = vr.projection_matrix(eye, NEAR, FAR);
       let eye_mat = vr.head_to_eye_transform(eye);
-      for track in (0..poses.count).map(|pose| poses.poses[pose]) {
-        match track.device_class() {
-          vr::TrackedDeviceClass::Controller |
-          vr::TrackedDeviceClass::TrackingReference => {
-            let model_mat = track.to_device.as_matrix4();
 
-            let trans = Trans { matrix: *(proj_mat * eye_mat * hmd_mat * model_mat).as_ref() };
+      let model_mat = na::Matrix4::one();
-            window.encoder.update_constant_buffer(&self.trans, &trans);
 
-            scene.render(&mut window.factory,
+      let trans = Trans { matrix: *(proj_mat * eye_mat * hmd_mat * model_mat).as_ref() };
-                         &mut window.encoder,
+      window.encoder.update_constant_buffer(&self.trans, &trans);
-                         &self.trans,
-                         &buffers.target,
-                         &buffers.depth);
-          },
-          _ => ()
-        }
-      }
 
+      scene.render(&mut window.factory,
+                   &mut window.encoder,
+                   &self.trans,
+                   &buffers.target,
+                   &buffers.depth);
     }
     // draw monitor window
     window.encoder.update_constant_buffer(&self.trans,