tile window draws all tiles + is optional

src/main.rs

@@ -57,6 +57,10 @@ struct Args {
     #[arg(short, long)]
     cycle_count: bool,
 
+    /// Show tile window
+    #[arg(short, long)]
+    tile_window: bool,
+
     /// Step emulation by...
     #[arg(long)]
     step_by: Option<usize>,
@@ -117,7 +121,11 @@ fn main() {
 
     window.topmost(true);
 
-    let mut cpu = CPU::new(Memory::init(bootrom, args.run_bootrom, rom), window);
+    let mut cpu = CPU::new(
+        Memory::init(bootrom, args.run_bootrom, rom),
+        window,
+        args.tile_window,
+    );
 
     if !args.run_bootrom {
         cpu.reg.pc = 0x0100;

src/processor/gpu.rs

@@ -1,3 +1,4 @@
+use self::tile_window::TileWindow;
 use crate::{
     processor::{as_signed, get_bit, set_bit, set_or_clear_bit, CPU},
     FACTOR, HEIGHT, WIDTH,
@@ -117,8 +118,10 @@ struct Object {
     flags: ObjectFlags,
 }
 
-const TILE_WINDOW_EDGE_LENGTH: usize = 16 * 8;
+const TILE_WINDOW_WIDTH: usize = 16 * 8;
-const TILE_WINDOW_EDGE_LENGTH_SCALED: usize = TILE_WINDOW_EDGE_LENGTH * FACTOR;
+const TILE_WINDOW_HEIGHT: usize = 24 * 8;
+const TILE_WINDOW_WIDTH_SCALED: usize = TILE_WINDOW_WIDTH * FACTOR;
+const TILE_WINDOW_HEIGHT_SCALED: usize = TILE_WINDOW_HEIGHT * FACTOR;
 
 pub struct GPU {
     pub buffer: Vec<u32>,
@@ -126,17 +129,16 @@ pub struct GPU {
     mode: DrawMode,
     mode_clock: usize,
     scanline: u8,
-    sprite_buffer: Vec<u32>,
+    tile_window: Option<TileWindow>,
-    sprite_buffer_scaled: Vec<u32>,
-    sprite_window: Window,
 }
 
-impl Default for GPU {
+impl GPU {
-    fn default() -> Self {
+    pub(super) fn new(enable_tile_window: bool) -> Self {
+        let tile_window = if enable_tile_window {
             let mut window = Window::new(
                 "Tiles",
-            TILE_WINDOW_EDGE_LENGTH_SCALED,
+                TILE_WINDOW_WIDTH_SCALED,
-            TILE_WINDOW_EDGE_LENGTH_SCALED,
+                TILE_WINDOW_HEIGHT_SCALED,
                 WindowOptions::default(),
             )
             .unwrap_or_else(|e| {
@@ -144,21 +146,19 @@ impl Default for GPU {
             });
 
             window.set_position((550 + (WIDTH * FACTOR)) as isize, 50);
-
             window.topmost(true);
+            Some(TileWindow::new(window))
+        } else {
+            None
+        };
+
         Self {
             buffer: vec![0; WIDTH * HEIGHT],
             scaled_buffer: vec![0; WIDTH * HEIGHT * 4],
             mode: DrawMode::Mode2,
             mode_clock: 0,
             scanline: 0,
-            sprite_buffer: vec![0; TILE_WINDOW_EDGE_LENGTH * TILE_WINDOW_EDGE_LENGTH],
+            tile_window,
-            sprite_buffer_scaled: vec![
-                0;
-                TILE_WINDOW_EDGE_LENGTH_SCALED
-                    * TILE_WINDOW_EDGE_LENGTH_SCALED
-            ],
-            sprite_window: window,
         }
     }
 }
@@ -259,10 +259,9 @@ impl CPU {
     fn exit_vblank(&mut self) {
         self.gpu.mode = DrawMode::Mode2;
         self.gpu.scanline = 0;
-        self.draw_sprite_window(
+        if let Some(tile_window) = &mut self.gpu.tile_window {
-            TiledataArea::D8000,
+            tile_window.draw_sprite_window(byte_to_palette(self.memory.get(0xFF47)), &self.memory);
-            byte_to_palette(self.memory.get(0xFF47)),
+        }
-        );
     }
 
     fn set_lcd_status(&mut self) {

src/processor/gpu/tile_window.rs

@@ -1,51 +1,94 @@
+use minifb::Window;
+
 use crate::{
     processor::{
         get_bit,
         gpu::{
-            bits_to_mapped_colour, scale_buffer, Palette, TiledataArea, TILE_WINDOW_EDGE_LENGTH,
+            bits_to_mapped_colour, scale_buffer, Palette, TiledataArea, TILE_WINDOW_HEIGHT,
-            TILE_WINDOW_EDGE_LENGTH_SCALED,
+            TILE_WINDOW_HEIGHT_SCALED, TILE_WINDOW_WIDTH, TILE_WINDOW_WIDTH_SCALED,
         },
-        CPU,
+        memory::Memory,
     },
     FACTOR,
 };
 
-impl CPU {
+pub(super) struct TileWindow {
-    pub(super) fn draw_sprite_window(&mut self, area: TiledataArea, palette: Palette) {
+    sprite_buffer: Vec<u32>,
+    sprite_buffer_scaled: Vec<u32>,
+    sprite_window: Window,
+}
+
+impl TileWindow {
+    pub(super) fn new(window: Window) -> Self {
+        Self {
+            sprite_buffer: vec![0; TILE_WINDOW_WIDTH * TILE_WINDOW_HEIGHT],
+            sprite_buffer_scaled: vec![0; TILE_WINDOW_WIDTH_SCALED * TILE_WINDOW_HEIGHT_SCALED],
+            sprite_window: window,
+        }
+    }
+}
+
+impl TileWindow {
+    pub(super) fn draw_sprite_window(&mut self, palette: Palette, memory: &Memory) {
         for tile_y in 0..16 {
+            self.draw_row(
+                tile_y,
+                tile_y as usize,
+                TiledataArea::D8000,
+                palette,
+                memory,
+            );
+        }
+        for tile_y in 0..8 {
+            self.draw_row(
+                tile_y,
+                (tile_y as usize) + 16,
+                TiledataArea::D9000,
+                palette,
+                memory,
+            );
+        }
+
+        self.sprite_buffer_scaled = scale_buffer(
+            &self.sprite_buffer,
+            TILE_WINDOW_WIDTH,
+            TILE_WINDOW_HEIGHT,
+            FACTOR,
+        );
+        self.sprite_window
+            .update_with_buffer(
+                &self.sprite_buffer_scaled,
+                TILE_WINDOW_WIDTH_SCALED,
+                TILE_WINDOW_HEIGHT_SCALED,
+            )
+            .unwrap();
+    }
+
+    fn draw_row(
+        &mut self,
+        tile_y: u8,
+        display_y: usize,
+        area: TiledataArea,
+        palette: Palette,
+        memory: &Memory,
+    ) {
         for tile_x in 0..16 {
             let tile_num = (tile_y * 16) + tile_x;
             let data_begin = area.get_addr(tile_num);
             for px_y in 0..8 {
-                    let lsbs = self.memory.get((px_y * 2) + data_begin);
+                let lsbs = memory.get((px_y * 2) + data_begin);
-                    let msbs = self.memory.get((px_y * 2) + data_begin + 1);
+                let msbs = memory.get((px_y * 2) + data_begin + 1);
                 for px_x in 0..8 {
-                        let real_px_y = (tile_y as usize * 8) + px_y as usize;
+                    let real_px_y = (display_y * 8) + px_y as usize;
                     let real_px_x = (tile_x as usize * 8) + px_x as usize;
                     let lsb = get_bit(lsbs, 7 - px_x);
                     let msb = get_bit(msbs, 7 - px_x);
                     let colour = bits_to_mapped_colour(lsb, msb, palette);
 
-                        self.gpu.sprite_buffer[real_px_x + (real_px_y * TILE_WINDOW_EDGE_LENGTH)] =
+                    self.sprite_buffer[real_px_x + (real_px_y * TILE_WINDOW_WIDTH)] =
                         colour.to_rgb();
                 }
             }
         }
     }
-
-        self.gpu.sprite_buffer_scaled = scale_buffer(
-            &self.gpu.sprite_buffer,
-            TILE_WINDOW_EDGE_LENGTH,
-            TILE_WINDOW_EDGE_LENGTH,
-            FACTOR,
-        );
-        self.gpu
-            .sprite_window
-            .update_with_buffer(
-                &self.gpu.sprite_buffer_scaled,
-                TILE_WINDOW_EDGE_LENGTH_SCALED,
-                TILE_WINDOW_EDGE_LENGTH_SCALED,
-            )
-            .unwrap();
-    }
 }

src/processor/mod.rs

@@ -38,14 +38,14 @@ const SPEEDUP: f64 = 1.;
 const FF04_SPEED: f64 = 16384.;
 
 impl CPU {
-    pub fn new(memory: Memory, window: Window) -> Self {
+    pub fn new(memory: Memory, window: Window, enable_tile_window: bool) -> Self {
         Self {
             memory,
             reg: Registers::default(),
             last_instruction: 0x0,
             last_instruction_addr: 0x0,
             window,
-            gpu: GPU::default(),
+            gpu: GPU::new(enable_tile_window),
             halted: false,
         }
     }