use upscaled mipmaps for tiles

src/ega.rs

@@ -28,12 +28,68 @@ pub enum Tiling {
 
 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
   }
 }
 
@@ -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}
 }