253 lines
7.2 KiB
Zig
253 lines
7.2 KiB
Zig
const std = @import("std");
|
|
const contract = @import("contract");
|
|
const video = contract.video;
|
|
const audio = contract.audio;
|
|
const input = contract.input;
|
|
const storage = contract.storage;
|
|
const state = contract.state;
|
|
const _cpu = @import("cpu");
|
|
|
|
pub const common = @import("common.zig");
|
|
pub const Region = common.Region;
|
|
pub const Mirroring = common.Mirroring;
|
|
pub const Button = common.Button;
|
|
pub const screen_width = common.screen_width;
|
|
pub const screen_height = common.screen_height;
|
|
|
|
pub const ppu = @import("ppu/root.zig");
|
|
pub const apu = @import("apu/root.zig");
|
|
pub const bus_mod = @import("bus.zig");
|
|
pub const Bus = bus_mod.Bus;
|
|
pub const cartridge_mod = @import("cartridge.zig");
|
|
pub const Cartridge = cartridge_mod.Cartridge;
|
|
pub const controller_mod = @import("controller.zig");
|
|
pub const Controller = controller_mod.Controller;
|
|
pub const mapper_mod = @import("mapper/root.zig");
|
|
|
|
const Cpu = _cpu.m6502.Cpu(Bus, .ricoh2a03, .cycle);
|
|
|
|
pub const Nes = @This();
|
|
|
|
pub const default_palette_565: [64]u16 = blk: {
|
|
var table: [64]u16 = undefined;
|
|
for (ppu.default_palette, 0..) |rgba, i| {
|
|
const r = @as(u16, @truncate((rgba >> 24) & 0xFF));
|
|
const g = @as(u16, @truncate((rgba >> 16) & 0xFF));
|
|
const b = @as(u16, @truncate((rgba >> 8) & 0xFF));
|
|
const r5 = r >> 3;
|
|
const g6 = g >> 2;
|
|
const b5 = b >> 3;
|
|
table[i] = (r5 << 11) | (g6 << 5) | b5;
|
|
}
|
|
break :blk table;
|
|
};
|
|
|
|
pub const spec: contract.SystemSpec = .{
|
|
.name = "Nintendo Entertainment System",
|
|
.video_outputs = &.{
|
|
.{
|
|
.max_width = common.screen_width,
|
|
.max_height = common.screen_height,
|
|
.format = .rgb565,
|
|
.aspect_ratio = .{
|
|
.numerator = 4,
|
|
.denominator = 3,
|
|
},
|
|
.refresh_rate = .{
|
|
.numerator = 60,
|
|
.denominator = 1,
|
|
},
|
|
},
|
|
},
|
|
.audio_outputs = &.{
|
|
.{
|
|
.sample_rate = 44_100,
|
|
.channels = 1,
|
|
.format = .i16,
|
|
},
|
|
},
|
|
.input_devices = &.{
|
|
.{ .button_count = 8 },
|
|
.{ .button_count = 8 },
|
|
},
|
|
.storage_devices = &.{
|
|
.{
|
|
.name = "Battery PRG RAM",
|
|
.min_size = 0,
|
|
.max_size = 8192,
|
|
.persistent = true,
|
|
.removable = false,
|
|
.writable = true,
|
|
},
|
|
},
|
|
.save_state = .{
|
|
.max_size = 64 * 1024,
|
|
},
|
|
};
|
|
|
|
bus: Bus = undefined,
|
|
cpu: Cpu = undefined,
|
|
rgb565_framebuffer: [common.screen_width * common.screen_height]u16 = [_]u16{0} ** (common.screen_width * common.screen_height),
|
|
|
|
pub fn init(self: *Nes, rom_bytes: []const u8) !void {
|
|
const cart = try Cartridge.init(rom_bytes);
|
|
self.bus = Bus.init(.ntsc, cart);
|
|
self.cpu = Cpu.init(&self.bus);
|
|
self.cpu.reset();
|
|
}
|
|
|
|
pub fn reset(self: *Nes) void {
|
|
self.cpu.bus = &self.bus;
|
|
self.bus.reset();
|
|
self.cpu.reset();
|
|
}
|
|
|
|
pub fn runFrame(self: *Nes) void {
|
|
self.bus.ppu.frame_complete = false;
|
|
self.bus.apu.clearSamples();
|
|
|
|
while (!self.bus.ppu.frame_complete) {
|
|
if (self.bus.dma_active) {
|
|
self.bus.stepDma();
|
|
} else {
|
|
_ = self.cpu.step();
|
|
}
|
|
}
|
|
|
|
// Convert PPU framebuffer to RGB565 for frontend driver
|
|
for (self.bus.ppu.framebuffer, 0..) |color_idx, i| {
|
|
self.rgb565_framebuffer[i] = default_palette_565[color_idx & 0x3f];
|
|
}
|
|
}
|
|
|
|
pub fn videoFrame(self: *const Nes, _: usize) video.VideoFrame {
|
|
return .{
|
|
.data = std.mem.sliceAsBytes(&self.rgb565_framebuffer),
|
|
.width = common.screen_width,
|
|
.height = common.screen_height,
|
|
.pitch = common.screen_width * 2,
|
|
.format = .rgb565,
|
|
.frame_number = self.bus.ppu.frame_count,
|
|
};
|
|
}
|
|
|
|
pub fn audioBuffer(self: *const Nes, _: usize) audio.Buffer {
|
|
const samples = self.bus.apu.getSamples();
|
|
return .{
|
|
.data = std.mem.sliceAsBytes(samples),
|
|
.frames = samples.len,
|
|
.sample_rate = 44_100,
|
|
.channels = 1,
|
|
.format = .i16,
|
|
};
|
|
}
|
|
|
|
pub fn setInput(self: *Nes, device_index: usize, device_input: input.DeviceInput) void {
|
|
if (device_index < 2) {
|
|
self.bus.controllers[device_index].setButtons(@truncate(device_input.buttons));
|
|
}
|
|
}
|
|
|
|
pub fn storageView(self: *const Nes, index: usize) storage.View {
|
|
if (index == 0 and self.bus.cartridge != null) {
|
|
return .{
|
|
.data = &self.bus.cartridge.?.prg_ram,
|
|
.generation = 0,
|
|
};
|
|
}
|
|
return .{ .data = &.{}, .generation = 0 };
|
|
}
|
|
|
|
pub fn loadStorage(self: *Nes, index: usize, data: []const u8) storage.LoadError!void {
|
|
if (index != 0 or self.bus.cartridge == null) return error.InvalidSlot;
|
|
if (data.len > self.bus.cartridge.?.prg_ram.len) return error.InvalidSize;
|
|
@memcpy(self.bus.cartridge.?.prg_ram[0..data.len], data);
|
|
}
|
|
|
|
pub fn saveState(self: *const Nes, dest: []u8) state.Error!usize {
|
|
const required_size: usize = 8 + 7 + 0x800 + 0x800 + 256 + 32 + 0x2000;
|
|
if (dest.len < required_size) return error.BufferTooSmall;
|
|
|
|
var offset: usize = 0;
|
|
@memcpy(dest[offset .. offset + 8], "NESSTATE");
|
|
offset += 8;
|
|
|
|
const regs = self.cpu.registers;
|
|
dest[offset] = regs.a;
|
|
dest[offset + 1] = regs.x;
|
|
dest[offset + 2] = regs.y;
|
|
dest[offset + 3] = regs.sp;
|
|
dest[offset + 4] = @bitCast(regs.status);
|
|
dest[offset + 5] = @truncate(regs.pc);
|
|
dest[offset + 6] = @truncate(regs.pc >> 8);
|
|
offset += 7;
|
|
|
|
@memcpy(dest[offset .. offset + 0x800], &self.bus.ram);
|
|
offset += 0x800;
|
|
|
|
@memcpy(dest[offset .. offset + 0x800], &self.bus.ciram);
|
|
offset += 0x800;
|
|
|
|
@memcpy(dest[offset .. offset + 256], &self.bus.ppu.registers.oam);
|
|
offset += 256;
|
|
|
|
@memcpy(dest[offset .. offset + 32], &self.bus.ppu.palette.ram);
|
|
offset += 32;
|
|
|
|
if (self.bus.cartridge) |*c| {
|
|
@memcpy(dest[offset .. offset + 0x2000], &c.prg_ram);
|
|
offset += 0x2000;
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
pub fn loadState(self: *Nes, src: []const u8) state.Error!void {
|
|
if (src.len < 8 or !std.mem.eql(u8, src[0..8], "NESSTATE")) {
|
|
return error.InvalidState;
|
|
}
|
|
var offset: usize = 8;
|
|
|
|
self.cpu.registers.a = src[offset];
|
|
self.cpu.registers.x = src[offset + 1];
|
|
self.cpu.registers.y = src[offset + 2];
|
|
self.cpu.registers.sp = src[offset + 3];
|
|
self.cpu.registers.status = @bitCast(src[offset + 4]);
|
|
self.cpu.registers.pc = @as(u16, src[offset + 5]) | (@as(u16, src[offset + 6]) << 8);
|
|
offset += 7;
|
|
|
|
@memcpy(&self.bus.ram, src[offset .. offset + 0x800]);
|
|
offset += 0x800;
|
|
|
|
@memcpy(&self.bus.ciram, src[offset .. offset + 0x800]);
|
|
offset += 0x800;
|
|
|
|
@memcpy(&self.bus.ppu.registers.oam, src[offset .. offset + 256]);
|
|
offset += 256;
|
|
|
|
@memcpy(&self.bus.ppu.palette.ram, src[offset .. offset + 32]);
|
|
offset += 32;
|
|
|
|
if (self.bus.cartridge) |*c| {
|
|
if (src.len >= offset + 0x2000) {
|
|
@memcpy(&c.prg_ram, src[offset .. offset + 0x2000]);
|
|
offset += 0x2000;
|
|
}
|
|
}
|
|
}
|
|
|
|
test {
|
|
contract.system.validate(Nes);
|
|
_ = common;
|
|
_ = ppu;
|
|
_ = apu;
|
|
_ = bus_mod;
|
|
_ = cartridge_mod;
|
|
_ = controller_mod;
|
|
_ = mapper_mod;
|
|
_ = conformance;
|
|
}
|
|
|
|
pub const conformance = @import("conformance/root.zig");
|
|
|