Compare commits
1 Commits
8b018bdc49
...
59063fb2c4
| Author | SHA1 | Date |
|---|---|---|
 Rekai Nyangadzayi Musuka
|
59063fb2c4 |
|
|
@ -1 +1 @@
|
|||
Subproject commit d66925011971fbe221fc2a7f7cb4cd8c181d9ba3
|
||||
Subproject commit 401c50ff3d0b83ad4bd89caf580ce1bd90fb5618
|
||||
|
|
@ -14,7 +14,7 @@ fn PtrCastPreserveCV(comptime T: type, comptime PtrToT: type, comptime NewT: typ
|
|||
fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: usize) type {
|
||||
const self_bit: FieldType = (1 << shamt);
|
||||
|
||||
return extern struct {
|
||||
return struct {
|
||||
bits: Bitfield(FieldType, shamt, 1),
|
||||
|
||||
pub fn set(self: anytype) void {
|
||||
|
|
@ -63,7 +63,7 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
|
|||
|
||||
const ValueType = std.meta.Int(.unsigned, num_bits);
|
||||
|
||||
return extern struct {
|
||||
return struct {
|
||||
dummy: FieldType,
|
||||
|
||||
fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {
|
||||
|
|
|
|||
31
src/Gui.zig
31
src/Gui.zig
|
|
@ -11,6 +11,7 @@ const pitch = @import("core/ppu.zig").framebuf_pitch;
|
|||
const scale = @import("core/emu.zig").win_scale;
|
||||
|
||||
const emu = @import("core/emu.zig");
|
||||
const asString = @import("core/util.zig").asString;
|
||||
const log = std.log.scoped(.GUI);
|
||||
|
||||
const default_title: []const u8 = "ZBA";
|
||||
|
|
@ -53,11 +54,11 @@ pub fn init(title: [12]u8, width: i32, height: i32) Self {
|
|||
};
|
||||
}
|
||||
|
||||
pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
|
||||
pub fn run(self: *Self, arm7tdmi: *Arm7tdmi, scheduler: *Scheduler) !void {
|
||||
var quit = std.atomic.Atomic(bool).init(false);
|
||||
var frame_rate = FpsTracker.init();
|
||||
|
||||
const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &frame_rate, scheduler, cpu });
|
||||
const thread = try std.Thread.spawn(.{}, emu.run, .{ &quit, &frame_rate, scheduler, arm7tdmi });
|
||||
defer thread.join();
|
||||
|
||||
var title_buf: [0x100]u8 = [_]u8{0} ** 0x100;
|
||||
|
|
@ -68,7 +69,7 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
|
|||
switch (event.type) {
|
||||
SDL.SDL_QUIT => break :emu_loop,
|
||||
SDL.SDL_KEYDOWN => {
|
||||
const io = &cpu.bus.io;
|
||||
const io = &arm7tdmi.bus.io;
|
||||
const key_code = event.key.keysym.sym;
|
||||
|
||||
switch (key_code) {
|
||||
|
|
@ -86,7 +87,7 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
|
|||
}
|
||||
},
|
||||
SDL.SDL_KEYUP => {
|
||||
const io = &cpu.bus.io;
|
||||
const io = &arm7tdmi.bus.io;
|
||||
const key_code = event.key.keysym.sym;
|
||||
|
||||
switch (key_code) {
|
||||
|
|
@ -100,12 +101,12 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
|
|||
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_i => log.err("Sample Count: {}", .{@intCast(u32, SDL.SDL_AudioStreamAvailable(arm7tdmi.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 => {
|
||||
// Dump IWRAM to file
|
||||
log.info("PC: 0x{X:0>8}", .{cpu.r[15]});
|
||||
log.info("LR: 0x{X:0>8}", .{cpu.r[14]});
|
||||
log.info("PC: 0x{X:0>8}", .{arm7tdmi.r[15]});
|
||||
log.info("LR: 0x{X:0>8}", .{arm7tdmi.r[14]});
|
||||
// const iwram_file = try std.fs.cwd().createFile("iwram.bin", .{});
|
||||
// defer iwram_file.close();
|
||||
|
||||
|
|
@ -119,7 +120,7 @@ pub fn run(self: *Self, cpu: *Arm7tdmi, scheduler: *Scheduler) !void {
|
|||
}
|
||||
|
||||
// Emulator has an internal Double Buffer
|
||||
const framebuf = cpu.bus.ppu.framebuf.get(.Renderer);
|
||||
const framebuf = arm7tdmi.bus.ppu.framebuf.get(.Renderer);
|
||||
_ = SDL.SDL_UpdateTexture(self.texture, null, framebuf.ptr, pitch);
|
||||
_ = SDL.SDL_RenderCopy(self.renderer, self.texture, null, null);
|
||||
SDL.SDL_RenderPresent(self.renderer);
|
||||
|
|
@ -136,13 +137,12 @@ pub fn initAudio(self: *Self, apu: *Apu) void {
|
|||
self.audio.?.play();
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.audio) |*aud| aud.deinit();
|
||||
pub fn deinit(self: Self) void {
|
||||
if (self.audio) |aud| aud.deinit();
|
||||
SDL.SDL_DestroyTexture(self.texture);
|
||||
SDL.SDL_DestroyRenderer(self.renderer);
|
||||
SDL.SDL_DestroyWindow(self.window);
|
||||
SDL.SDL_Quit();
|
||||
self.* = undefined;
|
||||
}
|
||||
|
||||
const Audio = struct {
|
||||
|
|
@ -169,13 +169,12 @@ const Audio = struct {
|
|||
};
|
||||
}
|
||||
|
||||
fn deinit(self: *This) void {
|
||||
SDL.SDL_CloseAudioDevice(self.device);
|
||||
self.* = undefined;
|
||||
fn deinit(this: This) void {
|
||||
SDL.SDL_CloseAudioDevice(this.device);
|
||||
}
|
||||
|
||||
pub fn play(self: *This) void {
|
||||
SDL.SDL_PauseAudioDevice(self.device, 0);
|
||||
pub fn play(this: *This) void {
|
||||
SDL.SDL_PauseAudioDevice(this.device, 0);
|
||||
}
|
||||
|
||||
export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {
|
||||
|
|
|
|||
|
|
@ -49,29 +49,32 @@ io: Io,
|
|||
cpu: ?*Arm7tdmi,
|
||||
sched: *Scheduler,
|
||||
|
||||
pub fn init(self: *Self, allocator: Allocator, sched: *Scheduler, cpu: *Arm7tdmi, paths: FilePaths) !void {
|
||||
self.* = .{
|
||||
.pak = try GamePak.init(allocator, paths.rom, paths.save),
|
||||
.bios = try Bios.init(allocator, paths.bios),
|
||||
.ppu = try Ppu.init(allocator, sched),
|
||||
pub fn init(alloc: Allocator, sched: *Scheduler, paths: FilePaths) !Self {
|
||||
return Self{
|
||||
.pak = try GamePak.init(alloc, paths.rom, paths.save),
|
||||
.bios = try Bios.init(alloc, paths.bios),
|
||||
.ppu = try Ppu.init(alloc, sched),
|
||||
.apu = Apu.init(sched),
|
||||
.iwram = try Iwram.init(allocator),
|
||||
.ewram = try Ewram.init(allocator),
|
||||
.iwram = try Iwram.init(alloc),
|
||||
.ewram = try Ewram.init(alloc),
|
||||
.dma = createDmaTuple(),
|
||||
.tim = createTimerTuple(sched),
|
||||
.io = Io.init(),
|
||||
.cpu = cpu,
|
||||
.cpu = null,
|
||||
.sched = sched,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
pub fn deinit(self: Self) void {
|
||||
self.iwram.deinit();
|
||||
self.ewram.deinit();
|
||||
self.pak.deinit();
|
||||
self.bios.deinit();
|
||||
self.ppu.deinit();
|
||||
self.* = undefined;
|
||||
}
|
||||
|
||||
pub fn attach(self: *Self, cpu: *Arm7tdmi) void {
|
||||
self.cpu = cpu;
|
||||
}
|
||||
|
||||
pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
|
||||
|
|
|
|||
|
|
@ -444,29 +444,29 @@ const ToneSweep = struct {
|
|||
};
|
||||
}
|
||||
|
||||
pub fn tick(self: *This, ch1: *Self) void {
|
||||
if (self.timer != 0) self.timer -= 1;
|
||||
pub fn tick(this: *This, ch1: *Self) void {
|
||||
if (this.timer != 0) this.timer -= 1;
|
||||
|
||||
if (self.timer == 0) {
|
||||
if (this.timer == 0) {
|
||||
const period = ch1.sweep.period.read();
|
||||
self.timer = if (period == 0) 8 else period;
|
||||
if (!self.calc_performed) self.calc_performed = true;
|
||||
this.timer = if (period == 0) 8 else period;
|
||||
if (!this.calc_performed) this.calc_performed = true;
|
||||
|
||||
if (self.enabled and period != 0) {
|
||||
const new_freq = self.calcFrequency(ch1);
|
||||
if (this.enabled and period != 0) {
|
||||
const new_freq = this.calcFrequency(ch1);
|
||||
|
||||
if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) {
|
||||
ch1.freq.frequency.write(@truncate(u11, new_freq));
|
||||
self.shadow = @truncate(u11, new_freq);
|
||||
this.shadow = @truncate(u11, new_freq);
|
||||
|
||||
_ = self.calcFrequency(ch1);
|
||||
_ = this.calcFrequency(ch1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn calcFrequency(self: *This, ch1: *Self) u12 {
|
||||
const shadow = @as(u12, self.shadow);
|
||||
fn calcFrequency(this: *This, ch1: *Self) u12 {
|
||||
const shadow = @as(u12, this.shadow);
|
||||
const shadow_shifted = shadow >> ch1.sweep.shift.read();
|
||||
const decrease = ch1.sweep.direction.read();
|
||||
|
||||
|
|
|
|||
|
|
@ -8,28 +8,27 @@ pub const size = 0x4000;
|
|||
const Self = @This();
|
||||
|
||||
buf: ?[]u8,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
addr_latch: u32,
|
||||
|
||||
pub fn init(allocator: Allocator, maybe_path: ?[]const u8) !Self {
|
||||
const buf: ?[]u8 = if (maybe_path) |path| blk: {
|
||||
pub fn init(alloc: Allocator, maybe_path: ?[]const u8) !Self {
|
||||
var buf: ?[]u8 = null;
|
||||
if (maybe_path) |path| {
|
||||
const file = try std.fs.cwd().openFile(path, .{});
|
||||
defer file.close();
|
||||
|
||||
break :blk try file.readToEndAlloc(allocator, try file.getEndPos());
|
||||
} else null;
|
||||
buf = try file.readToEndAlloc(alloc, try file.getEndPos());
|
||||
}
|
||||
|
||||
return Self{
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
.addr_latch = 0,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.buf) |buf| self.allocator.free(buf);
|
||||
self.* = undefined;
|
||||
pub fn deinit(self: Self) void {
|
||||
if (self.buf) |buf| self.alloc.free(buf);
|
||||
}
|
||||
|
||||
pub fn read(self: *Self, comptime T: type, r15: u32, addr: u32) T {
|
||||
|
|
|
|||
|
|
@ -5,21 +5,20 @@ const ewram_size = 0x40000;
|
|||
const Self = @This();
|
||||
|
||||
buf: []u8,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
pub fn init(allocator: Allocator) !Self {
|
||||
const buf = try allocator.alloc(u8, ewram_size);
|
||||
pub fn init(alloc: Allocator) !Self {
|
||||
const buf = try alloc.alloc(u8, ewram_size);
|
||||
std.mem.set(u8, buf, 0);
|
||||
|
||||
return Self{
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
pub fn deinit(self: Self) void {
|
||||
self.alloc.free(self.buf);
|
||||
}
|
||||
|
||||
pub fn read(self: *const Self, comptime T: type, address: usize) T {
|
||||
|
|
|
|||
|
|
@ -10,24 +10,24 @@ const Self = @This();
|
|||
|
||||
title: [12]u8,
|
||||
buf: []u8,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
backup: Backup,
|
||||
gpio: Gpio,
|
||||
|
||||
pub fn init(allocator: Allocator, rom_path: []const u8, save_path: ?[]const u8) !Self {
|
||||
pub fn init(alloc: Allocator, rom_path: []const u8, save_path: ?[]const u8) !Self {
|
||||
const file = try std.fs.cwd().openFile(rom_path, .{});
|
||||
defer file.close();
|
||||
|
||||
const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
|
||||
const file_buf = try file.readToEndAlloc(alloc, try file.getEndPos());
|
||||
const title = parseTitle(file_buf);
|
||||
const kind = Backup.guessKind(file_buf) orelse .None;
|
||||
|
||||
var pak = Self{
|
||||
.buf = file_buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
.title = title,
|
||||
.backup = try Backup.init(allocator, kind, title, save_path),
|
||||
.gpio = Gpio.init(allocator, .Rtc),
|
||||
.gpio = Gpio.init(alloc, .Rtc),
|
||||
.backup = try Backup.init(alloc, kind, title, save_path),
|
||||
};
|
||||
pak.parseHeader();
|
||||
|
||||
|
|
@ -80,11 +80,10 @@ inline fn isLarge(self: *const Self) bool {
|
|||
return self.buf.len > 0x100_0000;
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
pub fn deinit(self: Self) void {
|
||||
self.alloc.free(self.buf);
|
||||
self.backup.deinit();
|
||||
self.gpio.deinit(self.allocator);
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
self.gpio.deinit(self.alloc);
|
||||
}
|
||||
|
||||
pub fn read(self: *Self, comptime T: type, address: u32) T {
|
||||
|
|
@ -469,10 +468,10 @@ const Clock = struct {
|
|||
};
|
||||
|
||||
const GpioData = extern union {
|
||||
sck: Bit(u8, 0),
|
||||
sio: Bit(u8, 1),
|
||||
cs: Bit(u8, 2),
|
||||
raw: u8,
|
||||
sck: Bit(u4, 0),
|
||||
sio: Bit(u4, 1),
|
||||
cs: Bit(u4, 2),
|
||||
raw: u4,
|
||||
};
|
||||
|
||||
const Control = extern union {
|
||||
|
|
|
|||
|
|
@ -5,21 +5,20 @@ const iwram_size = 0x8000;
|
|||
const Self = @This();
|
||||
|
||||
buf: []u8,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
pub fn init(allocator: Allocator) !Self {
|
||||
const buf = try allocator.alloc(u8, iwram_size);
|
||||
pub fn init(alloc: Allocator) !Self {
|
||||
const buf = try alloc.alloc(u8, iwram_size);
|
||||
std.mem.set(u8, buf, 0);
|
||||
|
||||
return Self{
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
pub fn deinit(self: Self) void {
|
||||
self.alloc.free(self.buf);
|
||||
}
|
||||
|
||||
pub fn read(self: *const Self, comptime T: type, address: usize) T {
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ const Allocator = std.mem.Allocator;
|
|||
const log = std.log.scoped(.Backup);
|
||||
|
||||
const escape = @import("../util.zig").escape;
|
||||
const asStringSlice = @import("../util.zig").asStringSlice;
|
||||
const asString = @import("../util.zig").asString;
|
||||
|
||||
const backup_kinds = [5]Needle{
|
||||
.{ .str = "EEPROM_V", .kind = .Eeprom },
|
||||
|
|
@ -17,8 +17,8 @@ pub const Backup = struct {
|
|||
const Self = @This();
|
||||
|
||||
buf: []u8,
|
||||
allocator: Allocator,
|
||||
kind: Kind,
|
||||
alloc: Allocator,
|
||||
kind: BackupKind,
|
||||
|
||||
title: [12]u8,
|
||||
save_path: ?[]const u8,
|
||||
|
|
@ -26,15 +26,7 @@ pub const Backup = struct {
|
|||
flash: Flash,
|
||||
eeprom: Eeprom,
|
||||
|
||||
const Kind = enum {
|
||||
Eeprom,
|
||||
Sram,
|
||||
Flash,
|
||||
Flash1M,
|
||||
None,
|
||||
};
|
||||
|
||||
pub fn init(allocator: Allocator, kind: Kind, title: [12]u8, path: ?[]const u8) !Self {
|
||||
pub fn init(alloc: Allocator, kind: BackupKind, title: [12]u8, path: ?[]const u8) !Self {
|
||||
log.info("Kind: {}", .{kind});
|
||||
|
||||
const buf_size: usize = switch (kind) {
|
||||
|
|
@ -44,24 +36,24 @@ pub const Backup = struct {
|
|||
.None, .Eeprom => 0, // EEPROM is handled upon first Read Request to it
|
||||
};
|
||||
|
||||
const buf = try allocator.alloc(u8, buf_size);
|
||||
const buf = try alloc.alloc(u8, buf_size);
|
||||
std.mem.set(u8, buf, 0xFF);
|
||||
|
||||
var backup = Self{
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
.kind = kind,
|
||||
.title = title,
|
||||
.save_path = path,
|
||||
.flash = Flash.init(),
|
||||
.eeprom = Eeprom.init(allocator),
|
||||
.eeprom = Eeprom.init(alloc),
|
||||
};
|
||||
|
||||
if (backup.save_path) |p| backup.loadSaveFromDisk(allocator, p) catch |e| log.err("Failed to load save: {}", .{e});
|
||||
if (backup.save_path) |p| backup.loadSaveFromDisk(p) catch |e| log.err("Failed to load save: {}", .{e});
|
||||
return backup;
|
||||
}
|
||||
|
||||
pub fn guessKind(rom: []const u8) ?Kind {
|
||||
pub fn guessKind(rom: []const u8) ?BackupKind {
|
||||
for (backup_kinds) |needle| {
|
||||
const needle_len = needle.str.len;
|
||||
|
||||
|
|
@ -74,15 +66,14 @@ pub const Backup = struct {
|
|||
return null;
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
if (self.save_path) |path| self.writeSaveToDisk(self.allocator, path) catch |e| log.err("Failed to write save: {}", .{e});
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
pub fn deinit(self: Self) void {
|
||||
if (self.save_path) |path| self.writeSaveToDisk(path) catch |e| log.err("Failed to write save: {}", .{e});
|
||||
self.alloc.free(self.buf);
|
||||
}
|
||||
|
||||
fn loadSaveFromDisk(self: *Self, allocator: Allocator, path: []const u8) !void {
|
||||
const file_path = try self.getSaveFilePath(allocator, path);
|
||||
defer allocator.free(file_path);
|
||||
fn loadSaveFromDisk(self: *Self, path: []const u8) !void {
|
||||
const file_path = try self.getSaveFilePath(path);
|
||||
defer self.alloc.free(file_path);
|
||||
|
||||
// FIXME: Don't rely on this lol
|
||||
if (std.mem.eql(u8, file_path[file_path.len - 12 .. file_path.len], "untitled.sav")) {
|
||||
|
|
@ -90,8 +81,8 @@ pub const Backup = struct {
|
|||
}
|
||||
|
||||
const file: std.fs.File = try std.fs.openFileAbsolute(file_path, .{});
|
||||
const file_buf = try file.readToEndAlloc(allocator, try file.getEndPos());
|
||||
defer allocator.free(file_buf);
|
||||
const file_buf = try file.readToEndAlloc(self.alloc, try file.getEndPos());
|
||||
defer self.alloc.free(file_buf);
|
||||
|
||||
switch (self.kind) {
|
||||
.Sram, .Flash, .Flash1M => {
|
||||
|
|
@ -106,7 +97,7 @@ pub const Backup = struct {
|
|||
if (file_buf.len == 0x200 or file_buf.len == 0x2000) {
|
||||
self.eeprom.kind = if (file_buf.len == 0x200) .Small else .Large;
|
||||
|
||||
self.buf = try allocator.alloc(u8, file_buf.len);
|
||||
self.buf = try self.alloc.alloc(u8, file_buf.len);
|
||||
std.mem.copy(u8, self.buf, file_buf);
|
||||
return log.info("Loaded Save from {s}", .{file_path});
|
||||
}
|
||||
|
|
@ -120,23 +111,23 @@ pub const Backup = struct {
|
|||
}
|
||||
}
|
||||
|
||||
fn getSaveFilePath(self: *const Self, allocator: Allocator, path: []const u8) ![]const u8 {
|
||||
const filename = try self.getSaveFilename(allocator);
|
||||
defer allocator.free(filename);
|
||||
fn getSaveFilePath(self: *const Self, path: []const u8) ![]const u8 {
|
||||
const filename = try self.getSaveFilename();
|
||||
defer self.alloc.free(filename);
|
||||
|
||||
return try std.fs.path.join(allocator, &[_][]const u8{ path, filename });
|
||||
return try std.fs.path.join(self.alloc, &[_][]const u8{ path, filename });
|
||||
}
|
||||
|
||||
fn getSaveFilename(self: *const Self, allocator: Allocator) ![]const u8 {
|
||||
const title_str = asStringSlice(&escape(self.title));
|
||||
const name = if (title_str.len != 0) title_str else "untitled";
|
||||
fn getSaveFilename(self: *const Self) ![]const u8 {
|
||||
const title = asString(escape(self.title));
|
||||
const name = if (title.len != 0) title else "untitled";
|
||||
|
||||
return try std.mem.concat(allocator, u8, &[_][]const u8{ name, ".sav" });
|
||||
return try std.mem.concat(self.alloc, u8, &[_][]const u8{ name, ".sav" });
|
||||
}
|
||||
|
||||
fn writeSaveToDisk(self: Self, allocator: Allocator, path: []const u8) !void {
|
||||
const file_path = try self.getSaveFilePath(allocator, path);
|
||||
defer allocator.free(file_path);
|
||||
fn writeSaveToDisk(self: Self, path: []const u8) !void {
|
||||
const file_path = try self.getSaveFilePath(path);
|
||||
defer self.alloc.free(file_path);
|
||||
|
||||
switch (self.kind) {
|
||||
.Sram, .Flash, .Flash1M, .Eeprom => {
|
||||
|
|
@ -210,13 +201,21 @@ pub const Backup = struct {
|
|||
}
|
||||
};
|
||||
|
||||
const BackupKind = enum {
|
||||
Eeprom,
|
||||
Sram,
|
||||
Flash,
|
||||
Flash1M,
|
||||
None,
|
||||
};
|
||||
|
||||
const Needle = struct {
|
||||
const Self = @This();
|
||||
|
||||
str: []const u8,
|
||||
kind: Backup.Kind,
|
||||
kind: BackupKind,
|
||||
|
||||
fn init(str: []const u8, kind: Backup.Kind) Self {
|
||||
fn init(str: []const u8, kind: BackupKind) Self {
|
||||
return .{
|
||||
.str = str,
|
||||
.kind = kind,
|
||||
|
|
@ -231,7 +230,7 @@ const SaveError = error{
|
|||
const Flash = struct {
|
||||
const Self = @This();
|
||||
|
||||
state: State,
|
||||
state: FlashState,
|
||||
|
||||
id_mode: bool,
|
||||
set_bank: bool,
|
||||
|
|
@ -240,12 +239,6 @@ const Flash = struct {
|
|||
|
||||
bank: u1,
|
||||
|
||||
const State = enum {
|
||||
Ready,
|
||||
Set,
|
||||
Command,
|
||||
};
|
||||
|
||||
fn init() Self {
|
||||
return .{
|
||||
.state = .Ready,
|
||||
|
|
@ -300,6 +293,12 @@ const Flash = struct {
|
|||
}
|
||||
};
|
||||
|
||||
const FlashState = enum {
|
||||
Ready,
|
||||
Set,
|
||||
Command,
|
||||
};
|
||||
|
||||
const Eeprom = struct {
|
||||
const Self = @This();
|
||||
|
||||
|
|
@ -310,7 +309,7 @@ const Eeprom = struct {
|
|||
writer: Writer,
|
||||
reader: Reader,
|
||||
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
const Kind = enum {
|
||||
Unknown,
|
||||
|
|
@ -326,14 +325,14 @@ const Eeprom = struct {
|
|||
RequestEnd,
|
||||
};
|
||||
|
||||
fn init(allocator: Allocator) Self {
|
||||
fn init(alloc: Allocator) Self {
|
||||
return .{
|
||||
.kind = .Unknown,
|
||||
.state = .Ready,
|
||||
.writer = Writer.init(),
|
||||
.reader = Reader.init(),
|
||||
.addr = 0,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -361,7 +360,7 @@ const Eeprom = struct {
|
|||
else => unreachable,
|
||||
};
|
||||
|
||||
buf.* = self.allocator.alloc(u8, len) catch |e| {
|
||||
buf.* = self.alloc.alloc(u8, len) catch |e| {
|
||||
log.err("Failed to resize EEPROM buf to {} bytes", .{len});
|
||||
std.debug.panic("EEPROM entered irrecoverable state {}", .{e});
|
||||
};
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ const File = std.fs.File;
|
|||
|
||||
// ARM Instructions
|
||||
pub const arm = struct {
|
||||
pub const InstrFn = *const fn (*Arm7tdmi, *Bus, u32) void;
|
||||
pub const InstrFn = fn (*Arm7tdmi, *Bus, u32) void;
|
||||
const lut: [0x1000]InstrFn = populate();
|
||||
|
||||
const processing = @import("cpu/arm/data_processing.zig").dataProcessing;
|
||||
|
|
@ -110,7 +110,7 @@ pub const arm = struct {
|
|||
|
||||
// THUMB Instructions
|
||||
pub const thumb = struct {
|
||||
pub const InstrFn = *const fn (*Arm7tdmi, *Bus, u16) void;
|
||||
pub const InstrFn = fn (*Arm7tdmi, *Bus, u16) void;
|
||||
const lut: [0x400]InstrFn = populate();
|
||||
|
||||
const processing = @import("cpu/thumb/data_processing.zig");
|
||||
|
|
@ -250,7 +250,7 @@ pub const Arm7tdmi = struct {
|
|||
|
||||
logger: ?Logger,
|
||||
|
||||
pub fn init(sched: *Scheduler, bus: *Bus, log_file: ?std.fs.File) Self {
|
||||
pub fn init(sched: *Scheduler, bus: *Bus) Self {
|
||||
return Self{
|
||||
.r = [_]u32{0x00} ** 16,
|
||||
.sched = sched,
|
||||
|
|
@ -260,10 +260,14 @@ pub const Arm7tdmi = struct {
|
|||
.banked_fiq = [_]u32{0x00} ** 10,
|
||||
.banked_r = [_]u32{0x00} ** 12,
|
||||
.banked_spsr = [_]PSR{.{ .raw = 0x0000_0000 }} ** 5,
|
||||
.logger = if (log_file) |file| Logger.init(file) else null,
|
||||
.logger = null,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn attach(self: *Self, log_file: std.fs.File) void {
|
||||
self.logger = Logger.init(log_file);
|
||||
}
|
||||
|
||||
inline fn bankedIdx(mode: Mode, kind: BankedKind) usize {
|
||||
const idx: usize = switch (mode) {
|
||||
.User, .System => 0,
|
||||
|
|
|
|||
138
src/core/ppu.zig
138
src/core/ppu.zig
|
|
@ -41,25 +41,28 @@ pub const Ppu = struct {
|
|||
oam: Oam,
|
||||
sched: *Scheduler,
|
||||
framebuf: FrameBuffer,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
scanline_sprites: *[128]?Sprite,
|
||||
scanline_sprites: [128]?Sprite,
|
||||
scanline: Scanline,
|
||||
|
||||
pub fn init(allocator: Allocator, sched: *Scheduler) !Self {
|
||||
pub fn init(alloc: Allocator, sched: *Scheduler) !Self {
|
||||
// Queue first Hblank
|
||||
sched.push(.Draw, 240 * 4);
|
||||
|
||||
const sprites = try allocator.create([128]?Sprite);
|
||||
sprites.* = [_]?Sprite{null} ** 128;
|
||||
const framebufs = try alloc.alloc(u8, (framebuf_pitch * height) * 2);
|
||||
std.mem.set(u8, framebufs, 0);
|
||||
|
||||
const scanline_buf = try alloc.alloc(?u16, width * 2);
|
||||
std.mem.set(?u16, scanline_buf, null);
|
||||
|
||||
return Self{
|
||||
.vram = try Vram.init(allocator),
|
||||
.palette = try Palette.init(allocator),
|
||||
.oam = try Oam.init(allocator),
|
||||
.vram = try Vram.init(alloc),
|
||||
.palette = try Palette.init(alloc),
|
||||
.oam = try Oam.init(alloc),
|
||||
.sched = sched,
|
||||
.framebuf = try FrameBuffer.init(allocator),
|
||||
.allocator = allocator,
|
||||
.framebuf = FrameBuffer.init(framebufs),
|
||||
.alloc = alloc,
|
||||
|
||||
// Registers
|
||||
.win = Window.init(),
|
||||
|
|
@ -72,19 +75,17 @@ pub const Ppu = struct {
|
|||
.bldalpha = .{ .raw = 0x0000 },
|
||||
.bldy = .{ .raw = 0x0000 },
|
||||
|
||||
.scanline = try Scanline.init(allocator),
|
||||
.scanline_sprites = sprites,
|
||||
.scanline = Scanline.init(scanline_buf),
|
||||
.scanline_sprites = [_]?Sprite{null} ** 128,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
self.allocator.destroy(self.scanline_sprites);
|
||||
self.framebuf.deinit();
|
||||
self.scanline.deinit();
|
||||
pub fn deinit(self: Self) void {
|
||||
self.framebuf.deinit(self.alloc);
|
||||
self.scanline.deinit(self.alloc);
|
||||
self.vram.deinit();
|
||||
self.palette.deinit();
|
||||
self.oam.deinit();
|
||||
self.* = undefined;
|
||||
}
|
||||
|
||||
pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void {
|
||||
|
|
@ -398,7 +399,7 @@ pub const Ppu = struct {
|
|||
// Reset Current Scanline Pixel Buffer and list of fetched sprites
|
||||
// in prep for next scanline
|
||||
self.scanline.reset();
|
||||
std.mem.set(?Sprite, self.scanline_sprites, null);
|
||||
std.mem.set(?Sprite, &self.scanline_sprites, null);
|
||||
},
|
||||
0x1 => {
|
||||
const fb_base = framebuf_pitch * @as(usize, scanline);
|
||||
|
|
@ -425,7 +426,7 @@ pub const Ppu = struct {
|
|||
// Reset Current Scanline Pixel Buffer and list of fetched sprites
|
||||
// in prep for next scanline
|
||||
self.scanline.reset();
|
||||
std.mem.set(?Sprite, self.scanline_sprites, null);
|
||||
std.mem.set(?Sprite, &self.scanline_sprites, null);
|
||||
},
|
||||
0x2 => {
|
||||
const fb_base = framebuf_pitch * @as(usize, scanline);
|
||||
|
|
@ -451,7 +452,7 @@ pub const Ppu = struct {
|
|||
// Reset Current Scanline Pixel Buffer and list of fetched sprites
|
||||
// in prep for next scanline
|
||||
self.scanline.reset();
|
||||
std.mem.set(?Sprite, self.scanline_sprites, null);
|
||||
std.mem.set(?Sprite, &self.scanline_sprites, null);
|
||||
},
|
||||
0x3 => {
|
||||
const vram_base = width * @sizeOf(u16) * @as(usize, scanline);
|
||||
|
|
@ -628,21 +629,20 @@ const Palette = struct {
|
|||
const Self = @This();
|
||||
|
||||
buf: []u8,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
fn init(allocator: Allocator) !Self {
|
||||
const buf = try allocator.alloc(u8, palram_size);
|
||||
fn init(alloc: Allocator) !Self {
|
||||
const buf = try alloc.alloc(u8, palram_size);
|
||||
std.mem.set(u8, buf, 0);
|
||||
|
||||
return Self{
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
};
|
||||
}
|
||||
|
||||
fn deinit(self: *Self) void {
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
fn deinit(self: Self) void {
|
||||
self.alloc.free(self.buf);
|
||||
}
|
||||
|
||||
pub fn read(self: *const Self, comptime T: type, address: usize) T {
|
||||
|
|
@ -677,21 +677,20 @@ const Vram = struct {
|
|||
const Self = @This();
|
||||
|
||||
buf: []u8,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
fn init(allocator: Allocator) !Self {
|
||||
const buf = try allocator.alloc(u8, vram_size);
|
||||
fn init(alloc: Allocator) !Self {
|
||||
const buf = try alloc.alloc(u8, vram_size);
|
||||
std.mem.set(u8, buf, 0);
|
||||
|
||||
return Self{
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
};
|
||||
}
|
||||
|
||||
fn deinit(self: *Self) void {
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
fn deinit(self: Self) void {
|
||||
self.alloc.free(self.buf);
|
||||
}
|
||||
|
||||
pub fn read(self: *const Self, comptime T: type, address: usize) T {
|
||||
|
|
@ -738,21 +737,20 @@ const Oam = struct {
|
|||
const Self = @This();
|
||||
|
||||
buf: []u8,
|
||||
allocator: Allocator,
|
||||
alloc: Allocator,
|
||||
|
||||
fn init(allocator: Allocator) !Self {
|
||||
const buf = try allocator.alloc(u8, oam_size);
|
||||
fn init(alloc: Allocator) !Self {
|
||||
const buf = try alloc.alloc(u8, oam_size);
|
||||
std.mem.set(u8, buf, 0);
|
||||
|
||||
return Self{
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.alloc = alloc,
|
||||
};
|
||||
}
|
||||
|
||||
fn deinit(self: *Self) void {
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
fn deinit(self: Self) void {
|
||||
self.alloc.free(self.buf);
|
||||
}
|
||||
|
||||
pub fn read(self: *const Self, comptime T: type, address: usize) T {
|
||||
|
|
@ -1215,38 +1213,35 @@ fn copyToSpriteBuffer(bldcnt: io.BldCnt, scanline: *Scanline, x: u9, bgr555: u16
|
|||
const Scanline = struct {
|
||||
const Self = @This();
|
||||
|
||||
layers: [2][]?u16,
|
||||
buf: []?u16,
|
||||
buf: [2][]?u16,
|
||||
original: []?u16,
|
||||
|
||||
allocator: Allocator,
|
||||
fn init(buf: []?u16) Self {
|
||||
std.debug.assert(buf.len == width * 2);
|
||||
|
||||
fn init(allocator: Allocator) !Self {
|
||||
const buf = try allocator.alloc(?u16, width * 2); // Top & Bottom Scanline
|
||||
std.mem.set(?u16, buf, null);
|
||||
const top_slice = buf[0..][0..width];
|
||||
const btm_slice = buf[width..][0..width];
|
||||
|
||||
return .{
|
||||
// Top & Bototm Layers
|
||||
.layers = [_][]?u16{ buf[0..][0..width], buf[width..][0..width] },
|
||||
.buf = buf,
|
||||
.allocator = allocator,
|
||||
.buf = [_][]?u16{ top_slice, btm_slice },
|
||||
.original = buf,
|
||||
};
|
||||
}
|
||||
|
||||
fn reset(self: *Self) void {
|
||||
std.mem.set(?u16, self.buf, null);
|
||||
std.mem.set(?u16, self.original, null);
|
||||
}
|
||||
|
||||
fn deinit(self: *Self) void {
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
fn deinit(self: Self, alloc: Allocator) void {
|
||||
alloc.free(self.original);
|
||||
}
|
||||
|
||||
fn top(self: *Self) []?u16 {
|
||||
return self.layers[0];
|
||||
return self.buf[0];
|
||||
}
|
||||
|
||||
fn btm(self: *Self) []?u16 {
|
||||
return self.layers[1];
|
||||
return self.buf[1];
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -1254,36 +1249,31 @@ const Scanline = struct {
|
|||
const FrameBuffer = struct {
|
||||
const Self = @This();
|
||||
|
||||
layers: [2][]u8,
|
||||
buf: []u8,
|
||||
buf: [2][]u8,
|
||||
original: []u8,
|
||||
current: u1,
|
||||
|
||||
allocator: Allocator,
|
||||
|
||||
// TODO: Rename
|
||||
const Device = enum {
|
||||
Emulator,
|
||||
Renderer,
|
||||
};
|
||||
|
||||
pub fn init(allocator: Allocator) !Self {
|
||||
const framebuf_len = framebuf_pitch * height;
|
||||
const buf = try allocator.alloc(u8, framebuf_len * 2);
|
||||
std.mem.set(u8, buf, 0);
|
||||
pub fn init(bufs: []u8) Self {
|
||||
std.debug.assert(bufs.len == framebuf_pitch * height * 2);
|
||||
|
||||
const front = bufs[0 .. framebuf_pitch * height];
|
||||
const back = bufs[framebuf_pitch * height ..];
|
||||
|
||||
return .{
|
||||
// Front and Back Framebuffers
|
||||
.layers = [_][]u8{ buf[0..][0..framebuf_len], buf[framebuf_len..][0..framebuf_len] },
|
||||
.buf = buf,
|
||||
.buf = [2][]u8{ front, back },
|
||||
.original = bufs,
|
||||
.current = 0,
|
||||
|
||||
.allocator = allocator,
|
||||
};
|
||||
}
|
||||
|
||||
fn deinit(self: *Self) void {
|
||||
self.allocator.free(self.buf);
|
||||
self.* = undefined;
|
||||
fn deinit(self: Self, alloc: Allocator) void {
|
||||
alloc.free(self.original);
|
||||
}
|
||||
|
||||
pub fn swap(self: *Self) void {
|
||||
|
|
@ -1291,6 +1281,6 @@ const FrameBuffer = struct {
|
|||
}
|
||||
|
||||
pub fn get(self: *Self, comptime dev: Device) []u8 {
|
||||
return self.layers[if (dev == .Emulator) self.current else ~self.current];
|
||||
return self.buf[if (dev == .Emulator) self.current else ~self.current];
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -14,16 +14,15 @@ pub const Scheduler = struct {
|
|||
tick: u64,
|
||||
queue: PriorityQueue(Event, void, lessThan),
|
||||
|
||||
pub fn init(allocator: Allocator) Self {
|
||||
var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(allocator, {}) };
|
||||
pub fn init(alloc: Allocator) Self {
|
||||
var sched = Self{ .tick = 0, .queue = PriorityQueue(Event, void, lessThan).init(alloc, {}) };
|
||||
sched.queue.add(.{ .kind = .HeatDeath, .tick = std.math.maxInt(u64) }) catch unreachable;
|
||||
|
||||
return sched;
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
pub fn deinit(self: Self) void {
|
||||
self.queue.deinit();
|
||||
self.* = undefined;
|
||||
}
|
||||
|
||||
pub inline fn now(self: *const Self) u64 {
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ pub fn intToBytes(comptime T: type, value: anytype) [@sizeOf(T)]u8 {
|
|||
///
|
||||
/// This function returns a slice of everything just before the first
|
||||
/// `\0`
|
||||
pub fn asStringSlice(title: *const [12]u8) []const u8 {
|
||||
pub fn asString(title: [12]u8) []const u8 {
|
||||
var len = title.len;
|
||||
for (title) |char, i| {
|
||||
if (char == 0) {
|
||||
|
|
@ -129,45 +129,45 @@ pub const Logger = struct {
|
|||
try self.buf.writer().print(format, args);
|
||||
}
|
||||
|
||||
pub fn mgbaLog(self: *Self, cpu: *const Arm7tdmi, opcode: u32) void {
|
||||
pub fn mgbaLog(self: *Self, arm7tdmi: *const Arm7tdmi, opcode: u32) void {
|
||||
const fmt_base = "{X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} {X:0>8} cpsr: {X:0>8} | ";
|
||||
const thumb_fmt = fmt_base ++ "{X:0>4}:\n";
|
||||
const arm_fmt = fmt_base ++ "{X:0>8}:\n";
|
||||
|
||||
if (cpu.cpsr.t.read()) {
|
||||
if (arm7tdmi.cpsr.t.read()) {
|
||||
if (opcode >> 11 == 0x1E) {
|
||||
// Instruction 1 of a BL Opcode, print in ARM mode
|
||||
const low = cpu.bus.dbgRead(u16, cpu.r[15]);
|
||||
const low = arm7tdmi.bus.dbgRead(u16, arm7tdmi.r[15]);
|
||||
const bl_opcode = @as(u32, opcode) << 16 | low;
|
||||
|
||||
self.print(arm_fmt, Self.fmtArgs(cpu, bl_opcode)) catch @panic("failed to write to log file");
|
||||
self.print(arm_fmt, Self.fmtArgs(arm7tdmi, bl_opcode)) catch @panic("failed to write to log file");
|
||||
} else {
|
||||
self.print(thumb_fmt, Self.fmtArgs(cpu, opcode)) catch @panic("failed to write to log file");
|
||||
self.print(thumb_fmt, Self.fmtArgs(arm7tdmi, opcode)) catch @panic("failed to write to log file");
|
||||
}
|
||||
} else {
|
||||
self.print(arm_fmt, Self.fmtArgs(cpu, opcode)) catch @panic("failed to write to log file");
|
||||
self.print(arm_fmt, Self.fmtArgs(arm7tdmi, opcode)) catch @panic("failed to write to log file");
|
||||
}
|
||||
}
|
||||
|
||||
fn fmtArgs(cpu: *const Arm7tdmi, opcode: u32) FmtArgTuple {
|
||||
fn fmtArgs(arm7tdmi: *const Arm7tdmi, opcode: u32) FmtArgTuple {
|
||||
return .{
|
||||
cpu.r[0],
|
||||
cpu.r[1],
|
||||
cpu.r[2],
|
||||
cpu.r[3],
|
||||
cpu.r[4],
|
||||
cpu.r[5],
|
||||
cpu.r[6],
|
||||
cpu.r[7],
|
||||
cpu.r[8],
|
||||
cpu.r[9],
|
||||
cpu.r[10],
|
||||
cpu.r[11],
|
||||
cpu.r[12],
|
||||
cpu.r[13],
|
||||
cpu.r[14],
|
||||
cpu.r[15],
|
||||
cpu.cpsr.raw,
|
||||
arm7tdmi.r[0],
|
||||
arm7tdmi.r[1],
|
||||
arm7tdmi.r[2],
|
||||
arm7tdmi.r[3],
|
||||
arm7tdmi.r[4],
|
||||
arm7tdmi.r[5],
|
||||
arm7tdmi.r[6],
|
||||
arm7tdmi.r[7],
|
||||
arm7tdmi.r[8],
|
||||
arm7tdmi.r[9],
|
||||
arm7tdmi.r[10],
|
||||
arm7tdmi.r[11],
|
||||
arm7tdmi.r[12],
|
||||
arm7tdmi.r[13],
|
||||
arm7tdmi.r[14],
|
||||
arm7tdmi.r[15],
|
||||
arm7tdmi.cpsr.raw,
|
||||
opcode,
|
||||
};
|
||||
}
|
||||
|
|
|
|||
22
src/main.zig
22
src/main.zig
|
|
@ -14,7 +14,7 @@ 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;
|
||||
const cpu_logging = @import("core/emu.zig").cpu_logging;
|
||||
const arm7tdmi_logging = @import("core/emu.zig").cpu_logging;
|
||||
pub const log_level = if (builtin.mode != .Debug) .info else std.log.default_level;
|
||||
|
||||
// TODO: Reimpl Logging
|
||||
|
|
@ -40,26 +40,28 @@ pub fn main() anyerror!void {
|
|||
const paths = try handleArguments(allocator, &result);
|
||||
defer if (paths.save) |path| allocator.free(path);
|
||||
|
||||
const log_file: ?std.fs.File = if (cpu_logging) try std.fs.cwd().createFile("zba.log", .{}) else null;
|
||||
defer if (log_file) |file| file.close();
|
||||
|
||||
// TODO: Take Emulator Init Code out of main.zig
|
||||
var scheduler = Scheduler.init(allocator);
|
||||
defer scheduler.deinit();
|
||||
|
||||
var bus: Bus = undefined;
|
||||
var cpu = Arm7tdmi.init(&scheduler, &bus, log_file);
|
||||
if (paths.bios == null) cpu.fastBoot();
|
||||
|
||||
try bus.init(allocator, &scheduler, &cpu, paths);
|
||||
var bus = try Bus.init(allocator, &scheduler, paths);
|
||||
bus.pak.setupGpio(); // FIXME: Can I not call this in main()?
|
||||
defer bus.deinit();
|
||||
|
||||
var arm7tdmi = Arm7tdmi.init(&scheduler, &bus);
|
||||
|
||||
const log_file: ?std.fs.File = if (arm7tdmi_logging) try std.fs.cwd().createFile("zba.log", .{}) else null;
|
||||
defer if (log_file) |file| file.close();
|
||||
|
||||
if (log_file) |file| arm7tdmi.attach(file);
|
||||
bus.attach(&arm7tdmi); // TODO: Shrink Surface (only CPSR and r15?)
|
||||
if (paths.bios == null) arm7tdmi.fastBoot();
|
||||
|
||||
var gui = Gui.init(bus.pak.title, width, height);
|
||||
gui.initAudio(&bus.apu);
|
||||
defer gui.deinit();
|
||||
|
||||
try gui.run(&cpu, &scheduler);
|
||||
try gui.run(&arm7tdmi, &scheduler);
|
||||
}
|
||||
|
||||
fn getSavePath(allocator: Allocator) !?[]const u8 {
|
||||
|
|
|
|||
Loading…
Reference in New Issue