paoda
/
zba
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat: document mode 0

This commit is contained in:
Rekai Nyangadzayi Musuka 2022-02-16 02:49:36 -04:00
parent 5835b509e4
commit d2d4667f7b
2 changed files with 44 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/bus/io.zig
View File

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

62
src/ppu.zig
View File

@ -71,45 +71,60 @@ pub const Ppu = struct {
switch (bg_mode) { switch (bg_mode) {
0x0 => { 0x0 => {
// A Tile is always 8x8 pixels // TODO: Consider more than BG0
// TODO: Consider Scrolling
// Mode 0 Implementation Assuming: // The Current Scanline which will be copied into
// - Scrolling isn't a thing // the Framebuffer
// - Bill Gates said we'll never need more than BG0
// Write to this Scanline once we're done
const start = framebuf_pitch * @as(usize, scanline); const start = framebuf_pitch * @as(usize, scanline);
var scanline_buf = std.mem.zeroes([framebuf_pitch]u8); var scanline_buf = std.mem.zeroes([framebuf_pitch]u8);
// These we can probably move to top level? // A Tile in a charblock is a byte, while a Screen Entry is a halfword
const charblock_len: u32 = 0x4000; const charblock_len: u32 = 0x4000;
const screenblock_len: u32 = 0x800; const screenblock_len: u32 = 0x800;
const cbb: u2 = self.bg0.cnt.char_base.read(); // Char Block Base 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 sbb: u5 = self.bg0.cnt.screen_base.read(); // Screen Block Base
const is_8bpp: bool = self.bg0.cnt.palette_type.read(); // Colour Mode const is_8bpp: bool = self.bg0.cnt.colour_mode.read(); // Colour Mode
const size: u2 = self.bg0.cnt.screen_size.read(); // Background Size 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 // 0x0600_000 is implied because we can access VRAM without the Bus
const char_base: u32 = charblock_len * @as(u32, cbb); const char_base: u32 = charblock_len * @as(u32, cbb);
const screen_base: u32 = screenblock_len * @as(u32, sbb); const screen_base: u32 = screenblock_len * @as(u32, sbb);
const y = @as(u32, scanline); const y = @as(u32, scanline);
var x: u32 = 0; var x: u32 = 0;
while (x < width) : (x += 1) { while (x < width) : (x += 1) {
const entry_addr = screen_base + tilemapIndex(size, x, y); // 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])); 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 tile_id: u32 = entry.tile_id.read();
const px_y = if (entry.h_flip.read()) 7 - (y % 8) else y % 8; const row = if (entry.h_flip.read()) 7 - (y % 8) else y % 8; // Determine on which row in a tile we're on
const px_x = if (entry.v_flip.read()) 7 - (x % 8) else x % 8; const tile_addr = char_base + (tile_len * tile_id) + (tile_row_offset * row);
const tile_addr = char_base + if (is_8bpp) 0x40 * tile_id + 0x8 * px_y else 0x20 * tile_id + 0x4 * px_y;
var tile = self.vram.buf[tile_addr + if (is_8bpp) px_x else px_x >> 1]; // Calculate on which column in a tile we're on
tile = if (px_x & 1 == 1) tile >> 4 else tile & 0xF; // 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];
const pal_bank: u8 = @as(u8, entry.palette_bank.read()) << 4; // If we're in 8bpp, then the tile value is an index into the palette,
const colour = pal_bank | tile; // 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, scanline_buf[x * 2 ..][0..2], self.palette.buf[colour * 2 ..][0..2]);
} }
@ -140,11 +155,16 @@ pub const Ppu = struct {
} }
} }
fn tilemapIndex(size: u2, x: u32, y: u32) u32 { 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) { return switch (size) {
0 => (((y % 256) / 8) * 64) + (((x % 256) / 8) * 2), 0 => (y % 256 / 8) * 0x40 + (x % 256 / 8) * 2, // 256 x 256
1 => (((y % 256) / 8) * 64) + (((x % 256) / 8) * 2), 1 => (y % 512 / 8) * 0x40 + (x % 256 / 8) * 2, // 512 x 256
else => std.debug.panic("tile size {}", .{size}), 2 => (y % 256 / 8) * 0x40 + (x % 512 / 8) * 2, // 256 x 512
3 => (y % 512 / 8) * 0x40 + (x % 512 / 8) * 2, // 512 x 512
}; };
} }
}; };