feat(sched): add HBlank and VBlank events to the 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/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()) {
-            sch.handleEvent(cpu, bus);
+        while (sched.tick >= sched.nextTimestamp()) {
+            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,18 @@
 const std = @import("std");
 
 const Allocator = std.mem.Allocator;
+const Scheduler = @import("scheduler.zig").Scheduler;
 
 pub const Ppu = struct {
     vram: Vram,
     palette: Palette,
+    sched: *Scheduler,
 
-    pub fn init(alloc: Allocator) !@This() {
+    pub fn init(alloc: Allocator, sched: *Scheduler) !@This() {
         return @This(){
             .vram = try Vram.init(alloc),
             .palette = try Palette.init(alloc),
+            .sched = sched,
         };
     }
 

src/scheduler.zig

@@ -35,6 +35,12 @@ pub const Scheduler = struct {
                 .HeatDeath => {
                     std.debug.panic("[Scheduler] Somehow, a u64 overflowed", .{});
                 },
+                .HBlank => {
+                    std.debug.panic("[Scheduler] tick {}: Hblank", .{self.tick});
+                },
+                .VBlank => {
+                    std.debug.panic("[Scheduler] tick {}: VBlank", .{self.tick});
+                },
             }
         }
     }
@@ -57,4 +63,6 @@ fn lessThan(_: void, a: Event, b: Event) Order {
 
 pub const EventKind = enum {
     HeatDeath,
+    HBlank,
+    VBlank,
 };