feat: implement PPU Timings in Scheduler

src/bus.zig

@@ -1,5 +1,6 @@
 const std = @import("std");
 
+const Scheduler = @import("scheduler.zig").Scheduler;
 const Io = @import("bus/io.zig").Io;
 const Bios = @import("bus/bios.zig").Bios;
 const GamePak = @import("bus/pak.zig").GamePak;
@@ -13,11 +14,11 @@ pub const Bus = struct {
     ppu: Ppu,
     io: Io,
 
-    pub fn init(alloc: Allocator, path: []const u8) !@This() {
+    pub fn init(alloc: Allocator, sched: *Scheduler, path: []const u8) !@This() {
         return @This(){
             .pak = try GamePak.init(alloc, path),
             .bios = try Bios.init(alloc, "./bin/gba_bios.bin"), // TODO: don't hardcode this + bundle open-sorce Boot ROM
-            .ppu = try Ppu.init(alloc),
+            .ppu = try Ppu.init(alloc, sched),
             .io = Io.init(),
         };
     }

src/bus/io.zig

@@ -5,13 +5,15 @@ const Bitfield = bitfield.Bitfield;
 const Bit = bitfield.Bit;
 
 pub const Io = struct {
-    dispcnt: Dispcnt,
+    dispcnt: DispCnt,
-    dispstat: Dispstat,
+    dispstat: DispStat,
+    vcount: VCount,
 
     pub fn init() @This() {
         return .{
             .dispcnt = .{ .raw = 0x0000_0000 },
             .dispstat = .{ .raw = 0x0000_0000 },
+            .vcount = .{ .raw = 0x0000_0000 },
         };
     }
 
@@ -48,7 +50,7 @@ pub const Io = struct {
     }
 };
 
-const Dispcnt = extern union {
+const DispCnt = extern union {
     bg_mode: Bitfield(u16, 0, 3),
     frame_select: Bit(u16, 4),
     hblank_interraw_free: Bit(u16, 5),
@@ -61,7 +63,7 @@ const Dispcnt = extern union {
     raw: u16,
 };
 
-const Dispstat = extern union {
+const DispStat = extern union {
     vblank: Bit(u16, 0),
     hblank: Bit(u16, 1),
     vcount: Bit(u16, 2),
@@ -71,3 +73,8 @@ const Dispstat = extern union {
     vcount_setting: Bitfield(u16, 8, 7),
     raw: u16,
 };
+
+const VCount = extern union {
+    scanline: Bitfield(u16, 0, 8),
+    raw: u16,
+};

src/cpu.zig

@@ -18,14 +18,14 @@ const arm_lut: [0x1000]InstrFn = populate();
 
 pub const Arm7tdmi = struct {
     r: [16]u32,
-    sch: *Scheduler,
+    sched: *Scheduler,
     bus: *Bus,
     cpsr: CPSR,
 
-    pub fn init(scheduler: *Scheduler, bus: *Bus) @This() {
+    pub fn init(sched: *Scheduler, bus: *Bus) @This() {
         return .{
             .r = [_]u32{0x00} ** 16,
-            .sch = scheduler,
+            .sched = sched,
             .bus = bus,
             .cpsr = .{ .raw = 0x0000_00DF },
         };

src/emu.zig

@@ -4,14 +4,14 @@ const Bus = @import("bus.zig").Bus;
 
 const cycles_per_frame: u64 = 100; // TODO: How many cycles actually?
 
-pub fn runFrame(sch: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void {
+pub fn runFrame(sched: *Scheduler, cpu: *Arm7tdmi, bus: *Bus) void {
     var cycles: u64 = 0;
     while (cycles < cycles_per_frame) : (cycles += 1) {
-        sch.tick += 1;
+        sched.tick += 1;
         _ = cpu.step();
 
-        while (sch.tick >= sch.nextTimestamp()) {
+        while (sched.tick >= sched.nextTimestamp()) {
-            sch.handleEvent(cpu, bus);
+            sched.handleEvent(cpu, bus);
         }
     }
 }

src/main.zig

@@ -23,12 +23,12 @@ pub fn main() anyerror!void {
         return;
     }
 
-    var bus = try Bus.init(alloc, zba_args[0]);
-    defer bus.deinit();
-
     var scheduler = Scheduler.init(alloc);
     defer scheduler.deinit();
 
+    var bus = try Bus.init(alloc, &scheduler, zba_args[0]);
+    defer bus.deinit();
+
     var cpu = Arm7tdmi.init(&scheduler, &bus);
 
     cpu.skipBios();

src/ppu.zig

@@ -1,15 +1,22 @@
 const std = @import("std");
 
 const Allocator = std.mem.Allocator;
+const Scheduler = @import("scheduler.zig").Scheduler;
+const EventKind = @import("scheduler.zig").EventKind;
 
 pub const Ppu = struct {
     vram: Vram,
     palette: Palette,
+    sched: *Scheduler,
+
+    pub fn init(alloc: Allocator, sched: *Scheduler) !@This() {
+        // Queue first Hblank
+        sched.push(.{ .kind = .HBlank, .tick = sched.tick + 240 * 4 });
 
-    pub fn init(alloc: Allocator) !@This() {
         return @This(){
             .vram = try Vram.init(alloc),
             .palette = try Palette.init(alloc),
+            .sched = sched,
         };
     }
 

src/scheduler.zig

@@ -25,7 +25,7 @@ pub const Scheduler = struct {
         self.queue.deinit();
     }
 
-    pub fn handleEvent(self: *@This(), _: *Arm7tdmi, _: *Bus) void {
+    pub fn handleEvent(self: *@This(), _: *Arm7tdmi, bus: *Bus) void {
         const should_handle = if (self.queue.peek()) |e| self.tick >= e.tick else false;
 
         if (should_handle) {
@@ -35,10 +35,56 @@ pub const Scheduler = struct {
                 .HeatDeath => {
                     std.debug.panic("[Scheduler] Somehow, a u64 overflowed", .{});
                 },
+                .HBlank => {
+                    std.log.debug("[Scheduler] tick {}: Hblank", .{self.tick});
+
+                    // We've reached the end of a scanline
+                    const scanline = bus.io.vcount.scanline.read();
+                    bus.io.vcount.scanline.write(scanline + 1);
+
+                    bus.io.dispstat.hblank.set();
+
+                    if (scanline < 160) {
+                        self.push(.{ .kind = .Visible, .tick = self.tick + (68 * 4) });
+                    } else {
+                        self.push(.{ .kind = .VBlank, .tick = self.tick + (68 * 4) });
+                    }
+                },
+                .Visible => {
+                    std.log.debug("[Scheduler] tick {}: Visible", .{self.tick});
+
+                    // Beginning of a Scanline
+                    bus.io.dispstat.hblank.unset();
+                    bus.io.dispstat.vblank.unset();
+
+                    self.push(.{ .kind = .HBlank, .tick = self.tick + (240 * 4) });
+                },
+                .VBlank => {
+                    std.log.debug("[Scheduler] tick {}: VBlank", .{self.tick});
+
+                    // Beginning of a Scanline, not visible though
+                    bus.io.dispstat.hblank.unset();
+                    bus.io.dispstat.vblank.set();
+
+                    const scanline = bus.io.vcount.scanline.read();
+                    bus.io.vcount.scanline.write(scanline + 1);
+
+                    if (scanline < 227) {
+                        // Another Vblank Scanline
+                        self.push(.{ .kind = .VBlank, .tick = self.tick + 68 * (308 * 4) });
+                    } else {
+                        bus.io.vcount.scanline.write(0); // Reset Scanline
+                        self.push(.{ .kind = .Visible, .tick = self.tick + 68 * (308 * 4) });
+                    }
+                },
             }
         }
     }
 
+    pub inline fn push(self: *@This(), event: Event) void {
+        self.queue.add(event) catch unreachable;
+    }
+
     pub inline fn nextTimestamp(self: *@This()) u64 {
         if (self.queue.peek()) |e| {
             return e.tick;
@@ -57,4 +103,7 @@ fn lessThan(_: void, a: Event, b: Event) Order {
 
 pub const EventKind = enum {
     HeatDeath,
+    HBlank,
+    VBlank,
+    Visible,
 };