src/bus/io.zig

@@ -93,13 +93,13 @@ const KeyInput = extern union {
 
 // Read / Write
 pub const BackgroundControl = extern union {
-    priority: Bitfield(u16, 0, 2),
+    bg_priority: Bitfield(u16, 0, 2),
     char_base: Bitfield(u16, 2, 2),
     mosaic_enable: Bit(u16, 6),
-    colour_mode: Bit(u16, 7),
+    palette_type: Bit(u16, 7),
     screen_base: Bitfield(u16, 8, 5),
     display_overflow: Bit(u16, 13),
-    size: Bitfield(u16, 14, 2),
+    screen_size: Bitfield(u16, 14, 2),
     raw: u16,
 };
 

src/ppu.zig

@@ -4,9 +4,6 @@ const io = @import("bus/io.zig");
 const EventKind = @import("scheduler.zig").EventKind;
 const Scheduler = @import("scheduler.zig").Scheduler;
 
-const Bit = @import("bitfield").Bit;
-const Bitfield = @import("bitfield").Bitfield;
-
 const Allocator = std.mem.Allocator;
 
 pub const width = 240;
@@ -71,65 +68,8 @@ pub const Ppu = struct {
 
         switch (bg_mode) {
             0x0 => {
-                // TODO: Consider more than BG0
+                // Mode 0
-                // TODO: Consider Scrolling
 
-                // The Current Scanline which will be copied into
-                // the Framebuffer
-                const start = framebuf_pitch * @as(usize, scanline);
-                var scanline_buf = std.mem.zeroes([framebuf_pitch]u8);
-
-                // A Tile in a charblock is a byte, while a Screen Entry is a halfword
-                const charblock_len: u32 = 0x4000;
-                const screenblock_len: u32 = 0x800;
-
-                const cbb: u2 = self.bg0.cnt.char_base.read(); // Char Block Base
-                const sbb: u5 = self.bg0.cnt.screen_base.read(); // Screen Block Base
-                const is_8bpp: bool = self.bg0.cnt.colour_mode.read(); // Colour Mode
-                const size: u2 = self.bg0.cnt.size.read(); // Background Size
-
-                // In 4bpp: 1 byte represents two pixels so the length is (8 x 8) / 2
-                // In 8bpp: 1 byte represents one pixel so the length is 8 x 8
-                const tile_len = if (is_8bpp) @as(u32, 0x40) else 0x20;
-                const tile_row_offset = if (is_8bpp) @as(u32, 0x8) else 0x4;
-
-                // 0x0600_000 is implied because we can access VRAM without the Bus
-                const char_base: u32 = charblock_len * @as(u32, cbb);
-                const screen_base: u32 = screenblock_len * @as(u32, sbb);
-
-                const y = @as(u32, scanline);
-
-                var x: u32 = 0;
-                while (x < width) : (x += 1) {
-                    // Grab the Screen Entry from VRAM
-                    const entry_addr = screen_base + tilemapOffset(size, x, y);
-                    const entry = @bitCast(ScreenEntry, @as(u16, self.vram.buf[entry_addr + 1]) << 8 | @as(u16, self.vram.buf[entry_addr]));
-
-                    // Calculate the Address of the Tile in the designated Charblock
-                    // We also take this opportunity to flip tiles if necessary
-                    const tile_id: u32 = entry.tile_id.read();
-                    const row = if (entry.h_flip.read()) 7 - (y % 8) else y % 8; // Determine on which row in a tile we're on
-                    const tile_addr = char_base + (tile_len * tile_id) + (tile_row_offset * row);
-
-                    // Calculate on which column in a tile we're on
-                    // Similarly to when we calculated the row, if we're in 4bpp we want to account
-                    // for 1 byte consisting of two pixels
-                    const col = if (entry.v_flip.read()) 7 - (x % 8) else x % 8;
-                    var tile = self.vram.buf[tile_addr + if (is_8bpp) col else col / 2];
-
-                    // If we're in 8bpp, then the tile value is an index into the palette,
-                    // If we're in 4bpp, we have to account for a pal bank value in the Screen entry
-                    // and then we can index the palette
-                    const colour = if (!is_8bpp) blk: {
-                        tile = if (col & 1 == 1) tile >> 4 else tile & 0xF;
-                        const pal_bank: u8 = @as(u8, entry.palette_bank.read()) << 4;
-                        break :blk pal_bank | tile;
-                    } else tile;
-
-                    std.mem.copy(u8, scanline_buf[x * 2 ..][0..2], self.palette.buf[colour * 2 ..][0..2]);
-                }
-
-                std.mem.copy(u8, self.framebuf[start..][0..framebuf_pitch], &scanline_buf);
             },
             0x3 => {
                 const start = framebuf_pitch * @as(usize, scanline);
@@ -154,19 +94,6 @@ pub const Ppu = struct {
             else => std.debug.panic("[PPU] TODO: Implement BG Mode {}", .{bg_mode}),
         }
     }
-
-    fn tilemapOffset(size: u2, x: u32, y: u32) u32 {
-        // Current Row: (y % PIXEL_COUNT) / 8
-        // Current COlumn: (x % PIXEL_COUNT) / 8
-        // Length of 1 row of Screen Entries: 0x40
-        // Length of 1 Screen Entry: 0x2 is the size of a screen entry
-        return switch (size) {
-            0 => (y % 256 / 8) * 0x40 + (x % 256 / 8) * 2, // 256 x 256
-            1 => (y % 512 / 8) * 0x40 + (x % 256 / 8) * 2, // 512 x 256
-            2 => (y % 256 / 8) * 0x40 + (x % 512 / 8) * 2, // 256 x 512
-            3 => (y % 512 / 8) * 0x40 + (x % 512 / 8) * 2, // 512 x 512
-        };
-    }
 };
 
 const Palette = struct {
@@ -314,11 +241,3 @@ const Background = struct {
         };
     }
 };
-
-const ScreenEntry = extern union {
-    tile_id: Bitfield(u16, 0, 10),
-    h_flip: Bit(u16, 10),
-    v_flip: Bit(u16, 11),
-    palette_bank: Bitfield(u16, 12, 4),
-    raw: u16,
-};