const std = @import("std"); const builtin = @import("builtin"); const SDL = @import("sdl2"); const clap = @import("clap"); const known_folders = @import("known_folders"); const emu = @import("emu.zig"); const Bus = @import("Bus.zig"); const Apu = @import("apu.zig").Apu; const Arm7tdmi = @import("cpu.zig").Arm7tdmi; const Scheduler = @import("scheduler.zig").Scheduler; const FpsTracker = @import("util.zig").FpsTracker; const Timer = std.time.Timer; const Thread = std.Thread; const Atomic = std.atomic.Atomic; const File = std.fs.File; const window_scale = 4; const gba_width = @import("ppu.zig").width; const gba_height = @import("ppu.zig").height; const framebuf_pitch = @import("ppu.zig").framebuf_pitch; const expected_rate = @import("emu.zig").frame_rate; const sample_rate = @import("apu.zig").host_sample_rate; pub const enable_logging: bool = false; const is_binary: bool = false; const log = std.log.scoped(.GUI); pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level; const asString = @import("util.zig").asString; // CLI Arguments + Help Text const params = clap.parseParamsComptime( \\-h, --help Display this help and exit. \\-b, --bios Optional path to a GBA BIOS ROM. \\ Path to the GBA GamePak ROM \\ ); pub fn main() anyerror!void { // Allocator for Emulator + CLI var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer std.debug.assert(!gpa.deinit()); const alloc = gpa.allocator(); // Setup CLI using zig-clap var res = try clap.parse(clap.Help, ¶ms, clap.parsers.default, .{}); defer res.deinit(); const stderr = std.io.getStdErr(); defer stderr.close(); // Display Help, if requested // Grab ROM and BIOS paths if provided if (res.args.help) return clap.help(stderr.writer(), clap.Help, ¶ms, .{}); const rom_path = try getRomPath(res, stderr); const bios_path: ?[]const u8 = if (res.args.bios) |p| p else null; // Determine Save Directory const save_dir = try getSavePath(alloc); defer if (save_dir) |path| alloc.free(path); log.info("Found save directory: {s}", .{save_dir}); // Initialize Scheduler and ARM7TDMI Emulator // Provide GBA Bus (initialized with ARM7TDMI) with a valid ptr to ARM7TDMI var scheduler = Scheduler.init(alloc); defer scheduler.deinit(); const paths = .{ .bios = bios_path, .rom = rom_path, .save = save_dir }; var cpu = try Arm7tdmi.init(alloc, &scheduler, paths); defer cpu.deinit(); cpu.bus.attach(&cpu); // cpu.fastBoot(); // Uncomment to skip BIOS // Copy ROM title while Emulator still belongs to this thread const title = cpu.bus.pak.title; // Initialize SDL2 initSdl2(); defer SDL.SDL_Quit(); const dev = initAudio(&cpu.bus.apu); defer SDL.SDL_CloseAudioDevice(dev); // TODO: Refactor or delete this Logging code // I probably still need logging in some form though (e.g. Golden Sun IIRC) const log_file: ?File = if (enable_logging) blk: { const file = try std.fs.cwd().createFile(if (is_binary) "zba.bin" else "zba.log", .{}); cpu.useLogger(&file, is_binary); break :blk file; } else null; defer if (log_file) |file| file.close(); var quit = Atomic(bool).init(false); var emu_rate = FpsTracker.init(); // Run Emulator in it's separate thread // From this point on, interacting with Arm7tdmi or Scheduler // be justified, as it will require to be thread-afe const emu_thread = try Thread.spawn(.{}, emu.run, .{ .LimitedFPS, &quit, &emu_rate, &scheduler, &cpu }); defer emu_thread.join(); var title_buf: [0x20]u8 = std.mem.zeroes([0x20]u8); const window_title = try std.fmt.bufPrint(&title_buf, "ZBA | {s}", .{asString(title)}); const window = createWindow(window_title, gba_width, gba_height); defer SDL.SDL_DestroyWindow(window); const renderer = createRenderer(window); defer SDL.SDL_DestroyRenderer(renderer); const texture = createTexture(renderer, gba_width, gba_height); defer SDL.SDL_DestroyTexture(texture); // Init FPS Timer var dyn_title_buf: [0x100]u8 = [_]u8{0x00} ** 0x100; emu_loop: while (true) { var event: SDL.SDL_Event = undefined; while (SDL.SDL_PollEvent(&event) != 0) { switch (event.type) { SDL.SDL_QUIT => break :emu_loop, SDL.SDL_KEYDOWN => { const io = &cpu.bus.io; const key_code = event.key.keysym.sym; switch (key_code) { SDL.SDLK_UP => io.keyinput.up.unset(), SDL.SDLK_DOWN => io.keyinput.down.unset(), SDL.SDLK_LEFT => io.keyinput.left.unset(), SDL.SDLK_RIGHT => io.keyinput.right.unset(), SDL.SDLK_x => io.keyinput.a.unset(), SDL.SDLK_z => io.keyinput.b.unset(), SDL.SDLK_a => io.keyinput.shoulder_l.unset(), SDL.SDLK_s => io.keyinput.shoulder_r.unset(), SDL.SDLK_RETURN => io.keyinput.start.unset(), SDL.SDLK_RSHIFT => io.keyinput.select.unset(), else => {}, } }, SDL.SDL_KEYUP => { const io = &cpu.bus.io; const key_code = event.key.keysym.sym; switch (key_code) { SDL.SDLK_UP => io.keyinput.up.set(), SDL.SDLK_DOWN => io.keyinput.down.set(), SDL.SDLK_LEFT => io.keyinput.left.set(), SDL.SDLK_RIGHT => io.keyinput.right.set(), SDL.SDLK_x => io.keyinput.a.set(), SDL.SDLK_z => io.keyinput.b.set(), SDL.SDLK_a => io.keyinput.shoulder_l.set(), SDL.SDLK_s => io.keyinput.shoulder_r.set(), SDL.SDLK_RETURN => io.keyinput.start.set(), SDL.SDLK_RSHIFT => io.keyinput.select.set(), SDL.SDLK_i => 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() }), else => {}, } }, else => {}, } } // Emulator has an internal Double Buffer const buf_ptr = cpu.bus.ppu.framebuf.get(.Renderer).ptr; _ = SDL.SDL_UpdateTexture(texture, null, buf_ptr, framebuf_pitch); _ = SDL.SDL_RenderCopy(renderer, texture, null, null); SDL.SDL_RenderPresent(renderer); const dyn_title = std.fmt.bufPrint(&dyn_title_buf, "{s} [Emu: {}fps] ", .{ window_title, emu_rate.value() }) catch unreachable; SDL.SDL_SetWindowTitle(window, dyn_title.ptr); } quit.store(true, .SeqCst); // Terminate Emulator Thread } const CliError = error{ InsufficientOptions, UnneededOptions, }; fn sdlPanic() noreturn { const str = @as(?[*:0]const u8, SDL.SDL_GetError()) orelse "unknown error"; @panic(std.mem.sliceTo(str, 0)); } fn initSdl2() void { const status = SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_EVENTS | SDL.SDL_INIT_AUDIO | SDL.SDL_INIT_GAMECONTROLLER); if (status < 0) sdlPanic(); } fn createWindow(title: []u8, width: c_int, height: c_int) *SDL.SDL_Window { return SDL.SDL_CreateWindow( title.ptr, SDL.SDL_WINDOWPOS_CENTERED, SDL.SDL_WINDOWPOS_CENTERED, width * window_scale, height * window_scale, SDL.SDL_WINDOW_SHOWN, ) orelse sdlPanic(); } fn createRenderer(window: *SDL.SDL_Window) *SDL.SDL_Renderer { return SDL.SDL_CreateRenderer(window, -1, SDL.SDL_RENDERER_ACCELERATED | SDL.SDL_RENDERER_PRESENTVSYNC) orelse sdlPanic(); } fn createTexture(renderer: *SDL.SDL_Renderer, width: c_int, height: c_int) *SDL.SDL_Texture { return SDL.SDL_CreateTexture( renderer, SDL.SDL_PIXELFORMAT_RGBA8888, SDL.SDL_TEXTUREACCESS_STREAMING, width, height, ) orelse sdlPanic(); } fn initAudio(apu: *Apu) SDL.SDL_AudioDeviceID { var have: SDL.SDL_AudioSpec = undefined; var want: SDL.SDL_AudioSpec = .{ .freq = sample_rate, .format = SDL.AUDIO_U16, .channels = 2, .samples = 0x100, .callback = audioCallback, .userdata = apu, .silence = undefined, .size = undefined, .padding = undefined, }; const dev = SDL.SDL_OpenAudioDevice(null, 0, &want, &have, 0); if (dev == 0) sdlPanic(); // Start Playback on the Audio device SDL.SDL_PauseAudioDevice(dev, 0); return dev; } export fn audioCallback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void { const apu = @ptrCast(*Apu, @alignCast(8, userdata)); const written = SDL.SDL_AudioStreamGet(apu.stream, stream, len); // If we don't write anything, play silence otherwise garbage will be played // FIXME: I don't think this hack to remove DC Offset is acceptable :thinking: if (written == 0) std.mem.set(u8, stream[0..@intCast(usize, len)], 0x80); } fn getSavePath(alloc: std.mem.Allocator) !?[]const u8 { const save_subpath = "zba" ++ [_]u8{std.fs.path.sep} ++ "save"; const maybe_data_path = try known_folders.getPath(alloc, .data); defer if (maybe_data_path) |path| alloc.free(path); const save_path = if (maybe_data_path) |base| try std.fs.path.join(alloc, &[_][]const u8{ base, "zba", "save" }) else null; if (save_path) |_| { // If we've determined what our save path should be, ensure the prereq directories // are present so that we can successfully write to the path when necessary const maybe_data_dir = try known_folders.open(alloc, .data, .{}); if (maybe_data_dir) |data_dir| try data_dir.makePath(save_subpath); } return save_path; } fn getRomPath(res: clap.Result(clap.Help, ¶ms, clap.parsers.default), stderr: std.fs.File) ![]const u8 { return switch (res.positionals.len) { 1 => res.positionals[0], 0 => { try stderr.writeAll("ZBA requires a positional path to a GamePak ROM.\n"); return CliError.InsufficientOptions; }, else => { try stderr.writeAll("ZBA received too many arguments.\n"); return CliError.UnneededOptions; }, }; }