const std = @import("std"); const io = @import("bus/io.zig"); const util = @import("../util.zig"); const Bit = @import("bitfield").Bit; const Bitfield = @import("bitfield").Bitfield; const dma = @import("bus/dma.zig"); const Oam = @import("ppu/Oam.zig"); const Palette = @import("ppu/Palette.zig"); const Vram = @import("ppu/Vram.zig"); const Scheduler = @import("scheduler.zig").Scheduler; const Arm7tdmi = @import("cpu.zig").Arm7tdmi; const FrameBuffer = @import("../util.zig").FrameBuffer; const Allocator = std.mem.Allocator; const log = std.log.scoped(.PPU); const getHalf = util.getHalf; const setHalf = util.setHalf; const setQuart = util.setQuart; pub const width = 240; pub const height = 160; pub const framebuf_pitch = width * @sizeOf(u32); pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T { const byte_addr = @truncate(u8, addr); return switch (T) { u32 => switch (byte_addr) { 0x00 => ppu.dispcnt.raw, // Green Swap is in high half-word 0x04 => @as(T, ppu.vcount.raw) << 16 | ppu.dispstat.raw, 0x08 => @as(T, ppu.bg[1].bg1Cnt()) << 16 | ppu.bg[0].bg0Cnt(), 0x0C => @as(T, ppu.bg[3].cnt.raw) << 16 | ppu.bg[2].cnt.raw, 0x10, 0x14, 0x18, 0x1C => null, // BGXHOFS/VOFS 0x20, 0x24, 0x28, 0x2C => null, // BG2 Rot/Scaling 0x30, 0x34, 0x38, 0x3C => null, // BG3 Rot/Scaling 0x40, 0x44 => null, // WINXH/V Registers 0x48 => @as(T, ppu.win.getOut()) << 16 | ppu.win.getIn(), 0x4C => null, // MOSAIC, undefined in high byte 0x50 => @as(T, ppu.bld.getAlpha()) << 16 | ppu.bld.getCnt(), 0x54 => null, // BLDY, undefined in high half-wrd else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }), }, u16 => switch (byte_addr) { 0x00 => ppu.dispcnt.raw, 0x02 => null, // Green Swap 0x04 => ppu.dispstat.raw, 0x06 => ppu.vcount.raw, 0x08 => ppu.bg[0].bg0Cnt(), 0x0A => ppu.bg[1].bg1Cnt(), 0x0C => ppu.bg[2].cnt.raw, 0x0E => ppu.bg[3].cnt.raw, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E => null, // BGXHOFS/VOFS 0x20, 0x22, 0x24, 0x26, 0x28, 0x2A, 0x2C, 0x2E => null, // BG2 Rot/Scaling 0x30, 0x32, 0x34, 0x36, 0x38, 0x3A, 0x3C, 0x3E => null, // BG3 Rot/Scaling 0x40, 0x42, 0x44, 0x46 => null, // WINXH/V Registers 0x48 => ppu.win.getIn(), 0x4A => ppu.win.getOut(), 0x4C => null, // MOSAIC 0x4E => null, 0x50 => ppu.bld.getCnt(), 0x52 => ppu.bld.getAlpha(), 0x54 => null, // BLDY else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }), }, u8 => switch (byte_addr) { 0x00, 0x01 => @truncate(T, ppu.dispcnt.raw >> getHalf(byte_addr)), 0x02, 0x03 => null, 0x04, 0x05 => @truncate(T, ppu.dispstat.raw >> getHalf(byte_addr)), 0x06, 0x07 => @truncate(T, ppu.vcount.raw >> getHalf(byte_addr)), 0x08, 0x09 => @truncate(T, ppu.bg[0].bg0Cnt() >> getHalf(byte_addr)), 0x0A, 0x0B => @truncate(T, ppu.bg[1].bg1Cnt() >> getHalf(byte_addr)), 0x0C, 0x0D => @truncate(T, ppu.bg[2].cnt.raw >> getHalf(byte_addr)), 0x0E, 0x0F => @truncate(T, ppu.bg[3].cnt.raw >> getHalf(byte_addr)), 0x10...0x1F => null, // BGXHOFS/VOFS 0x20...0x2F => null, // BG2 Rot/Scaling 0x30...0x3F => null, // BG3 Rot/Scaling 0x40...0x47 => null, // WINXH/V Registers 0x48, 0x49 => @truncate(T, ppu.win.getIn() >> getHalf(byte_addr)), 0x4A, 0x4B => @truncate(T, ppu.win.getOut() >> getHalf(byte_addr)), 0x4C, 0x4D => null, // MOSAIC 0x4E, 0x4F => null, 0x50, 0x51 => @truncate(T, ppu.bld.getCnt() >> getHalf(byte_addr)), 0x52, 0x53 => @truncate(T, ppu.bld.getAlpha() >> getHalf(byte_addr)), 0x54, 0x55 => null, // BLDY else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }), }, else => @compileError("PPU: Unsupported read width"), }; } pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void { const byte_addr = @truncate(u8, addr); // prefixed with 0x0400_00 switch (T) { u32 => switch (byte_addr) { 0x00 => ppu.dispcnt.raw = @truncate(u16, value), 0x04 => { ppu.dispstat.set(@truncate(u16, value)); ppu.vcount.raw = @truncate(u16, value >> 16); }, 0x08 => ppu.setAdjCnts(0, value), 0x0C => ppu.setAdjCnts(2, value), 0x10 => ppu.setBgOffsets(0, value), 0x14 => ppu.setBgOffsets(1, value), 0x18 => ppu.setBgOffsets(2, value), 0x1C => ppu.setBgOffsets(3, value), 0x20 => ppu.aff_bg[0].writePaPb(value), 0x24 => ppu.aff_bg[0].writePcPd(value), 0x28 => ppu.aff_bg[0].setX(ppu.dispstat.vblank.read(), value), 0x2C => ppu.aff_bg[0].setY(ppu.dispstat.vblank.read(), value), 0x30 => ppu.aff_bg[1].writePaPb(value), 0x34 => ppu.aff_bg[1].writePcPd(value), 0x38 => ppu.aff_bg[1].setX(ppu.dispstat.vblank.read(), value), 0x3C => ppu.aff_bg[1].setY(ppu.dispstat.vblank.read(), value), 0x40 => ppu.win.setH(value), 0x44 => ppu.win.setV(value), 0x48 => ppu.win.setIo(value), 0x4C => log.debug("Wrote 0x{X:0>8} to MOSAIC", .{value}), 0x50 => { ppu.bld.cnt.raw = @truncate(u16, value); ppu.bld.alpha.raw = @truncate(u16, value >> 16); }, 0x54 => ppu.bld.y.raw = @truncate(u16, value), else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }), }, u16 => switch (byte_addr) { 0x00 => ppu.dispcnt.raw = value, 0x02 => {}, // Green Swap 0x04 => ppu.dispstat.set(value), 0x06 => {}, // VCOUNT 0x08 => ppu.bg[0].cnt.raw = value, 0x0A => ppu.bg[1].cnt.raw = value, 0x0C => ppu.bg[2].cnt.raw = value, 0x0E => ppu.bg[3].cnt.raw = value, 0x10 => ppu.bg[0].hofs.raw = value, // TODO: Don't write out every HOFS / VOFS? 0x12 => ppu.bg[0].vofs.raw = value, 0x14 => ppu.bg[1].hofs.raw = value, 0x16 => ppu.bg[1].vofs.raw = value, 0x18 => ppu.bg[2].hofs.raw = value, 0x1A => ppu.bg[2].vofs.raw = value, 0x1C => ppu.bg[3].hofs.raw = value, 0x1E => ppu.bg[3].vofs.raw = value, 0x20 => ppu.aff_bg[0].pa = @bitCast(i16, value), 0x22 => ppu.aff_bg[0].pb = @bitCast(i16, value), 0x24 => ppu.aff_bg[0].pc = @bitCast(i16, value), 0x26 => ppu.aff_bg[0].pd = @bitCast(i16, value), 0x28, 0x2A => ppu.aff_bg[0].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)), 0x2C, 0x2E => ppu.aff_bg[0].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)), 0x30 => ppu.aff_bg[1].pa = @bitCast(i16, value), 0x32 => ppu.aff_bg[1].pb = @bitCast(i16, value), 0x34 => ppu.aff_bg[1].pc = @bitCast(i16, value), 0x36 => ppu.aff_bg[1].pd = @bitCast(i16, value), 0x38, 0x3A => ppu.aff_bg[1].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)), 0x3C, 0x3E => ppu.aff_bg[1].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)), 0x40 => ppu.win.h[0].raw = value, 0x42 => ppu.win.h[1].raw = value, 0x44 => ppu.win.v[0].raw = value, 0x46 => ppu.win.v[1].raw = value, 0x48 => ppu.win.in.raw = value, 0x4A => ppu.win.out.raw = value, 0x4C => log.debug("Wrote 0x{X:0>4} to MOSAIC", .{value}), 0x4E => {}, 0x50 => ppu.bld.cnt.raw = value, 0x52 => ppu.bld.alpha.raw = value, 0x54 => ppu.bld.y.raw = value, else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, addr }), }, u8 => switch (byte_addr) { 0x00, 0x01 => ppu.dispcnt.raw = setHalf(u16, ppu.dispcnt.raw, byte_addr, value), 0x02, 0x03 => {}, // Green Swap 0x04, 0x05 => ppu.dispstat.set(setHalf(u16, ppu.dispstat.raw, byte_addr, value)), 0x06, 0x07 => {}, // VCOUNT // BGXCNT 0x08, 0x09 => ppu.bg[0].cnt.raw = setHalf(u16, ppu.bg[0].cnt.raw, byte_addr, value), 0x0A, 0x0B => ppu.bg[1].cnt.raw = setHalf(u16, ppu.bg[1].cnt.raw, byte_addr, value), 0x0C, 0x0D => ppu.bg[2].cnt.raw = setHalf(u16, ppu.bg[2].cnt.raw, byte_addr, value), 0x0E, 0x0F => ppu.bg[3].cnt.raw = setHalf(u16, ppu.bg[3].cnt.raw, byte_addr, value), // BGX HOFS/VOFS 0x10, 0x11 => ppu.bg[0].hofs.raw = setHalf(u16, ppu.bg[0].hofs.raw, byte_addr, value), 0x12, 0x13 => ppu.bg[0].vofs.raw = setHalf(u16, ppu.bg[0].vofs.raw, byte_addr, value), 0x14, 0x15 => ppu.bg[1].hofs.raw = setHalf(u16, ppu.bg[1].hofs.raw, byte_addr, value), 0x16, 0x17 => ppu.bg[1].vofs.raw = setHalf(u16, ppu.bg[1].vofs.raw, byte_addr, value), 0x18, 0x19 => ppu.bg[2].hofs.raw = setHalf(u16, ppu.bg[2].hofs.raw, byte_addr, value), 0x1A, 0x1B => ppu.bg[2].vofs.raw = setHalf(u16, ppu.bg[2].vofs.raw, byte_addr, value), 0x1C, 0x1D => ppu.bg[3].hofs.raw = setHalf(u16, ppu.bg[3].hofs.raw, byte_addr, value), 0x1E, 0x1F => ppu.bg[3].vofs.raw = setHalf(u16, ppu.bg[3].vofs.raw, byte_addr, value), // BG2 Rot/Scaling 0x20, 0x21 => ppu.aff_bg[0].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pa), byte_addr, value)), 0x22, 0x23 => ppu.aff_bg[0].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pb), byte_addr, value)), 0x24, 0x25 => ppu.aff_bg[0].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pc), byte_addr, value)), 0x26, 0x27 => ppu.aff_bg[0].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pd), byte_addr, value)), 0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)), 0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)), // BG3 Rot/Scaling 0x30, 0x31 => ppu.aff_bg[1].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pa), byte_addr, value)), 0x32, 0x33 => ppu.aff_bg[1].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pb), byte_addr, value)), 0x34, 0x35 => ppu.aff_bg[1].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pc), byte_addr, value)), 0x36, 0x37 => ppu.aff_bg[1].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pd), byte_addr, value)), 0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)), 0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)), // Window 0x40, 0x41 => ppu.win.h[0].raw = setHalf(u16, ppu.win.h[0].raw, byte_addr, value), 0x42, 0x43 => ppu.win.h[1].raw = setHalf(u16, ppu.win.h[1].raw, byte_addr, value), 0x44, 0x45 => ppu.win.v[0].raw = setHalf(u16, ppu.win.v[0].raw, byte_addr, value), 0x46, 0x47 => ppu.win.v[1].raw = setHalf(u16, ppu.win.v[1].raw, byte_addr, value), 0x48, 0x49 => ppu.win.in.raw = setHalf(u16, ppu.win.in.raw, byte_addr, value), 0x4A, 0x4B => ppu.win.out.raw = setHalf(u16, ppu.win.out.raw, byte_addr, value), 0x4C, 0x4D => log.debug("Wrote 0x{X:0>2} to MOSAIC", .{value}), 0x4E, 0x4F => {}, // Blending 0x50, 0x51 => ppu.bld.cnt.raw = setHalf(u16, ppu.bld.cnt.raw, byte_addr, value), 0x52, 0x53 => ppu.bld.alpha.raw = setHalf(u16, ppu.bld.alpha.raw, byte_addr, value), 0x54, 0x55 => ppu.bld.y.raw = setHalf(u16, ppu.bld.y.raw, byte_addr, value), else => util.io.write.undef(log, "Tried to write 0x{X:0>2}{} to 0x{X:0>8}", .{ value, T, addr }), }, else => @compileError("PPU: Unsupported write width"), } } pub const Ppu = struct { const Self = @This(); // Registers win: Window, bg: [4]Background, aff_bg: [2]AffineBackground, dispcnt: io.DisplayControl, dispstat: io.DisplayStatus, vcount: io.VCount, bld: Blend, vram: Vram, palette: Palette, oam: Oam, sched: *Scheduler, framebuf: FrameBuffer, allocator: Allocator, scanline_sprites: *[128]?Sprite, scanline: Scanline, pub fn init(allocator: Allocator, sched: *Scheduler) !Self { sched.push(.Draw, 240 * 4); // Add first PPU Event to Scheduler const sprites = try allocator.create([128]?Sprite); std.mem.set(?Sprite, sprites, null); return Self{ .vram = try Vram.init(allocator), .palette = try Palette.init(allocator), .oam = try Oam.init(allocator), .sched = sched, .framebuf = try FrameBuffer.init(allocator, framebuf_pitch * height), .allocator = allocator, // Registers .win = Window.init(), .bg = [_]Background{Background.init()} ** 4, .aff_bg = [_]AffineBackground{AffineBackground.init()} ** 2, .bld = Blend.create(), .dispcnt = .{ .raw = 0x0000 }, .dispstat = .{ .raw = 0x0000 }, .vcount = .{ .raw = 0x0000 }, .scanline = try Scanline.init(allocator), .scanline_sprites = sprites, }; } pub fn deinit(self: *Self) void { self.allocator.destroy(self.scanline_sprites); self.framebuf.deinit(); self.scanline.deinit(); self.vram.deinit(); self.palette.deinit(); self.oam.deinit(); self.* = undefined; } pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void { self.bg[n].hofs.raw = @truncate(u16, word); self.bg[n].vofs.raw = @truncate(u16, word >> 16); } pub fn setAdjCnts(self: *Self, comptime n: u2, word: u32) void { self.bg[n].cnt.raw = @truncate(u16, word); self.bg[n + 1].cnt.raw = @truncate(u16, word >> 16); } /// Search OAM for Sprites that might be rendered on this scanline fn fetchSprites(self: *Self) void { const y = self.vcount.scanline.read(); var i: usize = 0; search: while (i < self.oam.buf.len) : (i += 8) { // Attributes in OAM are 6 bytes long, with 2 bytes of padding // Grab Attributes from OAM const attr0 = @bitCast(Attr0, self.oam.read(u16, i)); // Only consider enabled Sprites if (attr0.is_affine.read() or !attr0.disabled.read()) { const attr1 = @bitCast(Attr1, self.oam.read(u16, i + 2)); const d = spriteDimensions(attr0.shape.read(), attr1.size.read()); // Account for double-size affine sprites const sprite_height = d[1] << blk: { if (!attr0.is_affine.read()) break :blk 0; const aff_attr0: AffineAttr0 = .{ .raw = attr0.raw }; break :blk if (aff_attr0.double_size.read()) 1 else 0; }; // When fetching sprites we only care about ones that could be rendered // on this scanline var y_pos: i32 = attr0.y.read(); if (y_pos >= 160) y_pos -= 256; // fleroviux's solution to negative positions // Sprites are expected to be able to wraparound, we perform the same check // for unsigned and signed values so that we handle all valid sprite positions // FIXME: Wrapping for Double-Size Sprites is not properly implemented if (y_pos <= y and y < (y_pos + sprite_height)) { for (self.scanline_sprites) |*maybe_sprite| { if (maybe_sprite.* == null) { maybe_sprite.* = Sprite.init(attr0, attr1, @bitCast(Attr2, self.oam.read(u16, i + 4))); continue :search; } } log.err("Found more than 128 sprites in OAM Search", .{}); unreachable; // TODO: Is this truly unreachable? } } } } fn drawSprites(self: *Self, layer: u2) void { // Loop over every fetched sprite for (self.scanline_sprites) |maybe_sprite| { if (maybe_sprite) |sprite| { // Skip this sprite if it isn't on the current priority if (sprite.priority() != layer) continue; if (sprite.attr0.is_affine.read()) self.drawAffineSprite(AffineSprite.from(sprite)) else self.drawSprite(sprite); } else break; } } fn drawAffineSprite(self: *Self, sprite: AffineSprite) void { const is_8bpp = sprite.is8bpp(); const tile_id: u32 = sprite.tileId(); const obj_mapping = self.dispcnt.obj_mapping.read(); const tile_row_offset: u32 = if (is_8bpp) 8 else 4; const tile_len: u32 = if (is_8bpp) 0x40 else 0x20; const double_size = sprite.attr0.double_size.read(); const char_base = 0x4000 * 4; const y = self.vcount.scanline.read(); var sprite_x: i16 = sprite.x(); if (sprite_x >= 240) sprite_x -= 512; var sprite_y: i16 = sprite.y(); if (sprite_y >= 160) sprite_y -= 256; const base = 32 * @as(u32, sprite.matrixId()); const pa = self.oam.read(u16, base + 3 * @sizeOf(u16)); const pb = self.oam.read(u16, base + 7 * @sizeOf(u16)); const pc = self.oam.read(u16, base + 11 * @sizeOf(u16)); const pd = self.oam.read(u16, base + 15 * @sizeOf(u16)); const matrix = @bitCast([4]i16, [_]u16{ pa, pb, pc, pd }); const sprite_width = sprite.width << if (double_size) 1 else 0; const sprite_height = sprite.height << if (double_size) 1 else 0; const half_width = sprite_width >> 1; const half_height = sprite_height >> 1; var i: u9 = 0; while (i < sprite_width) : (i += 1) { // TODO: Something is wrong here const x = @truncate(u9, @bitCast(u16, sprite_x + i)); if (x >= width) continue; if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue; // Check to see if sprite pixel is in bounds // TODO: Are any of the checks here redundant? if (sprite_x > x and x >= (sprite_x + sprite.width)) continue; // Sprite is within bounds and therefore should be rendered const local_x = @as(i16, x) - sprite_x; const local_y = @as(i16, y) - sprite_y; var rot_x = ((matrix[0] *% (local_x - half_width) +% matrix[1] *% (local_y - half_width)) >> 8); var rot_y = ((matrix[2] *% (local_x - half_width) +% matrix[3] *% (local_y - half_width)) >> 8); rot_x +%= half_width >> if (double_size) 1 else 0; rot_y +%= half_height >> if (double_size) 1 else 0; // Maybe this is the necessary check? if (rot_x >= sprite.width or rot_y >= sprite.height or rot_x < 0 or rot_y < 0) continue; const tile_x = @bitCast(u16, rot_x); const tile_y = @bitCast(u16, rot_y); const col = @truncate(u3, tile_x); const row = @truncate(u3, tile_y); // TODO: Finish that 2D Sprites Test ROM const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1; const mapping_offset = if (obj_mapping) sprite.width >> 3 else if (is_8bpp) @as(u32, 0x10) else 0x20; const tile_offset = (tile_x >> 3) * tile_len + (tile_y >> 3) * tile_len * mapping_offset; const tile = self.vram.buf[tile_base + tile_offset]; const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile; const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x)); // Sprite Palette starts at 0x0500_0200 if (pal_id != 0) { const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2); drawSpritePixel(self.bld.cnt, &self.scanline, @bitCast(Attr0, sprite.attr0), global_x, bgr555); } } } fn drawSprite(self: *Self, sprite: Sprite) void { const is_8bpp = sprite.is8bpp(); const tile_id: u32 = sprite.tileId(); const obj_mapping = self.dispcnt.obj_mapping.read(); const tile_row_offset: u32 = if (is_8bpp) 8 else 4; const tile_len: u32 = if (is_8bpp) 0x40 else 0x20; const char_base = 0x4000 * 4; const y = self.vcount.scanline.read(); var sprite_x: i16 = sprite.x(); if (sprite_x >= 240) sprite_x -= 512; var sprite_y: i16 = sprite.y(); if (sprite_y >= 160) sprite_y -= 256; var i: u9 = 0; while (i < sprite.width) : (i += 1) { // TODO: Something is Wrong Here const x = @truncate(u9, @bitCast(u16, sprite_x + i)); if (x >= width) continue; if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue; if (sprite_x > x and x >= (sprite_x + sprite.width)) continue; // Sprite is within bounds and therefore should be rendered const local_x = @as(i16, x) - sprite_x; const local_y = @as(i16, y) - sprite_y; // Note that we flip the tile_pos not the (tile_pos % 8) like we do for // Background Tiles. By doing this we mirror the entire sprite instead of // just a specific tile (see how sprite.width and sprite.height are involved) const tile_x = @intCast(u9, local_x) ^ if (sprite.hFlip()) (sprite.width - 1) else 0; const tile_y = @intCast(u8, local_y) ^ if (sprite.vFlip()) (sprite.height - 1) else 0; const col = @truncate(u3, tile_x); const row = @truncate(u3, tile_y); // TODO: Finish that 2D Sprites Test ROM const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1; const mapping_offset = if (obj_mapping) sprite.width >> 3 else if (is_8bpp) @as(u32, 0x10) else 0x20; const tile_offset = (tile_x >> 3) * tile_len + (tile_y >> 3) * tile_len * mapping_offset; const tile = self.vram.buf[tile_base + tile_offset]; const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile; const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x)); // Sprite Palette starts at 0x0500_0200 if (pal_id != 0) { const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2); drawSpritePixel(self.bld.cnt, &self.scanline, sprite.attr0, global_x, bgr555); } } } fn drawAffineBackground(self: *Self, comptime n: u2) void { comptime std.debug.assert(n == 2 or n == 3); // Only BG2 and BG3 can be affine const char_base = @as(u32, 0x4000) * self.bg[n].cnt.char_base.read(); const screen_base = @as(u32, 0x800) * self.bg[n].cnt.screen_base.read(); const size: u2 = self.bg[n].cnt.size.read(); const tile_width = @as(i32, 0x10) << size; const px_width = tile_width << 3; const px_height = px_width; var aff_x = self.aff_bg[n - 2].x_latch.?; var aff_y = self.aff_bg[n - 2].y_latch.?; var i: u32 = 0; while (i < width) : (i += 1) { var ix = aff_x >> 8; var iy = aff_y >> 8; aff_x += self.aff_bg[n - 2].pa; aff_y += self.aff_bg[n - 2].pc; const _x = @truncate(u9, @bitCast(u32, ix)); const _y = @truncate(u8, @bitCast(u32, iy)); const win_bounds = self.windowBounds(_x, _y); if (!shouldDrawBackground(self, n, win_bounds, i)) continue; if (self.bg[n].cnt.display_overflow.read()) { ix = if (ix > px_width) @rem(ix, px_width) else if (ix < 0) px_width + @rem(ix, px_width) else ix; iy = if (iy > px_height) @rem(iy, px_height) else if (iy < 0) px_height + @rem(iy, px_height) else iy; } else if (ix > px_width or iy > px_height or ix < 0 or iy < 0) continue; const x = @bitCast(u32, ix); const y = @bitCast(u32, iy); const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @bitCast(u32, tile_width) + (x / 8))); const row = y & 7; const col = x & 7; const tile_addr = char_base + (tile_id * 0x40) + (row * 0x8) + col; const pal_id: u16 = self.vram.buf[tile_addr]; if (pal_id != 0) self.drawBackgroundPixel(n, i, self.palette.read(u16, pal_id * 2)); } // Update BGxX and BGxY self.aff_bg[n - 2].x_latch.? += self.aff_bg[n - 2].pb; // PB is added to BGxX self.aff_bg[n - 2].y_latch.? += self.aff_bg[n - 2].pd; // PD is added to BGxY } fn drawBackground(self: *Self, comptime n: u2) void { // A Tile in a charblock is a byte, while a Screen Entry is a halfword const char_base = 0x4000 * @as(u32, self.bg[n].cnt.char_base.read()); const screen_base = 0x800 * @as(u32, self.bg[n].cnt.screen_base.read()); const is_8bpp: bool = self.bg[n].cnt.colour_mode.read(); // Colour Mode const size: u2 = self.bg[n].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; const vofs: u32 = self.bg[n].vofs.offset.read(); const hofs: u32 = self.bg[n].hofs.offset.read(); const y = vofs + self.vcount.scanline.read(); var i: u32 = 0; while (i < width) : (i += 1) { const x = hofs + i; const win_bounds = self.windowBounds(@truncate(u9, x), @truncate(u8, y)); if (!shouldDrawBackground(self, n, win_bounds, i)) continue; // Grab the Screen Entry from VRAM const entry_addr = screen_base + tilemapOffset(size, x, y); const entry = @bitCast(ScreenEntry, self.vram.read(u16, 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(); // Calculate row and column offsets. Understand that // `tile_len`, `tile_row_offset` and `col` are subject to different // values depending on whether we are in 4bpp or 8bpp mode. const row = @truncate(u3, y) ^ if (entry.v_flip.read()) 7 else @as(u3, 0); const col = @truncate(u3, x) ^ if (entry.h_flip.read()) 7 else @as(u3, 0); const tile_addr = char_base + (tile_id * tile_len) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1; const tile = self.vram.buf[tile_addr]; // 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 pal_id: u16 = if (!is_8bpp) get4bppTilePalette(entry.pal_bank.read(), col, tile) else tile; if (pal_id != 0) self.drawBackgroundPixel(n, i, self.palette.read(u16, pal_id * 2)); } } inline fn get4bppTilePalette(pal_bank: u4, col: u3, tile: u8) u8 { const nybble_tile = tile >> ((col & 1) << 2) & 0xF; if (nybble_tile == 0) return 0; return (@as(u8, pal_bank) << 4) | nybble_tile; } pub fn drawScanline(self: *Self) void { const bg_mode = self.dispcnt.bg_mode.read(); const bg_enable = self.dispcnt.bg_enable.read(); const obj_enable = self.dispcnt.obj_enable.read(); const scanline = self.vcount.scanline.read(); switch (bg_mode) { 0x0 => { const framebuf_base = width * @as(usize, scanline); if (obj_enable) self.fetchSprites(); var layer: usize = 0; while (layer < 4) : (layer += 1) { self.drawSprites(@truncate(u2, layer)); if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0); if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1); if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawBackground(2); if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawBackground(3); } self.drawTextMode(framebuf_base); }, 0x1 => { const framebuf_base = width * @as(usize, scanline); if (obj_enable) self.fetchSprites(); var layer: usize = 0; while (layer < 4) : (layer += 1) { self.drawSprites(@truncate(u2, layer)); if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0); if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1); if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2); } self.drawTextMode(framebuf_base); }, 0x2 => { const framebuf_base = width * @as(usize, scanline); if (obj_enable) self.fetchSprites(); var layer: usize = 0; while (layer < 4) : (layer += 1) { self.drawSprites(@truncate(u2, layer)); if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2); if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawAffineBackground(3); } self.drawTextMode(framebuf_base); }, 0x3 => { const vram_base = width * @as(usize, scanline); const framebuf_base = width * @as(usize, scanline); // FIXME: @ptrCast between slices changing the length isn't implemented yet const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf)); const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); for (vram_buf[vram_base .. vram_base + width]) |bgr555, i| { framebuf[framebuf_base + i] = rgba888(bgr555); } }, 0x4 => { const sel = self.dispcnt.frame_select.read(); const vram_base = width * @as(usize, scanline) + if (sel) 0xA000 else @as(usize, 0); const framebuf_base = width * @as(usize, scanline); // FIXME: @ptrCast between slices changing the length isn't implemented yet const pal_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.palette.buf)); const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); for (self.vram.buf[vram_base .. vram_base + width]) |pal_id, i| { framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]); } }, 0x5 => { const m5_width = 160; const m5_height = 128; const sel = self.dispcnt.frame_select.read(); const vram_base = m5_width * @as(usize, scanline) + if (sel) 0xA000 else @as(usize, 0); const framebuf_base = width * @as(usize, scanline); // FIXME: @ptrCast between slices changing the length isn't implemented yet const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf)); const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); var i: usize = 0; while (i < width) : (i += 1) { const bgr555 = if (scanline < m5_height and i < m5_width) vram_buf[vram_base + i] else self.palette.backdrop(); framebuf[framebuf_base + i] = rgba888(bgr555); } }, else => std.debug.panic("[PPU] TODO: Implement BG Mode {}", .{bg_mode}), } } fn drawTextMode(self: *Self, framebuf_base: usize) void { // Copy Drawn Scanline to Frame Buffer // If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop // FIXME: @ptrCast between slices changing the length isn't implemented yet const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator))); for (self.scanline.top()) |maybe_top, i| { const maybe_btm = self.scanline.btm()[i]; const bgr555 = self.getBgr555(maybe_top, maybe_btm); framebuf[framebuf_base + i] = rgba888(bgr555); } // Reset Current Scanline Pixel Buffer and list of fetched sprites // in prep for next scanline self.scanline.reset(); std.mem.set(?Sprite, self.scanline_sprites, null); } fn getBgr555(self: *Self, maybe_top: Scanline.Pixel, maybe_btm: Scanline.Pixel) u16 { return switch (self.bld.cnt.mode.read()) { 0b00 => switch (maybe_top) { .set, .obj_set => |top| top, else => self.palette.backdrop(), }, 0b01 => switch (maybe_top) { .set, .obj_set => |top| switch (maybe_btm) { .set, .obj_set => |btm| alphaBlend(top, btm, self.bld.alpha), // ALPHA_BLEND else => top, }, else => switch (maybe_btm) { .set, .obj_set => |btm| btm, else => self.palette.backdrop(), }, }, 0b10 => switch (maybe_btm) { .set, .obj_set => |btm| blk: { // If there's a top pixel + this btm pixel came from a sprite // don't display top pixel + don't blend btm pixel if (maybe_btm == .obj_set and maybe_top.isSet()) break :blk btm; // BLD_WHITE const evy: u16 = self.bld.y.evy.read(); const r = btm & 0x1F; const g = (btm >> 5) & 0x1F; const b = (btm >> 10) & 0x1F; const bld_r = r + (((31 - r) * evy) >> 4); const bld_g = g + (((31 - g) * evy) >> 4); const bld_b = b + (((31 - b) * evy) >> 4); break :blk (bld_b << 10) | (bld_g << 5) | bld_r; }, else => switch (maybe_top) { .set, .obj_set => |top| top, else => self.palette.backdrop(), }, }, 0b11 => switch (maybe_btm) { .set, .obj_set => |btm| blk: { // If there's a top pixel + this btm pixel came from a sprite // don't display top pixel + don't blend btm pixel if (maybe_btm == .obj_set and maybe_top.isSet()) break :blk btm; // BLD_BLACK const evy: u16 = self.bld.y.evy.read(); const r = btm & 0x1F; const g = (btm >> 5) & 0x1F; const b = (btm >> 10) & 0x1F; const bld_r = r - ((r * evy) >> 4); const bld_g = g - ((g * evy) >> 4); const bld_b = b - ((b * evy) >> 4); break :blk (bld_b << 10) | (bld_g << 5) | bld_r; }, else => switch (maybe_top) { .set, .obj_set => |top| top, else => self.palette.backdrop(), }, }, }; } fn drawBackgroundPixel(self: *Self, comptime layer: u2, i: usize, bgr555: u16) void { // When writing to the scanline buffer, we want to be aware of a top and bottom layer. Some preconditions were // already determined by shouldDrawBackground, so we should be aware of what we can assume to be true or false switch (self.bld.cnt.mode.read()) { 0b00 => {}, // pass through 0b01 => { // We are to alpha blend here so we should pay attention to which layer ths pixel should be written to // FIXME: We redo work here that we've already figured out. Is this worth refactorning? // If the current layer is makred as Layer A, write to top buffer const top_layer = self.bld.cnt.layer_a.read(); const is_top_layer = (top_layer >> layer) & 1 == 1; if (is_top_layer) { self.scanline.top()[i] = Scanline.Pixel.from(.Background, bgr555); return; } // If the current layer is marked as Layer B, we want to continue if there's an available space on that buffer const btm_layer = self.bld.cnt.layer_b.read(); const is_btm_layer = (btm_layer >> layer) & 1 == 1; if (is_btm_layer) { self.scanline.btm()[i] = Scanline.Pixel.from(.Background, bgr555); return; } // The code we're about to fall-through to assumes that alpha blending takes place. In order to withold all invariants // we need to discard anything that might be in the bottom buffer. self.scanline.btm()[i] = .hidden; }, 0b10, 0b11 => { // BLD_WHITE, BLD_BLACK // Weare to blend with White or black here. By convention we store regular ol' pixels in the top layer, which means that if we want to // treat some pixels (in this case the ones relegated to blending) we need to keep them separate as we can't apply the blending to the top layer. // While in these modes, (and since this is a scanline renderer), the bottom layer will be completely unused. While it's a bit unintuitive, since we'll // be moving layer A pixels there, we will repurpose the bottom layer as the "to blend", layer // If the current layer is makred as Layer A, write to top buffer const top_layer = self.bld.cnt.layer_a.read(); const is_top_layer = (top_layer >> layer) & 1 == 1; if (is_top_layer) { const pixel = self.scanline.btm()[i]; // FIXME: Can't I do this check ealier? Test Amazing Mirror File Select, bld_demo.gba if (!pixel.isSet()) self.scanline.btm()[i] = Scanline.Pixel.from(.Background, bgr555); // this is intentional return; } }, } // If we aren't blending here at all, just add the pixel to the top layer self.scanline.top()[i] = Scanline.Pixel.from(.Background, bgr555); } const WindowBounds = enum { win0, win1, out }; fn windowBounds(self: *Self, x: u9, y: u8) ?WindowBounds { _ = y; _ = x; _ = self; // FIXME: Remove to enable PPU Window Emulation return null; // const win0 = self.dispcnt.win_enable.read() & 1 == 1; // const win1 = (self.dispcnt.win_enable.read() >> 1) & 1 == 1; // const winObj = self.dispcnt.obj_win_enable.read(); // if (!(win0 or win1 or winObj)) return null; // if (win0 and self.win.inRange(0, x, y)) return .win0; // if (win1 and self.win.inRange(1, x, y)) return .win1; // return .out; } fn shouldDrawBackground(self: *Self, comptime layer: u2, bounds: ?WindowBounds, i: usize) bool { switch (self.bld.cnt.mode.read()) { 0b00 => if (self.scanline.top()[i].isSet()) return false, // pass through 0b01 => blk: { // BLD_ALPHA // If the current layer is marked as Layer B, we want to continue if there's an available space on that buffer const btm_layer = self.bld.cnt.layer_b.read(); const is_btm_layer = (btm_layer >> layer) & 1 == 1; if (is_btm_layer) { if (self.scanline.btm()[i].isSet()) return false; // In some previous iteration we have determined that an opaque pixel was drawn at this position // therefore there's no reason to draw anything here if (self.scanline.btm()[i] == .hidden) return false; // We have a pixel and we know it to be a part of hte bottom layer. // when getBgr555 sees that thre's a pixel in the top and bottom layer it chooses to blend the two // Meaning that if we want to prevent Alpha Blending from happening (like for example if a window is preventing it) // we need to make that happen now. // We can do this by not drawing the bottom pixel, since with alpha blending disabled it wouldn't be visible anyways // if (bounds) |win| { // switch (win) { // .win0 => if (!self.win.in.w0_bld.read()) return false, // .win1 => if (!self.win.in.w1_bld.read()) return false, // .out => if (!self.win.out.out_bld.read()) return false, // } // } break :blk; } if (self.scanline.top()[i].isSet()) return false; }, 0b10, 0b11 => { // BLD_WHITE and BLD_BLACK // we want to treat the bottom layer the same as the top (despite it being repurposed) // so we should apply the same logic to the bottom layer if (self.scanline.top()[i].isSet()) return false; // If the bottom pixel comes rom a sprite, draw the pixel anyways if (self.scanline.btm()[i] == .set) return false; }, } // At this point we will have exited early if we determined that we'd be overwriting a pixel // with a higher priority. We can now move own to determining whether the pixel is visible or not // The first thing that may or may not affect visibility is windowing. We should check to see if ths pixel is in bounds // of of the background Window if it is enabled // TODO: Do Window Bounds checking here instead of outside this function? if (bounds) |window| { // If this parameter is non-null, we know that: // 1. Win0, Win1 or WinObj are enabled // 2. This specific pixel exists within the range of a window // Here, we check to see if the Window for this background is enabled. If not, we won't render the pixel // FIXME: We perform needless computations on Window Bounds by checking for enable here after we've already computed this information switch (window) { .win0 => if ((self.win.in.w0_bg.read() >> layer) & 1 == 0) return false, .win1 => if ((self.win.in.w1_bg.read() >> layer) & 1 == 0) return false, .out => if ((self.win.out.out_bg.read() >> layer) & 1 == 0) return false, } } // Otherwise, return true return true; } // TODO: Comment this + get a better understanding 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 @setRuntimeSafety(false); return switch (size) { 0 => (x % 256 / 8) * 2 + (y % 256 / 8) * 0x40, // 256 x 256 1 => blk: { // 512 x 256 const offset: u32 = if (x & 0x1FF > 0xFF) 0x800 else 0; break :blk offset + (x % 256 / 8) * 2 + (y % 256 / 8) * 0x40; }, 2 => blk: { // 256 x 512 const offset: u32 = if (y & 0x1FF > 0xFF) 0x800 else 0; break :blk offset + (x % 256 / 8) * 2 + (y % 256 / 8) * 0x40; }, 3 => blk: { // 512 x 512 const offset: u32 = if (x & 0x1FF > 0xFF) 0x800 else 0; const offset_2: u32 = if (y & 0x1FF > 0xFF) 0x800 else 0; break :blk offset + offset_2 + (x % 256 / 8) * 2 + (y % 512 / 8) * 0x40; }, }; } pub fn onHdrawEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void { // Transitioning to a Hblank if (self.dispstat.hblank_irq.read()) { cpu.bus.io.irq.hblank.set(); cpu.handleInterrupt(); } // See if HBlank DMA is present and not enabled if (!self.dispstat.vblank.read()) dma.onBlanking(cpu.bus, .HBlank); self.dispstat.hblank.set(); self.sched.push(.HBlank, 68 * 4 -| late); } pub fn onHblankEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void { // The End of a Hblank (During Draw or Vblank) const old_scanline = self.vcount.scanline.read(); const scanline = (old_scanline + 1) % 228; self.vcount.scanline.write(scanline); self.dispstat.hblank.unset(); // Perform Vc == VcT check const coincidence = scanline == self.dispstat.vcount_trigger.read(); self.dispstat.coincidence.write(coincidence); if (coincidence and self.dispstat.vcount_irq.read()) { cpu.bus.io.irq.coincidence.set(); cpu.handleInterrupt(); } if (scanline < 160) { // Transitioning to another Draw self.sched.push(.Draw, 240 * 4 -| late); } else { // Transitioning to a Vblank if (scanline == 160) { self.framebuf.swap(); // Swap FrameBuffers self.dispstat.vblank.set(); if (self.dispstat.vblank_irq.read()) { cpu.bus.io.irq.vblank.set(); cpu.handleInterrupt(); } self.aff_bg[0].latchRefPoints(); self.aff_bg[1].latchRefPoints(); // See if Vblank DMA is present and not enabled dma.onBlanking(cpu.bus, .VBlank); } if (scanline == 227) self.dispstat.vblank.unset(); self.sched.push(.VBlank, 240 * 4 -| late); } } }; const Blend = struct { const Self = @This(); cnt: io.BldCnt, alpha: io.BldAlpha, y: io.BldY, pub fn create() Self { return .{ .cnt = .{ .raw = 0x000 }, .alpha = .{ .raw = 0x000 }, .y = .{ .raw = 0x000 }, }; } pub fn getCnt(self: *const Self) u16 { return self.cnt.raw & 0x3FFF; } pub fn getAlpha(self: *const Self) u16 { return self.alpha.raw & 0x1F1F; } }; const Window = struct { const Self = @This(); h: [2]io.WinH, v: [2]io.WinV, out: io.WinOut, in: io.WinIn, fn init() Self { return .{ .h = [_]io.WinH{.{ .raw = 0 }} ** 2, .v = [_]io.WinV{.{ .raw = 0 }} ** 2, .out = .{ .raw = 0 }, .in = .{ .raw = 0 }, }; } pub fn getIn(self: *const Self) u16 { return self.in.raw & 0x3F3F; } pub fn getOut(self: *const Self) u16 { return self.out.raw & 0x3F3F; } fn inRange(self: *const Self, comptime id: u1, x: u9, y: u8) bool { const winh = self.h[id]; const winv = self.v[id]; if (isYInRange(winv, y)) { const x1 = winh.x1.read(); const x2 = winh.x2.read(); // Within X Bounds return if (x1 < x2) blk: { break :blk x >= x1 and x < x2; } else blk: { break :blk x >= x1 or x < x2; }; } return false; } inline fn isYInRange(winv: io.WinV, y: u9) bool { const y1 = winv.y1.read(); const y2 = winv.y2.read(); if (y1 < y2) { return y >= y1 and y < y2; } else { return y >= y1 or y < y2; } } pub fn setH(self: *Self, value: u32) void { self.h[0].raw = @truncate(u16, value); self.h[1].raw = @truncate(u16, value >> 16); } pub fn setV(self: *Self, value: u32) void { self.v[0].raw = @truncate(u16, value); self.v[1].raw = @truncate(u16, value >> 16); } pub fn setIo(self: *Self, value: u32) void { self.in.raw = @truncate(u16, value); self.out.raw = @truncate(u16, value >> 16); } }; const Background = struct { const Self = @This(); /// Read / Write cnt: io.BackgroundControl, /// Write Only hofs: io.BackgroundOffset, /// Write Only vofs: io.BackgroundOffset, fn init() Self { return .{ .cnt = .{ .raw = 0x0000 }, .hofs = .{ .raw = 0x0000 }, .vofs = .{ .raw = 0x0000 }, }; } /// For whatever reason, some higher bits of BG0CNT /// are masked out pub inline fn bg0Cnt(self: *const Self) u16 { return self.cnt.raw & 0xDFFF; } /// BG1CNT inherits the same mask as BG0CNTs pub inline fn bg1Cnt(self: *const Self) u16 { return self.bg0Cnt(); } }; const AffineBackground = struct { const Self = @This(); x: i32, y: i32, pa: i16, pb: i16, pc: i16, pd: i16, x_latch: ?i32, y_latch: ?i32, fn init() Self { return .{ .x = 0, .y = 0, .pa = 0, .pb = 0, .pc = 0, .pd = 0, .x_latch = null, .y_latch = null, }; } pub fn setX(self: *Self, is_vblank: bool, value: u32) void { self.x = @bitCast(i32, value); if (!is_vblank) self.x_latch = @bitCast(i32, value); } pub fn setY(self: *Self, is_vblank: bool, value: u32) void { self.y = @bitCast(i32, value); if (!is_vblank) self.y_latch = @bitCast(i32, value); } pub fn writePaPb(self: *Self, value: u32) void { self.pa = @bitCast(i16, @truncate(u16, value)); self.pb = @bitCast(i16, @truncate(u16, value >> 16)); } pub fn writePcPd(self: *Self, value: u32) void { self.pc = @bitCast(i16, @truncate(u16, value)); self.pd = @bitCast(i16, @truncate(u16, value >> 16)); } // Every Vblank BG?X/Y registers are latched fn latchRefPoints(self: *Self) void { self.x_latch = self.x; self.y_latch = self.y; } }; const ScreenEntry = extern union { tile_id: Bitfield(u16, 0, 10), h_flip: Bit(u16, 10), v_flip: Bit(u16, 11), pal_bank: Bitfield(u16, 12, 4), raw: u16, }; const Sprite = struct { const Self = @This(); attr0: Attr0, attr1: Attr1, attr2: Attr2, width: u8, height: u8, fn init(attr0: Attr0, attr1: Attr1, attr2: Attr2) Self { const d = spriteDimensions(attr0.shape.read(), attr1.size.read()); return .{ .attr0 = attr0, .attr1 = attr1, .attr2 = attr2, .width = d[0], .height = d[1], }; } fn x(self: *const Self) u9 { return self.attr1.x.read(); } fn y(self: *const Self) u8 { return self.attr0.y.read(); } fn is8bpp(self: *const Self) bool { return self.attr0.is_8bpp.read(); } fn tileId(self: *const Self) u10 { return self.attr2.tile_id.read(); } fn palBank(self: *const Self) u4 { return self.attr2.pal_bank.read(); } fn hFlip(self: *const Self) bool { return self.attr1.h_flip.read(); } fn vFlip(self: *const Self) bool { return self.attr1.v_flip.read(); } fn priority(self: *const Self) u2 { return self.attr2.rel_prio.read(); } }; const AffineSprite = struct { const Self = @This(); attr0: AffineAttr0, attr1: AffineAttr1, attr2: Attr2, width: u8, height: u8, fn from(sprite: Sprite) AffineSprite { return .{ .attr0 = .{ .raw = sprite.attr0.raw }, .attr1 = .{ .raw = sprite.attr1.raw }, .attr2 = sprite.attr2, .width = sprite.width, .height = sprite.height, }; } fn x(self: *const Self) u9 { return self.attr1.x.read(); } fn y(self: *const Self) u8 { return self.attr0.y.read(); } fn is8bpp(self: *const Self) bool { return self.attr0.is_8bpp.read(); } fn tileId(self: *const Self) u10 { return self.attr2.tile_id.read(); } fn palBank(self: *const Self) u4 { return self.attr2.pal_bank.read(); } fn matrixId(self: *const Self) u5 { return self.attr1.aff_sel.read(); } }; const Attr0 = extern union { y: Bitfield(u16, 0, 8), is_affine: Bit(u16, 8), // This SBZ disabled: Bit(u16, 9), mode: Bitfield(u16, 10, 2), mosaic: Bit(u16, 12), is_8bpp: Bit(u16, 13), shape: Bitfield(u16, 14, 2), raw: u16, }; const AffineAttr0 = extern union { y: Bitfield(u16, 0, 8), rot_scaling: Bit(u16, 8), // This SB1 double_size: Bit(u16, 9), mode: Bitfield(u16, 10, 2), mosaic: Bit(u16, 12), is_8bpp: Bit(u16, 13), shape: Bitfield(u16, 14, 2), raw: u16, }; const Attr1 = extern union { x: Bitfield(u16, 0, 9), h_flip: Bit(u16, 12), v_flip: Bit(u16, 13), size: Bitfield(u16, 14, 2), raw: u16, }; const AffineAttr1 = extern union { x: Bitfield(u16, 0, 9), aff_sel: Bitfield(u16, 9, 5), size: Bitfield(u16, 14, 2), raw: u16, }; const Attr2 = extern union { tile_id: Bitfield(u16, 0, 10), rel_prio: Bitfield(u16, 10, 2), pal_bank: Bitfield(u16, 12, 4), raw: u16, }; fn spriteDimensions(shape: u2, size: u2) [2]u8 { @setRuntimeSafety(false); return switch (shape) { 0b00 => switch (size) { // Square 0b00 => [_]u8{ 8, 8 }, 0b01 => [_]u8{ 16, 16 }, 0b10 => [_]u8{ 32, 32 }, 0b11 => [_]u8{ 64, 64 }, }, 0b01 => switch (size) { 0b00 => [_]u8{ 16, 8 }, 0b01 => [_]u8{ 32, 8 }, 0b10 => [_]u8{ 32, 16 }, 0b11 => [_]u8{ 64, 32 }, }, 0b10 => switch (size) { 0b00 => [_]u8{ 8, 16 }, 0b01 => [_]u8{ 8, 32 }, 0b10 => [_]u8{ 16, 32 }, 0b11 => [_]u8{ 32, 64 }, }, else => std.debug.panic("{} is an invalid sprite shape", .{shape}), }; } inline fn rgba888(bgr555: u16) u32 { const b = @as(u32, bgr555 >> 10 & 0x1F); const g = @as(u32, bgr555 >> 5 & 0x1F); const r = @as(u32, bgr555 & 0x1F); return (r << 3 | r >> 2) << 24 | (g << 3 | g >> 2) << 16 | (b << 3 | b >> 2) << 8 | 0xFF; } fn alphaBlend(top: u16, btm: u16, bldalpha: io.BldAlpha) u16 { const eva: u16 = bldalpha.eva.read(); const evb: u16 = bldalpha.evb.read(); const top_r = top & 0x1F; const top_g = (top >> 5) & 0x1F; const top_b = (top >> 10) & 0x1F; const btm_r = btm & 0x1F; const btm_g = (btm >> 5) & 0x1F; const btm_b = (btm >> 10) & 0x1F; const bld_r = std.math.min(31, (top_r * eva + btm_r * evb) >> 4); const bld_g = std.math.min(31, (top_g * eva + btm_g * evb) >> 4); const bld_b = std.math.min(31, (top_b * eva + btm_b * evb) >> 4); return (bld_b << 10) | (bld_g << 5) | bld_r; } fn shouldDrawSprite(bldcnt: io.BldCnt, scanline: *Scanline, x: u9) bool { switch (bldcnt.mode.read()) { 0b00 => if (scanline.top()[x].isSet()) return false, 0b01 => { // BLD_ALPHA // We want to check if we're concerned aout the bottom layer first // because if so, the top layer already having a pixel is OK const btm_layers = bldcnt.layer_b.read(); const is_btm_layer = (btm_layers >> 4) & 1 == 1; if (is_btm_layer and scanline.btm()[x].isSet()) return false; if (scanline.top()[x].isSet()) return false; }, 0b10, 0b11 => { if (scanline.top()[x].isSet()) return false; if (scanline.btm()[x].isSet()) return false; }, } return true; } fn drawSpritePixel(bldcnt: io.BldCnt, scanline: *Scanline, attr0: Attr0, x: u9, bgr555: u16) void { if (attr0.mode.read() == 1) { // TODO: Force Alpha Blend in all moes? scanline.top()[x] = Scanline.Pixel.from(.Sprite, bgr555); return; } switch (bldcnt.mode.read()) { 0b00 => {}, // pass through 0b01 => { // BLD_ALPHA const top_layers = bldcnt.layer_a.read(); const is_top_layer = (top_layers >> 4) & 1 == 1; if (is_top_layer) { scanline.top()[x] = Scanline.Pixel.from(.Sprite, bgr555); return; } const btm_layers = bldcnt.layer_b.read(); const is_btm_layer = (btm_layers >> 4) & 1 == 1; if (is_btm_layer) { scanline.btm()[x] = Scanline.Pixel.from(.Sprite, bgr555); return; } // We're rendering a normal pixel that isn't alpha blended // we can mark the pixel on the bottom layer as hidden scanline.btm()[x] = .hidden; }, 0b10, 0b11 => { // This is explained in drawBackgroundPixel, we're reusing the bottom layer to draw layer A pixels we will want to // later blend with WHITE or BLACK const top_layers = bldcnt.layer_a.read(); const is_top_layer = (top_layers >> 4) & 1 == 1; if (is_top_layer) { scanline.btm()[x] = Scanline.Pixel.from(.Sprite, bgr555); // This is intentional return; } }, } scanline.top()[x] = Scanline.Pixel.from(.Sprite, bgr555); } const Scanline = struct { const Self = @This(); const Pixel = union(enum) { // TODO: Rename const Layer = enum { Background, Sprite }; set: u16, obj_set: u16, unset: void, hidden: void, fn from(comptime layer: Layer, bgr555: u16) Pixel { return switch (layer) { .Background => .{ .set = bgr555 }, .Sprite => .{ .obj_set = bgr555 }, }; } pub fn isSet(self: @This()) bool { return switch (self) { .set, .obj_set => true, .unset, .hidden => false, }; } }; layers: [2][]Pixel, buf: []Pixel, allocator: Allocator, fn init(allocator: Allocator) !Self { const buf = try allocator.alloc(Pixel, width * 2); // Top & Bottom Scanline std.mem.set(Pixel, buf, .unset); return .{ // Top & Bototm Layers .layers = [_][]Pixel{ buf[0..][0..width], buf[width..][0..width] }, .buf = buf, .allocator = allocator, }; } fn reset(self: *Self) void { std.mem.set(Pixel, self.buf, .unset); } fn deinit(self: *Self) void { self.allocator.free(self.buf); self.* = undefined; } fn top(self: *Self) []Pixel { return self.layers[0]; } fn btm(self: *Self) []Pixel { return self.layers[1]; } };