diff options
| -rw-r--r-- | Cargo.lock | 2 | ||||
| -rw-r--r-- | Cargo.toml | 2 | ||||
| -rw-r--r-- | README.rst | 19 | ||||
| -rw-r--r-- | src/bin.rs | 168 | ||||
| -rw-r--r-- | src/cartridge.rs | 2 | ||||
| -rw-r--r-- | src/mapper.rs | 8 | ||||
| -rw-r--r-- | src/utils.rs | 88 |
7 files changed, 235 insertions, 54 deletions
@@ -134,7 +134,7 @@ dependencies = [ [[package]] name = "runes" -version = "0.1.5" +version = "0.1.6" dependencies = [ "clap 2.29.0 (registry+https://github.com/rust-lang/crates.io-index)", "sdl2 0.31.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1,6 +1,6 @@ [package] name = "runes" -version = "0.1.5" +version = "0.1.6" authors = ["Determinant <[email protected]>"] description = "No-std NES emulator library and minimal emulator written purely in Rust." repository = "https://github.com/Determinant/runes" @@ -8,22 +8,23 @@ RuNES As we know, there have been a ton of NES emulator implementations in various kinds of languages (mostly C). All of these emulators come with different -accuracy and portability. RuNES is an attempt to build a reasonably -accurate (cycle-level accurate), light-weight and efficient emulation -core library using Rust. Unlike sprocketnes_ or pinky_, RuNES strives to -provide with a clean and minimal core library without standard library (i.e., -without Box, Rc, Vectors, etc.) that could be compiled and easily ported to -embedded environments. Of course, a minimal SDL-based GUI is also provided as a -demonstration of use. +accuracy and portability. RuNES is an attempt to build a reasonably accurate +(cycle-level accurate), light-weight and efficient emulation core library using +Rust. Unlike sprocketnes_ or pinky_, RuNES strives to provide with a clean and +minimal core library without standard library (i.e., without Box, Rc, Vectors, +etc.) that could be compiled and easily ported to embedded environments. Of +course, a minimal but usable SDL-based GUI is also provided as a demonstration +of use. Feature ======= - Core library with minimal use of the Rust core crate, and zero use of std. +- Lightweight and clean code base. - Support standard 6502 instruction set (unofficial instruction will be considered in the future). - -- Cycle-level accuracy. +- Load/save the machine state. +- Cycle-level accuracy (in-progress). Guidelines ========== @@ -66,6 +66,22 @@ impl SimpleCart { mirror_type: MirrorType) -> Self { SimpleCart{chr_rom, prg_rom, sram, mirror_type} } + + fn load_vec(vec: &mut Vec<u8>, reader: &mut utils::Read) -> bool { + let len = vec.len(); + match reader.read(vec) { + Some(x) => x == len, + None => false + } + } + + fn save_vec(vec: &Vec<u8>, writer: &mut utils::Write) -> bool { + let len = vec.len(); + match writer.write(vec) { + Some(x) => x == len, + None => false + } + } } impl Cartridge for SimpleCart { @@ -100,22 +116,24 @@ impl Cartridge for SimpleCart { fn set_mirror_type(&mut self, mt: MirrorType) {self.mirror_type = mt} fn load(&mut self, reader: &mut utils::Read) -> bool { - let len = self.sram.len(); - (match reader.read(&mut self.sram) { - Some(x) => x == len, - None => false - }) && + self.load_sram(reader) && + SimpleCart::load_vec(&mut self.chr_rom, reader) && utils::load_prefix(&mut self.mirror_type, 0, reader) } fn save(&self, writer: &mut utils::Write) -> bool { - let len = self.sram.len(); - (match writer.write(&self.sram) { - Some(x) => x == len, - None => false - }) && + self.save_sram(writer) && + SimpleCart::save_vec(&self.chr_rom, writer) && utils::save_prefix(&self.mirror_type, 0, writer) } + + fn load_sram(&mut self, reader: &mut utils::Read) -> bool { + SimpleCart::load_vec(&mut self.sram, reader) + } + + fn save_sram(&self, writer: &mut utils::Write) -> bool { + SimpleCart::save_vec(&self.sram, writer) + } } struct FileIO(File); @@ -387,39 +405,74 @@ fn print_cpu_trace(cpu: &CPU) { } fn main() { - let matches = App::new("RuNES") - .version("0.1.5") - .author("Ted Yin <[email protected]>") - .about("A Rust NES emulator") - .arg(Arg::with_name("scale") - .short("x") - .long("scale") - .required(false) - .takes_value(true)) - .arg(Arg::with_name("full") - .short("f") - .long("full") - .required(false) - .takes_value(false)) - .arg(Arg::with_name("INPUT") - .help("the iNES ROM file") - .required(true) - .index(1)) - .arg(Arg::with_name("load") - .short("l") - .long("load") - .required(false) - .takes_value(true)) - .get_matches(); + let matches = + App::new("RuNES") + .version("0.1") + .author("Ted Yin <[email protected]>") + .about("A Rust NES emulator") + .arg(Arg::with_name("scale") + .short("x") + .long("scale") + .help("Set pixel scaling factor (3 by default)") + .required(false) + .takes_value(true)) + .arg(Arg::with_name("full") + .help("Enable the entire PPU rendering area") + .short("f") + .long("full") + .required(false) + .takes_value(false)) + .arg(Arg::with_name("INPUT") + .help("iNES ROM file") + .required(true) + .index(1)) + .arg(Arg::with_name("load") + .help("Load from specified machine state file") + .short("l") + .long("load") + .required(false) + .takes_value(true)) + .arg(Arg::with_name("save") + .help("Save to specified machine state file when exit") + .short("s") + .long("save") + .required(false) + .takes_value(true)) + .arg(Arg::with_name("load-sram") + .help("Load from specified sram file") + .short("L") + .long("load-sram") + .required(false) + .takes_value(true)) + .arg(Arg::with_name("save-sram") + .help("Save to specified sram file when exit") + .short("S") + .long("save-sram") + .required(false) + .takes_value(true)) + .arg(Arg::with_name("no-state") + .help("Power up the emulator with initial state") + .short("n") + .long("no-state") + .required(false) + .takes_value(false)) + .get_matches(); let scale = std::cmp::min(8, std::cmp::max(1, value_t!(matches, "scale", u32).unwrap_or(3))); let full = matches.is_present("full"); - /* load and parse iNES file */ let fname = matches.value_of("INPUT").unwrap(); - let lname = matches.value_of("load"); + let load_state_name = matches.value_of("load"); + let save_state_name = matches.value_of("save"); + let save_sram_name = matches.value_of("save-sram"); + let load_sram_name = matches.value_of("load-sram"); + let default_state_name = fname.to_string() + ".runes"; + let default_sram_name = fname.to_string() + ".runes_sram"; + let no_state = matches.is_present("no-state"); + + /* load and parse iNES file */ let mut file = File::open(fname).unwrap(); let mut rheader = [0; 16]; file.read(&mut rheader[..]).unwrap(); @@ -493,19 +546,38 @@ fn main() { let mut apu = APU::new(&mut spkr); let cpu_ptr = &mut cpu as *mut CPU; cpu.mem.bus.attach(cpu_ptr, &mut ppu, &mut apu); - match lname { - Some(s) => { - let mut file = FileIO(File::open(s).unwrap()); + let load_state = !no_state && match match load_state_name { + Some(s) => Some(File::open(s).unwrap()), + None => match File::open(&default_state_name) { + Ok(file) => Some(file), + Err(_) => None + } + } { + Some(f) => { + let mut file = FileIO(f); cpu.load(&mut file); ppu.load(&mut file); apu.load(&mut file); mapper.get_mut().load(&mut file); - debug_assert!(cpu.cycle == 0); + true }, - None => { - cpu.powerup() + None => false + }; + + if !load_state { + if let Some(f) = match load_sram_name { + Some(s) => Some(File::open(s).unwrap()), + None => match File::open(&default_sram_name) { + Ok(file) => Some(file), + Err(_) => None + } + } { + let mut file = FileIO(f); + mapper.get_mut().get_cart_mut().load_sram(&mut file); } + cpu.powerup() } + device.resume(); loop { /* consume the leftover cycles from the last instruction */ @@ -514,12 +586,22 @@ fn main() { } if exit_flag.get() { { - let mut file = FileIO(File::create("t.dat").unwrap()); + let mut file = FileIO(File::create(match save_state_name { + Some(s) => s.to_string(), + None => default_state_name + }).unwrap()); cpu.save(&mut file); ppu.save(&mut file); apu.save(&mut file); mapper.save(&mut file); } + { + let mut file = FileIO(File::create(match save_sram_name { + Some(s) => s.to_string(), + None => default_sram_name + }).unwrap()); + mapper.get_cart().save_sram(&mut file); + } exit(0); } //print_cpu_trace(&cpu); diff --git a/src/cartridge.rs b/src/cartridge.rs index ca9c31e..29cfbd7 100644 --- a/src/cartridge.rs +++ b/src/cartridge.rs @@ -24,4 +24,6 @@ pub trait Cartridge { #[inline(always)] fn set_mirror_type(&mut self, mt: MirrorType); fn load(&mut self, reader: &mut Read) -> bool; fn save(&self, writer: &mut Write) -> bool; + fn load_sram(&mut self, reader: &mut Read) -> bool; + fn save_sram(&self, writer: &mut Write) -> bool; } diff --git a/src/mapper.rs b/src/mapper.rs index 3d72189..8a6c261 100644 --- a/src/mapper.rs +++ b/src/mapper.rs @@ -7,6 +7,7 @@ use utils::{Read, Write, load_prefix, save_prefix}; pub trait Mapper : VMem { fn get_cart(&self) -> &Cartridge; + fn get_cart_mut(&mut self) -> &mut Cartridge; fn tick(&mut self, _bus: &CPUBus) {} fn load(&mut self, reader: &mut Read) -> bool; fn save(&self, writer: &mut Write) -> bool; @@ -35,6 +36,7 @@ impl<'a> core::ops::Deref for RefMapper<'a> { } } +#[repr(C)] pub struct Mapper1<'a, C> where C: Cartridge { cart: C, prg_banks: [&'a [u8]; 2], @@ -177,6 +179,7 @@ impl<'a, C> Mapper1<'a, C> where C: Cartridge { impl<'a, C> Mapper for Mapper1<'a, C> where C: Cartridge { fn get_cart(&self) -> &Cartridge {&self.cart} + fn get_cart_mut(&mut self) -> &mut Cartridge {&mut self.cart} fn load(&mut self, reader: &mut Read) -> bool { for v in self.prg_banks.iter_mut() { @@ -215,6 +218,7 @@ impl<'a, C> Mapper for Mapper1<'a, C> where C: Cartridge { } } +#[repr(C)] pub struct Mapper2<'a, C> where C: Cartridge { cart: C, prg_banks: [&'a [u8]; 2], @@ -282,6 +286,7 @@ impl<'a, C> Mapper2<'a, C> where C: Cartridge { impl<'a, C> Mapper for Mapper2<'a, C> where C: Cartridge { fn get_cart(&self) -> &Cartridge {&self.cart} + fn get_cart_mut(&mut self) -> &mut Cartridge {&mut self.cart} fn load(&mut self, reader: &mut Read) -> bool { for v in self.prg_banks.iter_mut() { @@ -312,6 +317,7 @@ impl<'a, C> Mapper for Mapper2<'a, C> where C: Cartridge { } } +#[repr(C)] pub struct Mapper4<'a, C> where C: Cartridge { cart: C, prg_banks: [&'a [u8]; 4], @@ -500,6 +506,8 @@ impl<'a, C> Mapper4<'a, C> where C: Cartridge { impl<'a, C> Mapper for Mapper4<'a, C> where C: Cartridge { fn get_cart(&self) -> &Cartridge {&self.cart} + fn get_cart_mut(&mut self) -> &mut Cartridge {&mut self.cart} + fn tick(&mut self, bus: &CPUBus) { let ppu = bus.get_ppu(); if ppu.cycle != 260 { diff --git a/src/utils.rs b/src/utils.rs new file mode 100644 index 0000000..ea20ac9 --- /dev/null +++ b/src/utils.rs @@ -0,0 +1,88 @@ +use core::intrinsics::transmute; +use core::mem::size_of; +use core::slice::{from_raw_parts_mut, from_raw_parts}; + +pub struct Sampler { + freq2: u32, + q0: u32, + r0: u32, + ddl: (u32, u32), + cnt: u32, + sec_cnt: u32 +} + +impl Sampler { + pub fn new(freq1: u32, freq2: u32) -> Self { + let q0 = freq1 / freq2; + let r0 = freq1 - q0 * freq2; + Sampler { + freq2, + q0, + r0, + ddl: (q0, r0), + cnt: 0, + sec_cnt: 0 + } + } + + pub fn load(&mut self, reader: &mut Read) -> bool { + load_prefix(self, 0, reader) + } + + pub fn save(&self, writer: &mut Write) -> bool { + save_prefix(self, 0, writer) + } + + pub fn tick(&mut self) -> bool { + let (q, r) = self.ddl; + if self.cnt == q { + let nr = r + self.r0; + self.ddl = if nr > self.freq2 { + (self.q0, nr - self.freq2) + } else { + (self.q0 - 1, nr) + }; + self.cnt = 0; + self.sec_cnt += 1; + if self.sec_cnt == self.freq2 { + self.sec_cnt = 0 + } + true + } else { + self.cnt += 1; + false + } + } +} + +pub trait Read { + fn read(&mut self, buf: &mut [u8]) -> Option<usize>; +} + +pub trait Write { + fn write(&mut self, buf: &[u8]) -> Option<usize>; +} + +pub fn load_prefix<T>(obj: &mut T, ignored: usize, reader: &mut Read) -> bool { + let len = size_of::<T>() - ignored; + match reader.read(unsafe { + from_raw_parts_mut( + transmute::<*mut T, *mut u8>(obj as *mut T), + len + )}) { + Some(x) => x == len, + None => false + } +} + +pub fn save_prefix<T>(obj: &T, ignored: usize, writer: &mut Write) -> bool { + let len = size_of::<T>() - ignored; + match writer.write(unsafe { + from_raw_parts( + transmute::<*const T, *const u8>(obj as *const T), + len + )}) { + Some(x) => x == len, + None => false + } +} |