feat: allow gui and gdbstub to run in parallel

.github/workflows/main.yml

@@ -14,8 +14,7 @@ jobs:
   build:
     strategy:
       matrix:
-        # os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest]
-        os: [ubuntu-latest, windows-latest]
     runs-on: ${{matrix.os}}
     steps:
       - uses: goto-bus-stop/setup-zig@v2
@@ -24,8 +23,8 @@ jobs:
       - name: prepare-linux
         if: runner.os == 'Linux'
         run: |
-            sudo apt update
+            sudo apt-get update
-            sudo apt install libgtk-3-dev libsdl2-dev
+            sudo apt-get install libsdl2-dev
       - name: prepare-windows
         if: runner.os == 'Windows'
         run: |
@@ -38,9 +37,9 @@ jobs:
             brew install sdl2
       - uses: actions/checkout@v3
         with:
-          submodules: recursive
+          submodules: true
       - name: build 
-        run: zig build -Doptimize=ReleaseSafe -Dcpu=baseline
+        run: zig build -Doptimize=ReleaseSafe
       - name: upload
         uses: actions/upload-artifact@v3
         with:
@@ -51,7 +50,7 @@ jobs:
     steps: 
       - uses: actions/checkout@v3
         with:
-          submodules: recursive
+          submodules: true
       - uses: goto-bus-stop/setup-zig@v2
         with:
           version: master

.gitignore

@@ -12,7 +12,3 @@
 
 # Any Custom Scripts for Debugging purposes
 *.sh
-
-
-# Dear ImGui
-**/imgui.ini

.gitmodules

@@ -16,12 +16,3 @@
 [submodule "lib/zba-gdbstub"]
 	path = lib/zba-gdbstub
 	url = https://git.musuka.dev/paoda/zba-gdbstub
-[submodule "lib/zgui"]
-	path = lib/zgui
-	url = https://git.musuka.dev/paoda/zgui
-[submodule "lib/nfd-zig"]
-	path = lib/nfd-zig
-	url = https://github.com/fabioarnold/nfd-zig
-[submodule "lib/zba-util"]
-	path = lib/zba-util
-	url = https://git.musuka.dev/paoda/zba-util.git

README.md

@@ -2,8 +2,6 @@
 
 A Game Boy Advance Emulator written in Zig ⚡!
 
