chore: update nfd-zig

respond to build.zig changes in zig master

.gitignore

@@ -11,4 +11,8 @@
 /lib/SDL2
 
 # Any Custom Scripts for Debugging purposes
-*.sh
+*.sh
+
+
+# Dear ImGui
+**/imgui.ini

.gitmodules

@@ -13,3 +13,9 @@
 [submodule "lib/zig-toml"]
 	path = lib/zig-toml
 	url = https://github.com/aeronavery/zig-toml
+[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

build.zig

@@ -1,6 +1,9 @@
 const std = @import("std");
 const builtin = @import("builtin");
+
 const Sdk = @import("lib/SDL.zig/Sdk.zig");
+const zgui = @import("lib/zgui/build.zig");
+const nfd = @import("lib/nfd-zig/build.zig");
 
 pub fn build(b: *std.build.Builder) void {
     // Minimum Zig Version
@@ -41,11 +44,21 @@ pub fn build(b: *std.build.Builder) void {
     // OpenGL 3.3 Bindings
     exe.addPackagePath("gl", "lib/gl.zig");
 
+    // NativeFileDialog(ue) Bindings
+    exe.linkLibrary(nfd.makeLib(b, target, optimize));
+    exe.addPackage(nfd.getPackage("nfd"));
+
     // Zig SDL Bindings: https://github.com/MasterQ32/SDL.zig
     const sdk = Sdk.init(b, null);
     sdk.link(exe, .dynamic);
     exe.addPackage(sdk.getNativePackage("sdl2"));
 
+    // Dear ImGui bindings
+    const zgui_options = zgui.BuildOptionsStep.init(b, .{ .backend = .sdl2_opengl3 });
+    const zgui_pkg = zgui.getPkg(&.{zgui_options.getPkg()});
+    zgui.link(exe, zgui_options);
+    exe.addPackage(zgui_pkg);
+
     exe.install();
 
     const run_cmd = exe.run();

lib/nfd-zig

@@ -0,0 +1 @@
+Subproject commit b8d56260294636f9d7bf596cb558b697e873793f

lib/zgui

@@ -0,0 +1 @@
+Subproject commit f9744ec8d613028b908896c410be937b5513f73b

src/core/bus/GamePak.zig

@@ -188,7 +188,7 @@ pub fn init(allocator: Allocator, cpu: *Arm7tdmi, rom_path: []const u8, save_pat
     const kind = Backup.guess(file_buf);
     const device = if (config.config().guest.force_rtc) .Rtc else guessDevice(file_buf);
 
-    logHeader(file_buf, &title);
+    logHeader(file_buf, title);
 
     return .{
         .buf = file_buf,
@@ -219,19 +219,17 @@ fn guessDevice(buf: []const u8) Gpio.Device.Kind {
     }
 
     // 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];
+fn logHeader(buf: []const u8, title: [12]u8) void {
+    const ver = buf[0xBC];
 
     log.info("Title: {s}", .{title});
-    if (version != 0) log.info("Version: {}", .{version});
-    log.info("Game Code: {s}", .{code});
-    log.info("Maker Code: {s}", .{maker});
+    if (ver != 0) log.info("Version: {}", .{ver});
+
+    log.info("Game Code: {s}", .{buf[0xAC..0xB0]});
+    log.info("Maker Code: {s}", .{buf[0xB0..0xB2]});
 }
 
 test "OOB Access" {

src/core/bus/io.zig

@@ -346,10 +346,10 @@ const InterruptEnable = extern union {
     vblank: Bit(u16, 0),
     hblank: Bit(u16, 1),
     coincidence: Bit(u16, 2),
-    tm0_overflow: Bit(u16, 3),
-    tm1_overflow: Bit(u16, 4),
-    tm2_overflow: Bit(u16, 5),
-    tm3_overflow: Bit(u16, 6),
+    tim0: Bit(u16, 3),
+    tim1: Bit(u16, 4),
+    tim2: Bit(u16, 5),
+    tim3: Bit(u16, 6),
     serial: Bit(u16, 7),
     dma0: Bit(u16, 8),
     dma1: Bit(u16, 9),

src/core/cpu.zig

@@ -647,7 +647,7 @@ pub const PSR = extern union {
     }
 };
 
-const Mode = enum(u5) {
+pub const Mode = enum(u5) {
     User = 0b10000,
     Fiq = 0b10001,
     Irq = 0b10010,
@@ -656,7 +656,7 @@ const Mode = enum(u5) {
     Undefined = 0b11011,
     System = 0b11111,
 
-    fn toString(self: Mode) []const u8 {
+    pub fn toString(self: Mode) []const u8 {
         return switch (self) {
             .User => "usr",
             .Fiq => "fiq",

src/core/emu.zig

@@ -4,7 +4,7 @@ const config = @import("../config.zig");
 
 const Scheduler = @import("scheduler.zig").Scheduler;
 const Arm7tdmi = @import("cpu.zig").Arm7tdmi;
-const FpsTracker = @import("../util.zig").FpsTracker;
+const Tracker = @import("../util.zig").FpsTracker;
 
 const Timer = std.time.Timer;
 const Atomic = std.atomic.Atomic;
@@ -35,18 +35,18 @@ const RunKind = enum {
     LimitedFPS,
 };
 
-pub fn run(quit: *Atomic(bool), scheduler: *Scheduler, cpu: *Arm7tdmi, tracker: *FpsTracker) void {
+pub fn run(quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: *Tracker) 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, quit, scheduler, cpu, tracker);
+        inner(.LimitedFPS, audio_sync, quit, pause, cpu, scheduler, tracker);
     } else {
-        inner(.UnlimitedFPS, audio_sync, quit, scheduler, cpu, tracker);
+        inner(.UnlimitedFPS, audio_sync, quit, pause, cpu, scheduler, tracker);
     }
 }
 
-fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), scheduler: *Scheduler, cpu: *Arm7tdmi, tracker: ?*FpsTracker) void {
+fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), pause: *Atomic(bool), cpu: *Arm7tdmi, scheduler: *Scheduler, tracker: ?*Tracker) void {
     if (kind == .UnlimitedFPS or kind == .LimitedFPS) {
         std.debug.assert(tracker != null);
         log.info("FPS tracking enabled", .{});
@@ -57,6 +57,8 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
             log.info("Emulation w/out video sync", .{});
 
             while (!quit.load(.Monotonic)) {
+                if (pause.load(.Monotonic)) continue;
+
                 runFrame(scheduler, cpu);
                 audioSync(audio_sync, cpu.bus.apu.stream, &cpu.bus.apu.is_buffer_full);
 
@@ -69,6 +71,8 @@ fn inner(comptime kind: RunKind, audio_sync: bool, quit: *Atomic(bool), schedule
             var wake_time: u64 = frame_period;
 
             while (!quit.load(.Monotonic)) {
+                if (pause.load(.Monotonic)) continue;
+
                 runFrame(scheduler, cpu);
                 const new_wake_time = videoSync(&timer, wake_time);
 

src/main.zig

@@ -13,8 +13,6 @@ const FilePaths = @import("util.zig").FilePaths;
 
 const Allocator = std.mem.Allocator;
 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
@@ -87,7 +85,8 @@ pub fn main() void {
         cpu.fastBoot();
     }
 
-    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.pak.title, &bus.apu) catch |e| exitln("failed to init gui: {}", .{e});
     defer gui.deinit();
 
     gui.run(&cpu, &scheduler) catch |e| exitln("failed to run gui thread: {}", .{e});

src/platform.zig

@@ -1,6 +1,9 @@
 const std = @import("std");
 const SDL = @import("sdl2");
 const gl = @import("gl");
+const zgui = @import("zgui");
+const nfd = @import("nfd");
+
 const emu = @import("core/emu.zig");
 const config = @import("config.zig");
 
@@ -8,10 +11,19 @@ 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 RingBuffer = @import("util.zig").RingBuffer;
 
 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;
 
@@ -19,9 +31,23 @@ 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);
 
+    const State = struct {
+        fps_hist: RingBuffer(u32),
+        should_quit: bool = false,
+
+        pub fn init(allocator: Allocator) !@This() {
+            const history = try allocator.alloc(u32, 0x400);
+            return .{ .fps_hist = RingBuffer(u32).init(history) };
+        }
+
+        fn deinit(self: *@This(), allocator: Allocator) void {
+            self.fps_hist.deinit(allocator);
+            self.* = undefined;
+        }
+    };
+
     // zig fmt: off
     const vertices: [32]f32 = [_]f32{
         // Positions        // Colours      // Texture Coords
@@ -39,25 +65,26 @@ pub const Gui = struct {
 
     window: *SDL.SDL_Window,
     ctx: SDL_GLContext,
-    title: []const u8,
+    title: [:0]const u8,
     audio: Audio,
 
+    state: State,
+
+    allocator: Allocator,
     program_id: gl.GLuint,
 
-    pub fn init(title: *const [12]u8, apu: *Apu, width: i32, height: i32) !Self {
+    pub fn init(allocator: Allocator, title: [12]u8, apu: *Apu) !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(
             default_title,
             SDL.SDL_WINDOWPOS_CENTERED,
             SDL.SDL_WINDOWPOS_CENTERED,
-            @as(c_int, width * win_scale),
-            @as(c_int, height * win_scale),
+            width,
+            height,
             SDL.SDL_WINDOW_OPENGL | SDL.SDL_WINDOW_SHOWN,
         ) orelse panic();
 
@@ -67,19 +94,62 @@ pub const Gui = struct {
         gl.load(ctx, Self.glGetProcAddress) catch {};
         if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();
 
-        const program_id = try compileShaders();
+        zgui.init(allocator);
+        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),
+            .title = try allocator.dupeZ(u8, &title),
             .ctx = ctx,
-            .program_id = program_id,
+            .program_id = try compileShaders(),
             .audio = Audio.init(apu),
+
+            .allocator = allocator,
+            .state = try State.init(allocator),
         };
     }
 
-    fn compileShaders() !gl.GLuint {
-        // TODO: Panic on Shader Compiler Failure + Error Message
+    pub fn deinit(self: *Self) void {
+        self.audio.deinit();
+        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.allocator.free(self.title);
+        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");
 
@@ -108,20 +178,25 @@ pub const Gui = struct {
     }
 
     // Returns the VAO ID since it's used in run()
-    fn generateBuffers() struct { c_uint, c_uint, c_uint } {
-        var vao_id: c_uint = undefined;
-        var vbo_id: c_uint = undefined;
-        var ebo_id: c_uint = undefined;
+    fn genBufferObjects() struct { GLuint, GLuint, GLuint } {
+        var vao_id: GLuint = undefined;
+        var vbo_id: GLuint = undefined;
+        var ebo_id: GLuint = 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);
-        gl.bufferData(gl.ARRAY_BUFFER, @sizeOf(@TypeOf(vertices)), &vertices, gl.STATIC_DRAW);
+        defer gl.bindBuffer(gl.ARRAY_BUFFER, 0);
 
         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
@@ -137,46 +212,242 @@ pub const Gui = struct {
         return .{ vao_id, vbo_id, ebo_id };
     }
 
-    fn generateTexture(buf: []const u8) c_uint {
-        var tex_id: c_uint = undefined;
+    fn genGbaTexture(buf: []const u8) GLuint {
+        var tex_id: GLuint = undefined;
         gl.genTextures(1, &tex_id);
-        gl.bindTexture(gl.TEXTURE_2D, tex_id);
 
-        // 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.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, buf.ptr);
-        // gl.generateMipmap(gl.TEXTURE_2D); // TODO: Remove?
 
         return tex_id;
     }
 
-    pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
-        var quit = std.atomic.Atomic(bool).init(false);
-        var tracker = FpsTracker.init();
+    fn genOutTexture() GLuint {
+        var tex_id: GLuint = undefined;
+        gl.genTextures(1, &tex_id);
 
-        var buffer_ids = Self.generateBuffers();
-        defer {
-            gl.deleteBuffers(1, &buffer_ids[2]); // EBO
-            gl.deleteBuffers(1, &buffer_ids[1]); // VBO
-            gl.deleteVertexArrays(1, &buffer_ids[0]); // VAO
+        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;
+    }
+
+    fn draw(self: *Self, tex_id: GLuint, cpu: *const 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", .{})) self.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;
+                    };
+
+                    if (maybe_path) |file_path| {
+                        defer nfd.freePath(file_path);
+                        log.info("user chose: \"{s}\"", .{file_path});
+
+                        // emu.loadRom(cpu, file_path);
+                    }
+                }
+            }
+
+            if (zgui.beginMenu("Emulation", true)) {
+                defer zgui.endMenu();
+
+                if (zgui.menuItem("Restart", .{})) log.warn("TODO: Restart Emulator", .{});
+            }
         }
-        const vao_id = buffer_ids[0];
 
-        const tex_id = Self.generateTexture(cpu.bus.ppu.framebuf.get(.Renderer));
-        defer gl.deleteTextures(1, &tex_id);
+        {
+            const w = @intToFloat(f32, gba_width * win_scale);
+            const h = @intToFloat(f32, gba_height * win_scale);
 
-        const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, scheduler, cpu, &tracker });
+            _ = zgui.begin(self.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();
+
+            {
+                var i: usize = 0;
+                while (i < 8) : (i += 1) {
+                    zgui.text("R{}: 0x{X:0>8}", .{ i, cpu.r[i] });
+
+                    zgui.sameLine(.{});
+
+                    const prefix = if (8 + i < 10) " " else "";
+                    zgui.text("{s}R{}: 0x{X:0>8}", .{ prefix, 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); // space is for padding
+            widgets.interrupts("IRQ", cpu.bus.io.irq);
+        }
+
+        {
+            _ = zgui.begin("Performance", .{});
+            defer zgui.end();
+
+            const tmp = blk: {
+                var buf: [0x400]u32 = undefined;
+                const len = self.state.fps_hist.copy(&buf);
+
+                break :blk .{ buf, len };
+            };
+            const values = tmp[0];
+            const len = tmp[1];
+
+            if (len == values.len) _ = self.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);
+        }
+    }
+
+    pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
+        const obj_ids = Self.genBufferObjects();
+        defer gl.deleteBuffers(3, @as(*const [3]c_uint, &obj_ids));
+
+        const emu_tex = Self.genGbaTexture(cpu.bus.ppu.framebuf.get(.Renderer));
+        const out_tex = Self.genOutTexture();
+        defer gl.deleteTextures(2, &[_]c_uint{ emu_tex, out_tex });
+
+        const fbo_id = try Self.genFrameBufObject(out_tex);
+        defer gl.deleteFramebuffers(1, &fbo_id);
+
+        var tracker = FpsTracker.init();
+        var quit = std.atomic.Atomic(bool).init(false);
+        var pause = std.atomic.Atomic(bool).init(false);
+
+        const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &pause, cpu, scheduler, &tracker });
         defer thread.join();
-
-        var title_buf: [0x100]u8 = undefined;
+        defer quit.store(true, .Monotonic); // Terminate Emulator Thread
 
         emu_loop: while (true) {
             var event: SDL.SDL_Event = undefined;
+
+            // Quit Signal from Dear Imgui
+            if (self.state.should_quit) break :emu_loop;
+
             while (SDL.SDL_PollEvent(&event) != 0) {
+                _ = zgui.backend.processEvent(&event);
+
                 switch (event.type) {
                     SDL.SDL_QUIT => break :emu_loop,
                     SDL.SDL_KEYDOWN => {
@@ -214,12 +485,6 @@ 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 => {},
                         }
 
@@ -229,29 +494,36 @@ pub const Gui = struct {
                 }
             }
 
-            // Emulator has an internal Double Buffer
-            const framebuf = cpu.bus.ppu.framebuf.get(.Renderer);
-            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gba_width, gba_height, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, framebuf.ptr);
+            // We Access non-atomic parts of the Emulator here
+            {
+                pause.store(true, .Monotonic);
+                defer pause.store(false, .Monotonic);
+
+                self.state.fps_hist.push(tracker.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);
+                self.draw(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);
-
-            const dyn_title = std.fmt.bufPrintZ(&title_buf, "ZBA | {s} [Emu: {}fps] ", .{ self.title, tracker.value() }) catch unreachable;
-            SDL.SDL_SetWindowTitle(self.window, dyn_title.ptr);
         }
-
-        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 {
@@ -329,3 +601,95 @@ fn panic() noreturn {
     const str = @as(?[*:0]const u8, SDL.SDL_GetError()) orelse "unknown error";
     @panic(std.mem.sliceTo(str, 0));
 }
+
+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/util.zig

@@ -317,3 +317,78 @@ pub const FrameBuffer = struct {
         return self.layers[if (dev == .Emulator) self.current else ~self.current];
     }
 };
+
+pub fn RingBuffer(comptime T: type) type {
+    return struct {
+        const Self = @This();
+        const Index = usize;
+        const max_capacity = (@as(Index, 1) << @typeInfo(Index).Int.bits - 1) - 1; // half the range of index type
+
+        const log = std.log.scoped(.RingBuffer);
+
+        read: Index,
+        write: Index,
+        buf: []T,
+
+        const Error = error{buffer_full};
+
+        pub fn init(buf: []T) Self {
+            std.debug.assert(std.math.isPowerOfTwo(buf.len)); // capacity must be a power of two
+            std.debug.assert(buf.len <= max_capacity);
+
+            std.mem.set(T, buf, 0);
+
+            return .{ .read = 0, .write = 0, .buf = buf };
+        }
+
+        pub fn deinit(self: *Self, allocator: Allocator) void {
+            allocator.free(self.buf);
+            self.* = undefined;
+        }
+
+        pub fn push(self: *Self, value: T) Error!void {
+            if (self.isFull()) return error.buffer_full;
+            defer self.write += 1;
+
+            self.buf[self.mask(self.write)] = value;
+        }
+
+        pub fn pop(self: *Self) ?T {
+            if (self.isEmpty()) return null;
+            defer self.read += 1;
+
+            return self.buf[self.mask(self.read)];
+        }
+
+        /// Returns the number of entries read
+        pub fn copy(self: *const Self, cpy: []T) Index {
+            const count = std.math.min(self.len(), cpy.len);
+            var start: Index = self.read;
+
+            for (cpy) |*v, i| {
+                if (i >= count) break;
+
+                v.* = self.buf[self.mask(start)];
+                start += 1;
+            }
+
+            return count;
+        }
+
+        fn len(self: *const Self) Index {
+            return self.write - self.read;
+        }
+
+        fn isFull(self: *const Self) bool {
+            return self.len() == self.buf.len;
+        }
+
+        fn isEmpty(self: *const Self) bool {
+            return self.read == self.write;
+        }
+
+        fn mask(self: *const Self, idx: Index) Index {
+            return idx & (self.buf.len - 1);
+        }
+    };
+}