-![ZBA running リズム天国](assets/screenshot.png)
-
 ## Scope
 
 I'm hardly the first to write a Game Boy Advance Emulator nor will I be the last. This project isn't going to compete with the GOATs like [mGBA](https://github.com/mgba-emu) or [NanoBoyAdvance](https://github.com/nba-emu/NanoBoyAdvance). There aren't any interesting ideas either like in [DSHBA](https://github.com/DenSinH/DSHBA).
@@ -15,13 +13,14 @@ This is a simple (read: incomplete) for-fun long-term project. I hope to get "mo
 - [x] Affine Sprites
 - [ ] Windowing (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/window))
 - [ ] Audio Resampler (Having issues with SDL2's)
+- [x] Immediate Mode GUI (see [this branch](https://git.musuka.dev/paoda/zba/src/branch/imgui))
 - [ ] Refactoring for easy-ish perf boosts
 
 ## Usage
 
 As it currently exists, ZBA is run from the terminal. In your console of choice, type `./zba --help` to see what you can do.
 
-I typically find myself typing `./zba -b ./bin/bios.bin` and then going to File -> Insert ROM to load the title of my choice.
+I typically find myself typing `./zba -b ./bin/bios.bin ./bin/test/suite.gba` to see how badly my "cool new feature" broke everything else.
 
 Need a BIOS? Why not try using the open-source [Cult-Of-GBA BIOS](https://github.com/Cult-of-GBA/BIOS) written by [fleroviux](https://github.com/fleroviux) and [DenSinH](https://github.com/DenSinH)?
 
@@ -78,19 +77,17 @@ arm7wrestler GBA Fixed | [destoer](https://github.com/destoer)
 
 ## Compiling
 
-Most recently built on Zig [v0.11.0-dev.2168+322ace70f](https://github.com/ziglang/zig/tree/322ace70f)
+Most recently built on Zig [v0.11.0-dev.1580+a5b34a61a](https://github.com/ziglang/zig/tree/a5b34a61a)
 
 ### Dependencies
 
 Dependency | Source
 --- | ---
 SDL.zig | <https://github.com/MasterQ32/SDL.zig>
-known-folders | <https://github.com/ziglibs/known-folders>
-nfd-zig | <https://github.com/fabioarnold/nfd-zig>
-zgui | <https://github.com/michal-z/zig-gamedev/tree/main/libs/zgui>
 zig-clap | <https://github.com/Hejsil/zig-clap>
-zig-datetime | <https://github.com/frmdstryr/zig-datetime>
+known-folders | <https://github.com/ziglibs/known-folders>
 zig-toml | <https://github.com/aeronavery/zig-toml>
+zig-datetime | <https://github.com/frmdstryr/zig-datetime>
 `bitfields.zig` | [https://github.com/FlorenceOS/Florence](https://github.com/FlorenceOS/Florence/blob/aaa5a9e568/lib/util/bitfields.zig)
 `gl.zig` | <https://github.com/MasterQ32/zig-opengl>
 
@@ -99,7 +96,7 @@ Use `git submodule update --init` from the project root to pull the git relevant
 Be sure to provide SDL2 using:
 
 - Linux: Your distro's package manager
-- macOS: ¯\\\_(ツ)_/¯ (try [this formula](https://formulae.brew.sh/formula/sdl2)?)
+- MacOS: `brew` (install [this formula](https://formulae.brew.sh/formula/sdl2))
 - Windows: [`vcpkg`](https://github.com/Microsoft/vcpkg) (install `sdl2:x64-windows`)
 
 `SDL.zig` will provide a helpful compile error if the zig compiler is unable to find SDL2.

build.zig

@@ -2,13 +2,11 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 const Sdk = @import("lib/SDL.zig/Sdk.zig");
-const gdbstub = @import("lib/zba-gdbstub/build.zig");
+const Gdbstub = @import("lib/zba-gdbstub/build.zig");
-const zgui = @import("lib/zgui/build.zig");
-const nfd = @import("lib/nfd-zig/build.zig");
 
-pub fn build(b: *std.Build) void {
+pub fn build(b: *std.build.Builder) void {
     // Minimum Zig Version
-    const min_ver = std.SemanticVersion.parse("0.11.0-dev.2168+322ace70f") catch return; // https://github.com/ziglang/zig/commit/322ace70f
+    const min_ver = std.SemanticVersion.parse("0.11.0-dev.1580+a5b34a61a") catch return; // https://github.com/ziglang/zig/commit/a5b34a61a
     if (builtin.zig_version.order(min_ver).compare(.lt)) {
         std.log.err("{s}", .{b.fmt("Zig v{} does not meet the minimum version requirement. (Zig v{})", .{ builtin.zig_version, min_ver })});
         std.os.exit(1);
@@ -33,7 +31,7 @@ pub fn build(b: *std.Build) void {
     exe.addAnonymousModule("datetime", .{ .source_file = .{ .path = "lib/zig-datetime/src/main.zig" } });
 
     // Bitfield type from FlorenceOS: https://github.com/FlorenceOS/
-    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/bitfield.zig" } });
+    exe.addAnonymousModule("bitfield", .{ .source_file = .{ .path = "lib/util/bitfield.zig" } });
 
     // Argument Parsing Library
     exe.addAnonymousModule("clap", .{ .source_file = .{ .path = "lib/zig-clap/clap.zig" } });
@@ -44,27 +42,14 @@ pub fn build(b: *std.Build) void {
     // OpenGL 3.3 Bindings
     exe.addAnonymousModule("gl", .{ .source_file = .{ .path = "lib/gl.zig" } });
 
-    // ZBA utility code
-    exe.addAnonymousModule("zba-util", .{ .source_file = .{ .path = "lib/zba-util/src/lib.zig" } });
-
     // gdbstub
-    exe.addModule("gdbstub", gdbstub.getModule(b));
+    Gdbstub.link(exe);
-
-    // NativeFileDialog(ue) Bindings
-    exe.linkLibrary(nfd.makeLib(b, target, optimize));
-    exe.addModule("nfd", nfd.getModule(b));
 
     // Zig SDL Bindings: https://github.com/MasterQ32/SDL.zig
     const sdk = Sdk.init(b, null);
     sdk.link(exe, .dynamic);
     exe.addModule("sdl2", sdk.getNativeModule());
 
-    // Dear ImGui bindings
-
-    // .shared option should stay in sync with SDL.zig call above where true == .dynamic, and false == .static
-    const zgui_pkg = zgui.package(b, target, optimize, .{ .options = .{ .backend = .sdl2_opengl3, .shared = true } });
-    zgui_pkg.link(exe);
-
     exe.install();
 
     const run_cmd = exe.run();

src/core/Bus.zig

@@ -19,7 +19,7 @@ const log = std.log.scoped(.Bus);
 
 const createDmaTuple = @import("bus/dma.zig").create;
 const createTimerTuple = @import("bus/timer.zig").create;
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../util.zig").rotr;
 
 const timings: [2][0x10]u8 = [_][0x10]u8{
     // BIOS, Unused, EWRAM, IWRAM, I/0, PALRAM, VRAM, OAM, ROM0, ROM0, ROM1, ROM1, ROM2, ROM2, SRAM, Unused
@@ -102,51 +102,10 @@ pub fn deinit(self: *Self) void {
     self.* = undefined;
 }
 
-pub fn reset(self: *Self) void {
-    self.bios.reset();
-    self.ppu.reset();
-    self.apu.reset();
-    self.iwram.reset();
-    self.ewram.reset();
-
-    // https://github.com/ziglang/zig/issues/14705
-    {
-        comptime var i: usize = 0;
-        inline while (i < self.dma.len) : (i += 1) {
-            self.dma[0].reset();
-        }
-    }
-
-    // https://github.com/ziglang/zig/issues/14705
-    {
-        comptime var i: usize = 0;
-        inline while (i < self.tim.len) : (i += 1) {
-            self.tim[0].reset();
-        }
-    }
-
-    self.io.reset();
-}
-
-pub fn replaceGamepak(self: *Self, file_path: []const u8) !void {
-    // Note: `save_path` isn't owned by `Backup`
-    const save_path = self.pak.backup.save_path;
-    self.pak.deinit();
-
-    self.pak = try GamePak.init(self.allocator, self.cpu, file_path, save_path);
-
-    const read_ptr: *[table_len]?*const anyopaque = @constCast(self.read_table);
-    const write_ptrs: [2]*[table_len]?*anyopaque = .{ @constCast(self.write_tables[0]), @constCast(self.write_tables[1]) };
-
-    self.fillReadTable(read_ptr);
-    self.fillWriteTable(u32, write_ptrs[0]);
-    self.fillWriteTable(u8, write_ptrs[1]);
-}
-
 fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
     const vramMirror = @import("ppu/Vram.zig").mirror;
 
-    for (table, 0..) |*ptr, i| {
+    for (table) |*ptr, i| {
         const addr = @intCast(u32, page_size * i);
 
         ptr.* = switch (addr) {
@@ -173,7 +132,7 @@ fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyo
     comptime std.debug.assert(T == u32 or T == u16 or T == u8);
     const vramMirror = @import("ppu/Vram.zig").mirror;
 
-    for (table, 0..) |*ptr, i| {
+    for (table) |*ptr, i| {
         const addr = @intCast(u32, page_size * i);
 
         ptr.* = switch (addr) {

src/core/apu.zig

@@ -14,6 +14,7 @@ const SoundFifo = std.fifo.LinearFifo(u8, .{ .Static = 0x20 });
 
 const getHalf = util.getHalf;
 const setHalf = util.setHalf;
+const intToBytes = util.intToBytes;
 
 const log = std.log.scoped(.APU);
 
@@ -278,44 +279,17 @@ pub const Apu = struct {
             .is_buffer_full = false,
         };
 
-        Self.initEvents(apu.sched, apu.interval());
+        sched.push(.SampleAudio, apu.interval());
+        sched.push(.{ .ApuChannel = 0 }, @import("apu/signal/Square.zig").interval);
+        sched.push(.{ .ApuChannel = 1 }, @import("apu/signal/Square.zig").interval);
+        sched.push(.{ .ApuChannel = 2 }, @import("apu/signal/Wave.zig").interval);
+        sched.push(.{ .ApuChannel = 3 }, @import("apu/signal/Lfsr.zig").interval);
+        sched.push(.FrameSequencer, FrameSequencer.interval);
 
         return apu;
     }
 
-    fn initEvents(scheduler: *Scheduler, apu_interval: u64) void {
+    fn reset(self: *Self) void {
-        scheduler.push(.SampleAudio, apu_interval);
-        scheduler.push(.{ .ApuChannel = 0 }, @import("apu/signal/Square.zig").interval);
-        scheduler.push(.{ .ApuChannel = 1 }, @import("apu/signal/Square.zig").interval);
-        scheduler.push(.{ .ApuChannel = 2 }, @import("apu/signal/Wave.zig").interval);
-        scheduler.push(.{ .ApuChannel = 3 }, @import("apu/signal/Lfsr.zig").interval);
-        scheduler.push(.FrameSequencer, FrameSequencer.interval);
-    }
-
-    /// Used when resetting the emulator
-    pub fn reset(self: *Self) void {
-        // FIXME: These reset functions are meant to emulate obscure APU behaviour. Write proper emu reset fns
-        self.ch1.reset();
-        self.ch2.reset();
-        self.ch3.reset();
-        self.ch4.reset();
-
-        self.chA.reset();
-        self.chB.reset();
-
-        self.psg_cnt = .{ .raw = 0 };
-        self.dma_cnt = .{ .raw = 0 };
-        self.cnt = .{ .raw = 0 };
-        self.bias = .{ .raw = 0x200 };
-
-        self.sampling_cycle = 0;
-        self.fs.reset();
-
-        Self.initEvents(self.sched, self.interval());
-    }
-
-    /// Emulates the reset behaviour of the APU
-    fn _reset(self: *Self) void {
         // All PSG Registers between 0x0400_0060..0x0400_0081 are zeroed
         // 0x0400_0082 and 0x0400_0088 retain their values
         self.ch1.reset();
@@ -377,7 +351,7 @@ pub const Apu = struct {
             // Rest Noise
             self.ch4.lfsr.reset();
         } else {
-            self._reset();
+            self.reset();
         }
     }
 
@@ -554,15 +528,10 @@ pub fn DmaSound(comptime kind: DmaSoundKind) type {
             };
         }
 
-        /// Used when resetting hte emulator (not emulation code)
-        fn reset(self: *Self) void {
-            self.* = Self.init();
-        }
-
         pub fn push(self: *Self, value: u32) void {
             if (!self.enabled) self.enable();
 
-            self.fifo.write(std.mem.asBytes(&value)) catch |e| log.err("{} Error: {}", .{ kind, e });
+            self.fifo.write(&intToBytes(u32, value)) catch |e| log.err("{} Error: {}", .{ kind, e });
         }
 
         fn enable(self: *Self) void {
@@ -593,14 +562,10 @@ pub const FrameSequencer = struct {
     const Self = @This();
     pub const interval = (1 << 24) / 512;
 
-    step: u3 = 0,
+    step: u3,
 
     pub fn init() Self {
-        return .{};
+        return .{ .step = 0 };
-    }
-
-    pub fn reset(self: *Self) void {
-        self.* = .{};
     }
 
     pub fn tick(self: *Self) void {

src/core/apu/device/Envelope.zig

@@ -3,16 +3,17 @@ const io = @import("../../bus/io.zig");
 const Self = @This();
 
 /// Period Timer
-timer: u3 = 0,
+timer: u3,
 /// Current Volume
-vol: u4 = 0,
+vol: u4,
 
 pub fn create() Self {
-    return .{};
+    return .{ .timer = 0, .vol = 0 };
 }
 
 pub fn reset(self: *Self) void {
-    self.* = .{};
+    self.timer = 0;
+    self.vol = 0;
 }
 
 pub fn tick(self: *Self, nrx2: io.Envelope) void {

src/core/apu/device/Length.zig

@@ -1,13 +1,13 @@
 const Self = @This();
 
-timer: u9 = 0,
+timer: u9,
 
 pub fn create() Self {
-    return .{};
+    return .{ .timer = 0 };
 }
 
 pub fn reset(self: *Self) void {
-    self.* = .{};
+    self.timer = 0;
 }
 
 pub fn tick(self: *Self, enabled: bool, ch_enable: *bool) void {

src/core/apu/device/Sweep.zig

@@ -3,18 +3,26 @@ const ToneSweep = @import("../ToneSweep.zig");
 
 const Self = @This();
 
-timer: u8 = 0,
+timer: u8,
-enabled: bool = false,
+enabled: bool,
-shadow: u11 = 0,
+shadow: u11,
 
-calc_performed: bool = false,
+calc_performed: bool,
 
 pub fn create() Self {
-    return .{};
+    return .{
+        .timer = 0,
+        .enabled = false,
+        .shadow = 0,
+        .calc_performed = false,
+    };
 }
 
 pub fn reset(self: *Self) void {
-    self.* = .{};
+    self.timer = 0;
+    self.enabled = false;
+    self.shadow = 0;
+    self.calc_performed = false;
 }
 
 pub fn tick(self: *Self, ch1: *ToneSweep) void {

src/core/bus/Bios.zig

@@ -3,7 +3,7 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.Bios);
 
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../util.zig").rotr;
 const forceAlign = @import("../Bus.zig").forceAlign;
 
 /// Size of the BIOS in bytes
@@ -77,10 +77,6 @@ pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
     return Self{ .buf = buf, .allocator = allocator };
 }
 
-pub fn reset(self: *Self) void {
-    self.addr_latch = 0;
-}
-
 pub fn deinit(self: *Self) void {
     if (self.buf) |buf| self.allocator.free(buf);
     self.* = undefined;

src/core/bus/Ewram.zig

@@ -35,10 +35,6 @@ pub fn init(allocator: Allocator) !Self {
     };
 }
 
-pub fn reset(self: *Self) void {
-    std.mem.set(u8, self.buf, 0);
-}
-
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/core/bus/GamePak.zig

@@ -179,30 +179,23 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
     }
 }
 
-pub fn init(allocator: Allocator, cpu: *Arm7tdmi, maybe_rom: ?[]const u8, maybe_save: ?[]const u8) !Self {
+pub fn init(allocator: Allocator, cpu: *Arm7tdmi, rom_path: []const u8, save_path: ?[]const u8) !Self {
-    const Device = Gpio.Device;
+    const file = try std.fs.cwd().openFile(rom_path, .{});
+    defer file.close();
 
-    const items: struct { []u8, [12]u8, Backup.Kind, Device.Kind } = if (maybe_rom) |file_path| blk: {
+    const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
-        const file = try std.fs.cwd().openFile(file_path, .{});
+    const title = file_buf[0xA0..0xAC].*;
-        defer file.close();
+    const kind = Backup.guess(file_buf);
+    const device = if (config.config().guest.force_rtc) .Rtc else guessDevice(file_buf);
 
-        const buffer = try file.readToEndAlloc(allocator, try file.getEndPos());
+    logHeader(file_buf, &title);
-        const title = buffer[0xA0..0xAC];
-        logHeader(buffer, title);
-
-        const device_kind = if (config.config().guest.force_rtc) .Rtc else guessDevice(buffer);
-
-        break :blk .{ buffer, title.*, Backup.guess(buffer), device_kind };
-    } else .{ try allocator.alloc(u8, 0), [_]u8{0} ** 12, .None, .None };
-
-    const title = items[1];
 
     return .{
-        .buf = items[0],
+        .buf = file_buf,
         .allocator = allocator,
         .title = title,
-        .backup = try Backup.init(allocator, items[2], title, maybe_save),
+        .backup = try Backup.init(allocator, kind, title, save_path),
-        .gpio = try Gpio.init(allocator, cpu, items[3]),
+        .gpio = try Gpio.init(allocator, cpu, device),
     };
 }
 
@@ -220,24 +213,25 @@ fn guessDevice(buf: []const u8) Gpio.Device.Kind {
     // Try to Guess if ROM uses RTC
     const needle = "RTC_V"; // I was told SIIRTC_V, though Pokemen Firered (USA) is a false negative
 
-    // TODO: Use new for loop syntax?
     var i: usize = 0;
     while ((i + needle.len) < buf.len) : (i += 1) {
         if (std.mem.eql(u8, needle, buf[i..(i + needle.len)])) return .Rtc;
     }
 
     // TODO: Detect other GPIO devices
+
     return .None;
 }
 
 fn logHeader(buf: []const u8, title: *const [12]u8) void {
+    const code = buf[0xAC..0xB0];
+    const maker = buf[0xB0..0xB2];
     const version = buf[0xBC];
 
     log.info("Title: {s}", .{title});
     if (version != 0) log.info("Version: {}", .{version});
-
+    log.info("Game Code: {s}", .{code});
-    log.info("Game Code: {s}", .{buf[0xAC..0xB0]});
+    log.info("Maker Code: {s}", .{maker});
-    log.info("Maker Code: {s}", .{buf[0xB0..0xB2]});
 }
 
 test "OOB Access" {

src/core/bus/Iwram.zig

@@ -35,10 +35,6 @@ pub fn init(allocator: Allocator) !Self {
     };
 }
 
-pub fn reset(self: *Self) void {
-    std.mem.set(u8, self.buf, 0);
-}
-
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/core/bus/backup.zig

@@ -32,7 +32,7 @@ pub const Backup = struct {
     flash: Flash,
     eeprom: Eeprom,
 
-    pub const Kind = enum {
+    const Kind = enum {
         Eeprom,
         Sram,
         Flash,
@@ -137,7 +137,6 @@ pub const Backup = struct {
         for (backup_kinds) |needle| {
             const needle_len = needle.str.len;
 
-            // TODO: Use new for loop syntax?
             var i: usize = 0;
             while ((i + needle_len) < rom.len) : (i += 1) {
                 if (std.mem.eql(u8, needle.str, rom[i..][0..needle_len])) return needle.kind;
@@ -205,10 +204,6 @@ pub const Backup = struct {
         const file_path = try self.savePath(allocator, path);
         defer allocator.free(file_path);
 
-        // FIXME: communicate edge case to the user?
-        if (std.mem.eql(u8, &self.title, "ACE LIGHTNIN"))
-            return;
-
         switch (self.kind) {
             .Sram, .Flash, .Flash1M, .Eeprom => {
                 const file = try std.fs.createFileAbsolute(file_path, .{});

src/core/bus/dma.zig

@@ -12,7 +12,7 @@ const getHalf = util.getHalf;
 const setHalf = util.setHalf;
 const setQuart = util.setQuart;
 
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../util.zig").rotr;
 
 pub fn create() DmaTuple {
     return .{ DmaController(0).init(), DmaController(1).init(), DmaController(2).init(), DmaController(3).init() };
@@ -195,10 +195,6 @@ fn DmaController(comptime id: u2) type {
             };
         }
 
-        pub fn reset(self: *Self) void {
-            self.* = Self.init();
-        }
-
         pub fn setDmasad(self: *Self, addr: u32) void {
             self.sad = addr & sad_mask;
         }
@@ -343,7 +339,10 @@ fn DmaController(comptime id: u2) type {
 }
 
 pub fn onBlanking(bus: *Bus, comptime kind: DmaKind) void {
-    inline for (0..4) |i| bus.dma[i].poll(kind);
+    comptime var i: usize = 0;
+    inline while (i < 4) : (i += 1) {
+        bus.dma[i].poll(kind);
+    }
 }
 
 const Adjustment = enum(u2) {

src/core/bus/gpio.zig

@@ -293,13 +293,13 @@ pub const Clock = struct {
         self.cpu.sched.push(.RealTimeClock, (1 << 24) -| late); // Reschedule
 
         const now = DateTime.now();
-        self.year = bcd(@intCast(u8, now.date.year - 2000));
+        self.year = bcd(u8, @intCast(u8, now.date.year - 2000));
-        self.month = @truncate(u5, bcd(now.date.month));
+        self.month = bcd(u5, now.date.month);
-        self.day = @truncate(u6, bcd(now.date.day));
+        self.day = bcd(u6, now.date.day);
-        self.weekday = @truncate(u3, bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
+        self.weekday = bcd(u3, (now.date.weekday() + 1) % 7); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
-        self.hour = @truncate(u6, bcd(now.time.hour));
+        self.hour = bcd(u6, now.time.hour);
-        self.minute = @truncate(u7, bcd(now.time.minute));
+        self.minute = bcd(u7, now.time.minute);
-        self.second = @truncate(u7, bcd(now.time.second));
+        self.second = bcd(u7, now.time.second);
     }
 
     fn step(self: *Self, value: Data) u4 {
@@ -449,8 +449,16 @@ pub const Clock = struct {
     }
 };
 
-/// Converts an 8-bit unsigned integer to its BCD representation.
+fn bcd(comptime T: type, value: u8) T {
-/// Note: Algorithm only works for values between 0 and 99 inclusive.
+    var input = value;
-fn bcd(value: u8) u8 {
+    var ret: u8 = 0;
-    return ((value / 10) << 4) + (value % 10);
+    var shift: u3 = 0;
+
+    while (input > 0) {
+        ret |= (input % 10) << (shift << 2);
+        shift += 1;
+        input /= 10;
+    }
+
+    return @truncate(T, ret);
 }

src/core/bus/io.zig

@@ -38,10 +38,6 @@ pub const Io = struct {
         };
     }
 
-    pub fn reset(self: *Self) void {
-        self.* = Self.init();
-    }
-
     fn setIrqs(self: *Io, word: u32) void {
         self.ie.raw = @truncate(u16, word);
         self.irq.raw &= ~@truncate(u16, word >> 16);
@@ -350,10 +346,10 @@ const InterruptEnable = extern union {
     vblank: Bit(u16, 0),
     hblank: Bit(u16, 1),
     coincidence: Bit(u16, 2),
-    tim0: Bit(u16, 3),
+    tm0_overflow: Bit(u16, 3),
-    tim1: Bit(u16, 4),
+    tm1_overflow: Bit(u16, 4),
-    tim2: Bit(u16, 5),
+    tm2_overflow: Bit(u16, 5),
-    tim3: Bit(u16, 6),
+    tm3_overflow: Bit(u16, 6),
     serial: Bit(u16, 7),
     dma0: Bit(u16, 8),
     dma1: Bit(u16, 9),

src/core/bus/timer.zig

@@ -128,12 +128,6 @@ fn Timer(comptime id: u2) type {
             };
         }
 
-        pub fn reset(self: *Self) void {
-            const scheduler = self.sched;
-
-            self.* = Self.init(scheduler);
-        }
-
         /// TIMCNT_L Getter
         pub fn timcntL(self: *const Self) u16 {
             if (self.cnt.cascade.read() or !self.cnt.enabled.read()) return self._counter;

src/core/cpu.zig

@@ -39,12 +39,13 @@ pub const arm = struct {
     }
 
     fn populate() [0x1000]InstrFn {
-        comptime {
+        return comptime {
             @setEvalBranchQuota(0xE000);
-            var table = [_]InstrFn{und} ** 0x1000;
+            var ret = [_]InstrFn{und} ** 0x1000;
 
-            for (&table, 0..) |*handler, i| {
+            var i: usize = 0;
-                handler.* = switch (@as(u2, i >> 10)) {
+            while (i < ret.len) : (i += 1) {
+                ret[i] = switch (@as(u2, i >> 10)) {
                     0b00 => if (i == 0x121) blk: {
                         break :blk branchExchange;
                     } else if (i & 0xFCF == 0x009) blk: {
@@ -106,8 +107,8 @@ pub const arm = struct {
                 };
             }
 
-            return table;
+            return ret;
-        }
+        };
     }
 };
 
@@ -135,12 +136,13 @@ pub const thumb = struct {
     }
 
     fn populate() [0x400]InstrFn {
-        comptime {
+        return comptime {
             @setEvalBranchQuota(5025); // This is exact
-            var table = [_]InstrFn{und} ** 0x400;
+            var ret = [_]InstrFn{und} ** 0x400;
 
-            for (&table, 0..) |*handler, i| {
+            var i: usize = 0;
-                handler.* = switch (@as(u3, i >> 7 & 0x7)) {
+            while (i < ret.len) : (i += 1) {
+                ret[i] = switch (@as(u3, i >> 7 & 0x7)) {
                     0b000 => if (i >> 5 & 0x3 == 0b11) blk: {
                         const I = i >> 4 & 1 == 1;
                         const is_sub = i >> 3 & 1 == 1;
@@ -228,8 +230,8 @@ pub const thumb = struct {
                 };
             }
 
-            return table;
+            return ret;
-        }
+        };
     }
 };
 
@@ -314,14 +316,6 @@ pub const Arm7tdmi = struct {
         };
     }
 
-    // FIXME: Resetting disables logging (if enabled)
-    pub fn reset(self: *Self) void {
-        const bus_ptr = self.bus;
-        const scheduler_ptr = self.sched;
-
-        self.* = Self.init(scheduler_ptr, bus_ptr, null);
-    }
-
     pub inline fn hasSPSR(self: *const Self) bool {
         const mode = getModeChecked(self, self.cpsr.mode.read());
         return switch (mode) {
@@ -391,7 +385,8 @@ pub const Arm7tdmi = struct {
         const now = getModeChecked(self, self.cpsr.mode.read());
 
         // Bank R8 -> r12
-        for (0..5) |i| {
+        var i: usize = 0;
+        while (i < 5) : (i += 1) {
             self.bank.fiq[Bank.fiqIdx(i, now)] = self.r[8 + i];
         }
 
@@ -409,7 +404,8 @@ pub const Arm7tdmi = struct {
         }
 
         // Grab R8 -> R12
-        for (0..5) |i| {
+        i = 0;
+        while (i < 5) : (i += 1) {
             self.r[8 + i] = self.bank.fiq[Bank.fiqIdx(i, next)];
         }
 
@@ -474,7 +470,8 @@ pub const Arm7tdmi = struct {
     }
 
     pub fn stepDmaTransfer(self: *Self) bool {
-        inline for (0..4) |i| {
+        comptime var i: usize = 0;
+        inline while (i < 4) : (i += 1) {
             if (self.bus.dma[i].in_progress) {
                 self.bus.dma[i].step(self);
                 return true;
@@ -650,7 +647,7 @@ pub const PSR = extern union {
     }
 };
 
-pub const Mode = enum(u5) {
+const Mode = enum(u5) {
     User = 0b10000,
     Fiq = 0b10001,
     Irq = 0b10010,
@@ -659,7 +656,7 @@ pub const Mode = enum(u5) {
     Undefined = 0b11011,
     System = 0b11111,
 
-    pub fn toString(self: Mode) []const u8 {
+    fn toString(self: Mode) []const u8 {
         return switch (self) {
             .User => "usr",
             .Fiq => "fiq",

src/core/cpu/arm/branch.zig

@@ -2,7 +2,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const sext = @import("zba-util").sext;
+const sext = @import("../../../util.zig").sext;
 
 pub fn branch(comptime L: bool) InstrFn {
     return struct {

src/core/cpu/arm/half_signed_data_transfer.zig

@@ -2,8 +2,8 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const sext = @import("zba-util").sext;
+const sext = @import("../../../util.zig").sext;
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../../util.zig").rotr;
 
 pub fn halfAndSignedDataTransfer(comptime P: bool, comptime U: bool, comptime I: bool, comptime W: bool, comptime L: bool) InstrFn {
     return struct {

src/core/cpu/arm/psr_transfer.zig

@@ -7,7 +7,7 @@ const PSR = @import("../../cpu.zig").PSR;
 
 const log = std.log.scoped(.PsrTransfer);
 
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../../util.zig").rotr;
 
 pub fn psrTransfer(comptime I: bool, comptime R: bool, comptime kind: u2) InstrFn {
     return struct {

src/core/cpu/arm/single_data_swap.zig

@@ -2,7 +2,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../../util.zig").rotr;
 
 pub fn singleDataSwap(comptime B: bool) InstrFn {
     return struct {

src/core/cpu/arm/single_data_transfer.zig

@@ -3,7 +3,7 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").arm.InstrFn;
 
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../../util.zig").rotr;
 
 pub fn singleDataTransfer(comptime I: bool, comptime P: bool, comptime U: bool, comptime B: bool, comptime W: bool, comptime L: bool) InstrFn {
     return struct {

src/core/cpu/barrel_shifter.zig

@@ -1,7 +1,7 @@
 const Arm7tdmi = @import("../cpu.zig").Arm7tdmi;
 const CPSR = @import("../cpu.zig").PSR;
 
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../util.zig").rotr;
 
 pub fn exec(comptime S: bool, cpu: *Arm7tdmi, opcode: u32) u32 {
     var result: u32 = undefined;

src/core/cpu/thumb/block_data_transfer.zig

@@ -92,7 +92,8 @@ pub fn fmt15(comptime L: bool, comptime rb: u3) InstrFn {
 inline fn countRlist(opcode: u16) u32 {
     var count: u32 = 0;
 
-    inline for (0..8) |i| {
+    comptime var i: u4 = 0;
+    inline while (i < 8) : (i += 1) {
         if (opcode >> (7 - i) & 1 == 1) count += 1;
     }
 

src/core/cpu/thumb/branch.zig

@@ -3,7 +3,7 @@ const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").thumb.InstrFn;
 
 const checkCond = @import("../../cpu.zig").checkCond;
-const sext = @import("zba-util").sext;
+const sext = @import("../../../util.zig").sext;
 
 pub fn fmt16(comptime cond: u4) InstrFn {
     return struct {

src/core/cpu/thumb/data_transfer.zig

@@ -2,8 +2,8 @@ const Bus = @import("../../Bus.zig");
 const Arm7tdmi = @import("../../cpu.zig").Arm7tdmi;
 const InstrFn = @import("../../cpu.zig").thumb.InstrFn;
 
-const rotr = @import("zba-util").rotr;
+const rotr = @import("../../../util.zig").rotr;
-const sext = @import("zba-util").sext;
+const sext = @import("../../../util.zig").sext;
 
 pub fn fmt6(comptime rd: u3) InstrFn {
     return struct {

src/core/emu.zig

@@ -4,10 +4,10 @@ const config = @import("../config.zig");
 
 const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
-const Tracker = @import("../util.zig").FpsTracker;
+const FpsTracker = @import("../util.zig").FpsTracker;
-const TwoWayChannel = @import("zba-util").TwoWayChannel;
 
 const Timer = std.time.Timer;
+const Atomic = std.atomic.Atomic;
 
 /// 4 Cycles in 1 dot
 const cycles_per_dot = 4;
@@ -35,41 +35,28 @@ const RunKind = enum {
     LimitedFPS,
 };
 
-pub fn run(cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker, channel: *TwoWayChannel) void {
+pub fn run(quit: *Atomic(bool), scheduler: *Scheduler, cpu: *Arm7tdmi, tracker: *FpsTracker) void {
     const audio_sync = config.config().guest.audio_sync and !config.config().host.mute;
     if (audio_sync) log.info("Audio sync enabled", .{});
 
     if (config.config().guest.video_sync) {
-        inner(.LimitedFPS, audio_sync, cpu, scheduler, tracker, channel);
+        inner(.LimitedFPS, audio_sync, quit, scheduler, cpu, tracker);
     } else {
-        inner(.UnlimitedFPS, audio_sync, cpu, scheduler, tracker, channel);
+        inner(.UnlimitedFPS, audio_sync, quit, scheduler, cpu, tracker);
     }
 }
 
-fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker, channel: *TwoWayChannel) void {
+fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), scheduler: *Scheduler, cpu: *Arm7tdmi, tracker: ?*FpsTracker) void {
     if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
         std.debug.assert(tracker != null);
         log.info("FPS tracking enabled", .{});
     }
 
-    var paused: bool = false;
-
     switch (kind) {
         .Unlimited, .UnlimitedFPS => {
             log.info("Emulation w/out video sync", .{});
 
-            while (true) {
+            while (!quit.load(.Monotonic)) {
-                if (channel.emu.pop()) |e| switch (e) {
-                    .Quit => break,
-                    .Resume => paused = false,
-                    .Pause => {
-                        paused = true;
-                        channel.gui.push(.Paused);
-                    },
-                };
-
-                if (paused) continue;
-
                 runFrame(scheduler, cpu);
                 audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
 
@@ -81,18 +68,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *S
             var timer = Timer.start() catch @panic("failed to initalize std.timer.Timer");
             var wake_time: u64 = frame_period;
 
-            while (true) {
+            while (!quit.load(.Monotonic)) {
-                if (channel.emu.pop()) |e| switch (e) {
-                    .Quit => break,
-                    .Resume => paused = false,
-                    .Pause => {
-                        paused = true;
-                        channel.gui.push(.Paused);
-                    },
-                };
-
-                if (paused) continue;
-
                 runFrame(scheduler, cpu);
                 const new_wake_time = videoSync(&timer, wake_time);
 
@@ -170,8 +146,9 @@ fn sleep(timer: *Timer, wake_time: u64) ?u64 {
 
     const step = 2 * std.time.ns_per_ms; // Granularity of 2ms
     const times = sleep_for / step;
+    var i: usize = 0;
 
-    for (0..times) |_| {
+    while (i < times) : (i += 1) {
         std.time.sleep(step);
 
         // Upon wakeup, check to see if this particular sleep was longer than expected
@@ -242,15 +219,3 @@ pub const EmuThing = struct {
         }
     }
 };
-
-pub fn reset(cpu: *Arm7tdmi) void {
-    // @breakpoint();
-    cpu.sched.reset(); // Yes this is order sensitive, see the PPU reset for why
-    cpu.bus.reset();
-    cpu.reset();
-}
-
-pub fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void {
-    try cpu.bus.replaceGamepak(file_path);
-    reset(cpu);
-}

src/core/ppu.zig

@@ -290,26 +290,6 @@ pub const Ppu = struct {
         };
     }
 
-    pub fn reset(self: *Self) void {
-        self.sched.push(.Draw, 240 * 4);
-
-        self.vram.reset();
-        self.palette.reset();
-        self.oam.reset();
-        self.framebuf.reset();
-
-        self.win = Window.init();
-        self.bg = [_]Background{Background.init()} ** 4;
-        self.aff_bg = [_]AffineBackground{AffineBackground.init()} ** 2;
-        self.bld = Blend.create();
-        self.dispcnt = .{ .raw = 0x0000 };
-        self.dispstat = .{ .raw = 0x0000 };
-        self.vcount = .{ .raw = 0x0000 };
-
-        self.scanline.reset();
-        std.mem.set(?Sprite, self.scanline_sprites, null);
-    }
-
     pub fn deinit(self: *Self) void {
         self.allocator.destroy(self.scanline_sprites);
         self.framebuf.deinit();
@@ -645,7 +625,8 @@ pub const Ppu = struct {
                 const framebuf_base = width * @as(usize, scanline);
                 if (obj_enable) self.fetchSprites();
 
-                for (0..4) |layer| {
+                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);
@@ -659,7 +640,8 @@ pub const Ppu = struct {
                 const framebuf_base = width * @as(usize, scanline);
                 if (obj_enable) self.fetchSprites();
 
-                for (0..4) |layer| {
+                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);
@@ -672,7 +654,8 @@ pub const Ppu = struct {
                 const framebuf_base = width * @as(usize, scanline);
                 if (obj_enable) self.fetchSprites();
 
-                for (0..4) |layer| {
+                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);
@@ -688,7 +671,7 @@ pub const Ppu = struct {
                 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], 0..) |bgr555, i| {
+                for (vram_buf[vram_base .. vram_base + width]) |bgr555, i| {
                     framebuf[framebuf_base + i] = rgba888(bgr555);
                 }
             },
@@ -702,7 +685,7 @@ pub const Ppu = struct {
                 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], 0..) |pal_id, i| {
+                for (self.vram.buf[vram_base .. vram_base + width]) |pal_id, i| {
                     framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]);
                 }
             },
@@ -718,7 +701,8 @@ pub const Ppu = struct {
                 const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
                 const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
 
-                for (0..width) |i| {
+                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);
                 }
@@ -734,7 +718,7 @@ pub const Ppu = struct {
         // 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(), 0..) |maybe_top, i| {
+        for (self.scanline.top()) |maybe_top, i| {
             const maybe_btm = self.scanline.btm()[i];
 
             const bgr555 = self.getBgr555(maybe_top, maybe_btm);

src/core/ppu/Oam.zig

@@ -34,10 +34,6 @@ pub fn init(allocator: Allocator) !Self {
     return Self{ .buf = buf, .allocator = allocator };
 }
 
-pub fn reset(self: *Self) void {
-    std.mem.set(u8, self.buf, 0);
-}
-
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/core/ppu/Palette.zig

@@ -37,10 +37,6 @@ pub fn init(allocator: Allocator) !Self {
     return Self{ .buf = buf, .allocator = allocator };
 }
 
-pub fn reset(self: *Self) void {
-    std.mem.set(u8, self.buf, 0);
-}
-
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/core/ppu/Vram.zig

@@ -45,10 +45,6 @@ pub fn init(allocator: Allocator) !Self {
     return Self{ .buf = buf, .allocator = allocator };
 }
 
-pub fn reset(self: *Self) void {
-    std.mem.set(u8, self.buf, 0);
-}
-
 pub fn deinit(self: *Self) void {
     self.allocator.free(self.buf);
     self.* = undefined;

src/core/scheduler.zig

@@ -11,11 +11,11 @@ const log = std.log.scoped(.Scheduler);
 pub const Scheduler = struct {
     const Self = @This();
 
-    tick: u64 = 0,
+    tick: u64,
     queue: PriorityQueue(Event, void, lessThan),
 
     pub fn init(allocator: Allocator) Self {
-        var sched = Self{ .queue = PriorityQueue(Event, void, lessThan).init(allocator, {}) };
+        var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(allocator, {}) };
         sched.queue.add(.{ .kind = .HeatDeath, .tick = std.math.maxInt(u64) }) catch unreachable;
 
         return sched;
@@ -26,17 +26,6 @@ pub const Scheduler = struct {
         self.* = undefined;
     }
 
-    pub fn reset(self: *Self) void {
-        // `std.PriorityQueue` provides no reset function, so we will just create a new one
-        const allocator = self.queue.allocator;
-        self.queue.deinit();
-
-        var new_queue = PriorityQueue(Event, void, lessThan).init(allocator, {});
-        new_queue.add(.{ .kind = .HeatDeath, .tick = std.math.maxInt(u64) }) catch unreachable;
-
-        self.* = .{ .queue = new_queue };
-    }
-
     pub inline fn now(self: *const Self) u64 {
         return self.tick;
     }
@@ -84,7 +73,7 @@ pub const Scheduler = struct {
 
     /// Removes the **first** scheduled event of type `needle`
     pub fn removeScheduledEvent(self: *Self, needle: EventKind) void {
-        for (self.queue.items, 0..) |event, i| {
+        for (self.queue.items) |event, i| {
             if (std.meta.eql(event.kind, needle)) {
 
                 // invalidates the slice we're iterating over

src/imgui.zig

@@ -1,307 +0,0 @@
-//! Namespace for dealing with ZBA's immediate-mode GUI
-//! Currently, ZBA uses zgui from https://github.com/michal-z/zig-gamedev
-//! which provides Zig bindings for https://github.com/ocornut/imgui under the hood
-
-const std = @import("std");
-const zgui = @import("zgui");
-const gl = @import("gl");
-const nfd = @import("nfd");
-const config = @import("config.zig");
-const emu = @import("core/emu.zig");
-
-const Gui = @import("platform.zig").Gui;
-const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
-const RingBuffer = @import("zba-util").RingBuffer;
-
-const Allocator = std.mem.Allocator;
-const GLuint = gl.GLuint;
-
-const gba_width = @import("core/ppu.zig").width;
-const gba_height = @import("core/ppu.zig").height;
-
-const log = std.log.scoped(.Imgui);
-
-// two seconds worth of fps values into the past
-const histogram_len = 0x80;
-
-/// Immediate-Mode GUI State
-pub const State = struct {
-    title: [12:0]u8,
-
-    fps_hist: RingBuffer(u32),
-    should_quit: bool = false,
-
-    /// if zba is initialized with a ROM already provided, this initializer should be called
-    /// with `title_opt` being non-null
-    pub fn init(allocator: Allocator, title_opt: ?*const [12]u8) !@This() {
-        const history = try allocator.alloc(u32, histogram_len);
-
-        const title: [12:0]u8 = if (title_opt) |t| t.* ++ [_:0]u8{} else "[No Title]\x00\x00".*;
-        return .{ .title = title, .fps_hist = RingBuffer(u32).init(history) };
-    }
-
-    pub fn deinit(self: *@This(), allocator: Allocator) void {
-        allocator.free(self.fps_hist.buf);
-        self.* = undefined;
-    }
-};
-
-pub fn draw(state: *State, tex_id: GLuint, cpu: *Arm7tdmi) void {
-    const win_scale = config.config().host.win_scale;
-
-    {
-        _ = zgui.beginMainMenuBar();
-        defer zgui.endMainMenuBar();
-
-        if (zgui.beginMenu("File", true)) {
-            defer zgui.endMenu();
-
-            if (zgui.menuItem("Quit", .{})) state.should_quit = true;
-
-            if (zgui.menuItem("Insert ROM", .{})) blk: {
-                const maybe_path = nfd.openFileDialog("gba", null) catch |e| {
-                    log.err("failed to open file dialog: {}", .{e});
-                    break :blk;
-                };
-
-                const file_path = maybe_path orelse {
-                    log.warn("did not receive a file path", .{});
-                    break :blk;
-                };
-                defer nfd.freePath(file_path);
-
-                log.info("user chose: \"{s}\"", .{file_path});
-                emu.replaceGamepak(cpu, file_path) catch |e| {
-                    log.err("failed to replace GamePak: {}", .{e});
-                    break :blk;
-                };
-
-                state.title = cpu.bus.pak.title ++ [_:0]u8{};
-            }
-        }
-
-        if (zgui.beginMenu("Emulation", true)) {
-            defer zgui.endMenu();
-
-            if (zgui.menuItem("Restart", .{})) {
-                emu.reset(cpu);
-            }
-        }
-    }
-
-    {
-        const w = @intToFloat(f32, gba_width * win_scale);
-        const h = @intToFloat(f32, gba_height * win_scale);
-
-        const window_title = std.mem.sliceTo(&state.title, 0);
-        _ = zgui.begin(window_title, .{ .flags = .{ .no_resize = true, .always_auto_resize = true } });
-        defer zgui.end();
-
-        zgui.image(@intToPtr(*anyopaque, tex_id), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } });
-    }
-
-    {
-        _ = zgui.begin("Information", .{});
-        defer zgui.end();
-
-        for (0..8) |i| {
-            zgui.text("R{}: 0x{X:0>8}", .{ i, cpu.r[i] });
-
-            zgui.sameLine(.{});
-
-            const padding = if (8 + i < 10) " " else "";
-            zgui.text("{s}R{}: 0x{X:0>8}", .{ padding, 8 + i, cpu.r[8 + i] });
-        }
-
-        zgui.separator();
-
-        widgets.psr("CPSR", cpu.cpsr);
-        widgets.psr("SPSR", cpu.spsr);
-
-        zgui.separator();
-
-        widgets.interrupts(" IE", cpu.bus.io.ie);
-        widgets.interrupts("IRQ", cpu.bus.io.irq);
-    }
-
-    {
-        _ = zgui.begin("Performance", .{});
-        defer zgui.end();
-
-        const tmp = blk: {
-            var buf: [histogram_len]u32 = undefined;
-            const len = state.fps_hist.copy(&buf);
-
-            break :blk .{ buf, len };
-        };
-        const values = tmp[0];
-        const len = tmp[1];
-
-        if (len == values.len) _ = state.fps_hist.pop();
-
-        const sorted = blk: {
-            var buf: @TypeOf(values) = undefined;
-
-            std.mem.copy(u32, buf[0..len], values[0..len]);
-            std.sort.sort(u32, buf[0..len], {}, std.sort.asc(u32));
-
-            break :blk buf;
-        };
-
-        const y_max = 2 * if (len != 0) @intToFloat(f64, sorted[len - 1]) else emu.frame_rate;
-        const x_max = @intToFloat(f64, values.len);
-
-        const y_args = .{ .flags = .{ .no_grid_lines = true } };
-        const x_args = .{ .flags = .{ .no_grid_lines = true, .no_tick_labels = true, .no_tick_marks = true } };
-
-        if (zgui.plot.beginPlot("Emulation FPS", .{ .w = 0.0, .flags = .{ .no_title = true, .no_frame = true } })) {
-            defer zgui.plot.endPlot();
-
-            zgui.plot.setupLegend(.{ .north = true, .east = true }, .{});
-            zgui.plot.setupAxis(.x1, x_args);
-            zgui.plot.setupAxis(.y1, y_args);
-            zgui.plot.setupAxisLimits(.y1, .{ .min = 0.0, .max = y_max, .cond = .always });
-            zgui.plot.setupAxisLimits(.x1, .{ .min = 0.0, .max = x_max, .cond = .always });
-            zgui.plot.setupFinish();
-
-            zgui.plot.plotLineValues("FPS", u32, .{ .v = values[0..len] });
-        }
-
-        const stats: struct { u32, u32, u32 } = blk: {
-            if (len == 0) break :blk .{ 0, 0, 0 };
-
-            const average = average: {
-                var sum: u32 = 0;
-                for (sorted[0..len]) |value| sum += value;
-
-                break :average @intCast(u32, sum / len);
-            };
-            const median = sorted[len / 2];
-            const low = sorted[len / 100]; // 1% Low
-
-            break :blk .{ average, median, low };
-        };
-
-        zgui.text("Average: {:0>3} fps", .{stats[0]});
-        zgui.text(" Median: {:0>3} fps", .{stats[1]});
-        zgui.text(" 1% Low: {:0>3} fps", .{stats[2]});
-    }
-
-    {
-        _ = zgui.begin("Scheduler", .{});
-        defer zgui.end();
-
-        const scheduler = cpu.sched;
-
-        zgui.text("tick: {X:0>16}", .{scheduler.tick});
-        zgui.separator();
-
-        const Event = std.meta.Child(@TypeOf(scheduler.queue.items));
-
-        var items: [20]Event = undefined;
-        const len = scheduler.queue.len;
-
-        std.mem.copy(Event, &items, scheduler.queue.items);
-        std.sort.sort(Event, items[0..len], {}, widgets.eventDesc(Event));
-
-        for (items[0..len]) |event| {
-            zgui.text("{X:0>16} | {?}", .{ event.tick, event.kind });
-        }
-    }
-
-    // {
-    //     zgui.showDemoWindow(null);
-    // }
-}
-
-const widgets = struct {
-    fn interrupts(comptime label: []const u8, int: anytype) void {
-        const h = 15.0;
-        const w = 9.0 * 2 + 3.5;
-        const ww = 9.0 * 3;
-
-        {
-            zgui.text(label ++ ":", .{});
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("VBL", .{ .w = w, .h = h, .selected = int.vblank.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("HBL", .{ .w = w, .h = h, .selected = int.hblank.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("VCT", .{ .w = w, .h = h, .selected = int.coincidence.read() });
-
-            {
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM0", .{ .w = ww, .h = h, .selected = int.tim0.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM1", .{ .w = ww, .h = h, .selected = int.tim1.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM2", .{ .w = ww, .h = h, .selected = int.tim2.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("TIM3", .{ .w = ww, .h = h, .selected = int.tim3.read() });
-            }
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("SRL", .{ .w = w, .h = h, .selected = int.serial.read() });
-
-            {
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA0", .{ .w = ww, .h = h, .selected = int.dma0.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA1", .{ .w = ww, .h = h, .selected = int.dma1.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA2", .{ .w = ww, .h = h, .selected = int.dma2.read() });
-
-                zgui.sameLine(.{});
-                _ = zgui.selectable("DMA3", .{ .w = ww, .h = h, .selected = int.dma3.read() });
-            }
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("KPD", .{ .w = w, .h = h, .selected = int.keypad.read() });
-
-            zgui.sameLine(.{});
-            _ = zgui.selectable("GPK", .{ .w = w, .h = h, .selected = int.game_pak.read() });
-        }
-    }
-
-    fn psr(comptime label: []const u8, register: anytype) void {
-        const Mode = @import("core/cpu.zig").Mode;
-
-        const maybe_mode = std.meta.intToEnum(Mode, register.mode.read()) catch null;
-        const mode = if (maybe_mode) |mode| mode.toString() else "???";
-        const w = 9.0;
-        const h = 15.0;
-
-        zgui.text(label ++ ": 0x{X:0>8}", .{register.raw});
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("N", .{ .w = w, .h = h, .selected = register.n.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("Z", .{ .w = w, .h = h, .selected = register.z.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("C", .{ .w = w, .h = h, .selected = register.c.read() });
-
-        zgui.sameLine(.{});
-        _ = zgui.selectable("V", .{ .w = w, .h = h, .selected = register.v.read() });
-
-        zgui.sameLine(.{});
-        zgui.text("{s}", .{mode});
-    }
-
-    fn eventDesc(comptime T: type) fn (void, T, T) bool {
-        return struct {
-            fn inner(_: void, left: T, right: T) bool {
-                return left.tick > right.tick;
-            }
-        }.inner;
-    }
-};

src/main.zig

@@ -6,7 +6,6 @@ const clap = @import("clap");
 const config = @import("config.zig");
 const emu = @import("core/emu.zig");
 
-const TwoWayChannel = @import("zba-util").TwoWayChannel;
 const Gui = @import("platform.zig").Gui;
 const Bus = @import("core/Bus.zig");
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
@@ -14,8 +13,11 @@ const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FilePaths = @import("util.zig").FilePaths;
 const FpsTracker = @import("util.zig").FpsTracker;
 const Allocator = std.mem.Allocator;
+const Atomic = std.atomic.Atomic;
 
 const log = std.log.scoped(.Cli);
+const width = @import("core/ppu.zig").width;
+const height = @import("core/ppu.zig").height;
 pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;
 
 // CLI Arguments + Help Text
@@ -70,10 +72,9 @@ pub fn main() void {
     const paths = handleArguments(allocator, data_path, &result) catch |e| exitln("failed to handle cli arguments: {}", .{e});
     defer if (paths.save) |path| allocator.free(path);
 
-    const log_file = switch (config.config().debug.cpu_trace) {
+    const log_file = if (config.config().debug.cpu_trace) blk: {
-        true => std.fs.cwd().createFile("zba.log", .{}) catch |e| exitln("failed to create trace log file: {}", .{e}),
+        break :blk std.fs.cwd().createFile("zba.log", .{}) catch |e| exitln("failed to create trace log file: {}", .{e});
-        false => null,
+    } else null;
-    };
     defer if (log_file) |file| file.close();
 
     // TODO: Take Emulator Init Code out of main.zig
@@ -90,17 +91,10 @@ pub fn main() void {
         cpu.fastBoot();
     }
 
-    const title_ptr = if (paths.rom != null) &bus.pak.title else null;
+    var quit = Atomic(bool).init(false);
-
+    var gui = Gui.init(&bus.pak.title, &bus.apu, width, height) catch |e| exitln("failed to init gui: {}", .{e});
-    // TODO: Just copy the title instead of grabbing a pointer to it
-    var gui = Gui.init(allocator, &bus.apu, title_ptr) catch |e| exitln("failed to init gui: {}", .{e});
     defer gui.deinit();
 
-    var quit = std.atomic.Atomic(bool).init(false);
-
-    var items: [0x100]u8 = undefined;
-    var channel = TwoWayChannel.init(&items);
-
     if (result.args.gdb) {
         const Server = @import("gdbstub").Server;
         const EmuThing = @import("core/emu.zig").EmuThing;
@@ -122,26 +116,26 @@ pub fn main() void {
         gui.run(.{
             .cpu = &cpu,
             .scheduler = &scheduler,
-            .channel = &channel,
+            .quit = &quit,
         }) catch |e| exitln("main thread panicked: {}", .{e});
     } else {
         var tracker = FpsTracker.init();
 
-        const thread = std.Thread.spawn(.{}, emu.run, .{ &cpu, &scheduler, &tracker, &channel }) catch |e| exitln("emu thread panicked: {}", .{e});
+        const thread = std.Thread.spawn(.{}, emu.run, .{ &quit, &scheduler, &cpu, &tracker }) catch |e| exitln("emu thread panicked: {}", .{e});
         defer thread.join();
 
         gui.run(.{
             .cpu = &cpu,
             .scheduler = &scheduler,
-            .channel = &channel,
             .tracker = &tracker,
+            .quit = &quit,
         }) catch |e| exitln("main thread panicked: {}", .{e});
     }
 }
 
-fn handleArguments(allocator: Allocator, data_path: []const u8, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !FilePaths {
+pub fn handleArguments(allocator: Allocator, data_path: []const u8, result: *const clap.Result(clap.Help, &params, clap.parsers.default)) !FilePaths {
     const rom_path = romPath(result);
-    log.info("ROM path: {?s}", .{rom_path});
+    log.info("ROM path: {s}", .{rom_path});
 
     const bios_path = result.args.bios;
     if (bios_path) |path| log.info("BIOS path: {s}", .{path}) else log.warn("No BIOS provided", .{});
@@ -190,10 +184,10 @@ fn ensureConfigDirExists(config_path: []const u8) !void {
     try dir.makePath("zba");
 }
 
-fn romPath(result: *const clap.Result(clap.Help, &params, clap.parsers.default)) ?[]const u8 {
+fn romPath(result: *const clap.Result(clap.Help, &params, clap.parsers.default)) []const u8 {
     return switch (result.positionals.len) {
-        0 => null,
         1 => result.positionals[0],
+        0 => exitln("ZBA requires a path to a GamePak ROM", .{}),
         else => exitln("ZBA received too many positional arguments.", .{}),
     };
 }

src/platform.zig

@@ -1,36 +1,25 @@
 const std = @import("std");
 const SDL = @import("sdl2");
 const gl = @import("gl");
-const zgui = @import("zgui");
-
 const emu = @import("core/emu.zig");
 const config = @import("config.zig");
-const imgui = @import("imgui.zig");
 
 const Apu = @import("core/apu.zig").Apu;
 const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 const Scheduler = @import("core/scheduler.zig").Scheduler;
 const FpsTracker = @import("util.zig").FpsTracker;
-const TwoWayChannel = @import("zba-util").TwoWayChannel;
 
 const gba_width = @import("core/ppu.zig").width;
 const gba_height = @import("core/ppu.zig").height;
 
-const GLuint = gl.GLuint;
-const GLsizei = gl.GLsizei;
-const SDL_GLContext = *anyopaque;
-const Allocator = std.mem.Allocator;
-
-const width = 1280;
-const height = 720;
-
 pub const sample_rate = 1 << 15;
 pub const sample_format = SDL.AUDIO_U16;
 
-const window_title = "ZBA";
+const default_title = "ZBA";
 
 pub const Gui = struct {
     const Self = @This();
+    const SDL_GLContext = *anyopaque; // SDL.SDL_GLContext is a ?*anyopaque
     const log = std.log.scoped(.Gui);
 
     // zig fmt: off
@@ -50,25 +39,25 @@ pub const Gui = struct {
 
     window: *SDL.SDL_Window,
     ctx: SDL_GLContext,
+    title: []const u8,
     audio: Audio,
 
-    state: imgui.State,
-
-    allocator: Allocator,
     program_id: gl.GLuint,
 
-    pub fn init(allocator: Allocator, apu: *Apu, title_opt: ?*const [12]u8) !Self {
+    pub fn init(title: *const [12]u8, apu: *Apu, width: i32, height: i32) !Self {
         if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_EVENTS | SDL.SDL_INIT_AUDIO) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_PROFILE_MASK, SDL.SDL_GL_CONTEXT_PROFILE_CORE) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
         if (SDL.SDL_GL_SetAttribute(SDL.SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0) panic();
 
+        const win_scale = @intCast(c_int, config.config().host.win_scale);
+
         const window = SDL.SDL_CreateWindow(
-            window_title,
+            default_title,
             SDL.SDL_WINDOWPOS_CENTERED,
             SDL.SDL_WINDOWPOS_CENTERED,
-            width,
+            @as(c_int, width * win_scale),
-            height,
+            @as(c_int, height * win_scale),
             SDL.SDL_WINDOW_OPENGL | SDL.SDL_WINDOW_SHOWN,
         ) orelse panic();
 
@@ -78,60 +67,19 @@ pub const Gui = struct {
         gl.load(ctx, Self.glGetProcAddress) catch {};
         if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();
 
-        zgui.init(allocator);
+        const program_id = try compileShaders();
-        zgui.plot.init();
-        zgui.backend.init(window, ctx, "#version 330 core");
-
-        // zgui.io.setIniFilename(null);
 
         return Self{
             .window = window,
+            .title = std.mem.sliceTo(title, 0),
             .ctx = ctx,
-            .program_id = try compileShaders(),
+            .program_id = program_id,
             .audio = Audio.init(apu),
-
-            .allocator = allocator,
-            .state = try imgui.State.init(allocator, title_opt),
         };
     }
 
-    pub fn deinit(self: *Self) void {
+    fn compileShaders() !gl.GLuint {
-        self.audio.deinit();
+        // TODO: Panic on Shader Compiler Failure + Error Message
-        self.state.deinit(self.allocator);
-
-        zgui.backend.deinit();
-        zgui.plot.deinit();
-        zgui.deinit();
-
-        gl.deleteProgram(self.program_id);
-        SDL.SDL_GL_DeleteContext(self.ctx);
-        SDL.SDL_DestroyWindow(self.window);
-        SDL.SDL_Quit();
-
-        self.* = undefined;
-    }
-
-    fn drawGbaTexture(self: *const Self, obj_ids: struct { GLuint, GLuint, GLuint }, tex_id: GLuint, buf: []const u8) void {
-        gl.bindTexture(gl.TEXTURE_2D, tex_id);
-        defer gl.bindTexture(gl.TEXTURE_2D, 0);
-
-        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
-
-        // Bind VAO, EBO. VBO not bound
-        gl.bindVertexArray(obj_ids[0]); // VAO
-        defer gl.bindVertexArray(0);
-
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, obj_ids[2]); // EBO
-        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
-
-        // Use compiled frag + vertex shader
-        gl.useProgram(self.program_id);
-        defer gl.useProgram(0);
-
-        gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
-    }
-
-    fn compileShaders() !GLuint {
         const vert_shader = @embedFile("shader/pixelbuf.vert");
         const frag_shader = @embedFile("shader/pixelbuf.frag");
 
@@ -160,29 +108,24 @@ pub const Gui = struct {
     }
 
     // Returns the VAO ID since it's used in run()
-    fn genBufferObjects() struct { GLuint, GLuint, GLuint } {
+    fn generateBuffers() struct { c_uint, c_uint, c_uint } {
-        var vao_id: GLuint = undefined;
+        var vao_id: c_uint = undefined;
-        var vbo_id: GLuint = undefined;
+        var vbo_id: c_uint = undefined;
-        var ebo_id: GLuint = undefined;
+        var ebo_id: c_uint = undefined;
-
         gl.genVertexArrays(1, &vao_id);
         gl.genBuffers(1, &vbo_id);
         gl.genBuffers(1, &ebo_id);
 
         gl.bindVertexArray(vao_id);
-        defer gl.bindVertexArray(0);
 
         gl.bindBuffer(gl.ARRAY_BUFFER, vbo_id);
-        defer gl.bindBuffer(gl.ARRAY_BUFFER, 0);
+        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
 
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo_id);
-        defer gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0);
-
-        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
         gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, @sizeOf(@TypeOf(indices)), &indices, gl.STATIC_DRAW);
 
         // Position
-        gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), null); // lmao
+        gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, 0)); // lmao
         gl.enableVertexAttribArray(0);
         // Colour
         gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, (3 * @sizeOf(f32))));
@@ -194,56 +137,25 @@ pub const Gui = struct {
         return .{ vao_id, vbo_id, ebo_id };
     }
 
-    fn genGbaTexture(buf: []const u8) GLuint {
+    fn generateTexture(buf: []const u8) c_uint {
-        var tex_id: GLuint = undefined;
+        var tex_id: c_uint = undefined;
         gl.genTextures(1, &tex_id);
-
         gl.bindTexture(gl.TEXTURE_2D, tex_id);
-        defer gl.bindTexture(gl.TEXTURE_2D, 0);
+
+        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        // gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
 
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, buf.ptr);
+        // gl.generateMipmap(gl.TEXTURE_2D); // TODO: Remove?
 
         return tex_id;
     }
 
-    fn genOutTexture() GLuint {
-        var tex_id: GLuint = undefined;
-        gl.genTextures(1, &tex_id);
-
-        gl.bindTexture(gl.TEXTURE_2D, tex_id);
-        defer gl.bindTexture(gl.TEXTURE_2D, 0);
-
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gba_width, gba_height, 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, null);
-
-        return tex_id;
-    }
-
-    fn genFrameBufObject(tex_id: c_uint) !GLuint {
-        var fbo_id: GLuint = undefined;
-        gl.genFramebuffers(1, &fbo_id);
-
-        gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
-        defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
-
-        gl.framebufferTexture(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex_id, 0);
-
-        const draw_buffers: [1]GLuint = .{gl.COLOR_ATTACHMENT0};
-        gl.drawBuffers(1, &draw_buffers);
-
-        if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE)
-            return error.FrameBufferObejctInitFailed;
-
-        return fbo_id;
-    }
-
     const RunOptions = struct {
-        channel: *TwoWayChannel,
+        quit: *std.atomic.Atomic(bool),
         tracker: ?*FpsTracker = null,
         cpu: *Arm7tdmi,
         scheduler: *Scheduler,
@@ -252,34 +164,29 @@ pub const Gui = struct {
     pub fn run(self: *Self, opt: RunOptions) !void {
         const cpu = opt.cpu;
         const tracker = opt.tracker;
-        const channel = opt.channel;
+        const quit = opt.quit;
 
-        const obj_ids = Self.genBufferObjects();
+        var buffer_ids = Self.generateBuffers();
-        defer gl.deleteBuffers(3, @as(*const [3]c_uint, &obj_ids));
+        defer {
+            gl.deleteBuffers(1, &buffer_ids[2]); // EBO
+            gl.deleteBuffers(1, &buffer_ids[1]); // VBO
+            gl.deleteVertexArrays(1, &buffer_ids[0]); // VAO
+        }
+        const vao_id = buffer_ids[0];
 
-        const emu_tex = Self.genGbaTexture(cpu.bus.ppu.framebuf.get(.Renderer));
+        const tex_id = Self.generateTexture(cpu.bus.ppu.framebuf.get(.Renderer));
-        const out_tex = Self.genOutTexture();
+        defer gl.deleteTextures(1, &tex_id);
-        defer gl.deleteTextures(2, &[_]c_uint{ emu_tex, out_tex });
 
-        const fbo_id = try Self.genFrameBufObject(out_tex);
+        var title_buf: [0x100]u8 = undefined;
-        defer gl.deleteFramebuffers(1, &fbo_id);
 
         emu_loop: while (true) {
-            // `quit` from RunOptions may be modified by the GDBSTUB thread,
-            // so we want to recognize that it may change to `true` and exit the GUI thread
-            if (channel.gui.pop()) |event| switch (event) {
-                .Quit => break :emu_loop,
-                .Paused => @panic("TODO: We want to peek (and then pop if it's .Quit), not always pop"),
-            };
-
-            // Outside of `SDL.SDL_QUIT` below, the DearImgui UI might signal that the program
-            // should exit, in which case we should also handle this
-            if (self.state.should_quit) break :emu_loop;
-
             var event: SDL.SDL_Event = undefined;
-            while (SDL.SDL_PollEvent(&event) != 0) {
-                _ = zgui.backend.processEvent(&event);
 
+            // This might be true if the emu is running via a gdbstub server
+            // and the gdb stub exits first
+            if (quit.load(.Monotonic)) break :emu_loop;
+
+            while (SDL.SDL_PollEvent(&event) != 0) {
                 switch (event.type) {
                     SDL.SDL_QUIT => break :emu_loop,
                     SDL.SDL_KEYDOWN => {
@@ -317,6 +224,12 @@ pub const Gui = struct {
                             SDL.SDLK_s => keyinput.shoulder_r.set(),
                             SDL.SDLK_RETURN => keyinput.start.set(),
                             SDL.SDLK_RSHIFT => keyinput.select.set(),
+                            SDL.SDLK_i => {
+                                comptime std.debug.assert(sample_format == SDL.AUDIO_U16);
+                                log.err("Sample Count: {}", .{@intCast(u32, SDL.SDL_AudioStreamAvailable(cpu.bus.apu.stream)) / (2 * @sizeOf(u16))});
+                            },
+                            // SDL.SDLK_j => log.err("Scheduler Capacity: {} | Scheduler Event Count: {}", .{ scheduler.queue.capacity(), scheduler.queue.count() }),
+                            SDL.SDLK_k => {},
                             else => {},
                         }
 
@@ -326,44 +239,31 @@ pub const Gui = struct {
                 }
             }
 
-            {
+            // Emulator has an internal Double Buffer
-                channel.emu.push(.Pause);
+            const framebuf = cpu.bus.ppu.framebuf.get(.Renderer);
-                defer channel.emu.push(.Resume);
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, framebuf.ptr);
-
-                // Spin Loop until we know that the emu is paused
-                wait: while (true) switch (channel.gui.pop() orelse continue) {
-                    .Paused => break :wait,
-                    else => |any| std.debug.panic("[Gui/Channel]: Unhandled Event: {}", .{any}),
-                };
-
-                // Add FPS count to the histogram
-                if (tracker) |t| self.state.fps_hist.push(t.value()) catch {};
-
-                // Draw GBA Screen to Texture
-                {
-                    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo_id);
-                    defer gl.bindFramebuffer(gl.FRAMEBUFFER, 0);
-
-                    const buf = cpu.bus.ppu.framebuf.get(.Renderer);
-                    gl.viewport(0, 0, gba_width, gba_height);
-                    self.drawGbaTexture(obj_ids, emu_tex, buf);
-                }
-
-                // Background Colour
-                const size = zgui.io.getDisplaySize();
-                gl.viewport(0, 0, @floatToInt(c_int, size[0]), @floatToInt(c_int, size[1]));
-                gl.clearColor(0, 0, 0, 1.0);
-                gl.clear(gl.COLOR_BUFFER_BIT);
-
-                zgui.backend.newFrame(width, height);
-                imgui.draw(&self.state, out_tex, cpu);
-                zgui.backend.draw();
-            }
 
+            gl.useProgram(self.program_id);
+            gl.bindVertexArray(vao_id);
+            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, null);
             SDL.SDL_GL_SwapWindow(self.window);
+
+            if (tracker) |t| {
+                const dyn_title = std.fmt.bufPrintZ(&title_buf, "ZBA | {s} [Emu: {}fps] ", .{ self.title, t.value() }) catch unreachable;
+                SDL.SDL_SetWindowTitle(self.window, dyn_title.ptr);
+            }
         }
 
-        channel.emu.push(.Quit);
+        quit.store(true, .Monotonic); // Terminate Emulator Thread
+    }
+
+    pub fn deinit(self: *Self) void {
+        self.audio.deinit();
+        gl.deleteProgram(self.program_id);
+        SDL.SDL_GL_DeleteContext(self.ctx);
+        SDL.SDL_DestroyWindow(self.window);
+        SDL.SDL_Quit();
+        self.* = undefined;
     }
 
     fn glGetProcAddress(ctx: SDL.SDL_GLContext, proc: [:0]const u8) ?*anyopaque {

src/util.zig

@@ -7,6 +7,27 @@ const Arm7tdmi = @import("core/cpu.zig").Arm7tdmi;
 
 const Allocator = std.mem.Allocator;
 
+// Sign-Extend value of type `T` to type `U`
+pub fn sext(comptime T: type, comptime U: type, value: T) T {
+    // U must have less bits than T
+    comptime std.debug.assert(@typeInfo(U).Int.bits <= @typeInfo(T).Int.bits);
+
+    const iT = std.meta.Int(.signed, @typeInfo(T).Int.bits);
+    const ExtU = if (@typeInfo(U).Int.signedness == .unsigned) T else iT;
+    const shift_amt = @intCast(Log2Int(T), @typeInfo(T).Int.bits - @typeInfo(U).Int.bits);
+
+    return @bitCast(T, @bitCast(iT, @as(ExtU, @truncate(U, value)) << shift_amt) >> shift_amt);
+}
+
+/// See https://godbolt.org/z/W3en9Eche
+pub inline fn rotr(comptime T: type, x: T, r: anytype) T {
+    if (@typeInfo(T).Int.signedness == .signed)
+        @compileError("cannot rotate signed integer");
+
+    const ar = @intCast(Log2Int(T), @mod(r, @typeInfo(T).Int.bits));
+    return x >> ar | x << (1 +% ~ar);
+}
+
 pub const FpsTracker = struct {
     const Self = @This();
 
@@ -36,6 +57,17 @@ pub const FpsTracker = struct {
     }
 };
 
+pub fn intToBytes(comptime T: type, value: anytype) [@sizeOf(T)]u8 {
+    comptime std.debug.assert(@typeInfo(T) == .Int);
+
+    var result: [@sizeOf(T)]u8 = undefined;
+
+    var i: Log2Int(T) = 0;
+    while (i < result.len) : (i += 1) result[i] = @truncate(u8, value >> i * @bitSizeOf(u8));
+
+    return result;
+}
+
 /// Creates a copy of a title with all Filesystem-invalid characters replaced
 ///
 /// e.g. POKEPIN R/S to POKEPIN R_S
@@ -50,7 +82,7 @@ pub fn escape(title: [12]u8) [12]u8 {
 }
 
 pub const FilePaths = struct {
-    rom: ?[]const u8,
+    rom: []const u8,
     bios: ?[]const u8,
     save: ?[]const u8,
 };
@@ -251,7 +283,7 @@ pub const FrameBuffer = struct {
 
     layers: [2][]u8,
     buf: []u8,
-    current: u1 = 0,
+    current: u1,
 
     allocator: Allocator,
 
@@ -266,16 +298,12 @@ pub const FrameBuffer = struct {
             // Front and Back Framebuffers
             .layers = [_][]u8{ buf[0..][0..len], buf[len..][0..len] },
             .buf = buf,
+            .current = 0,
 
             .allocator = allocator,
         };
     }
 
-    pub fn reset(self: *Self) void {
-        std.mem.set(u8, self.buf, 0);
-        self.current = 0;
-    }
-
     pub fn deinit(self: *Self) void {
         self.allocator.free(self.buf);
         self.* = undefined;