aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/cartridge.rs37
-rw-r--r--src/main.rs175
-rw-r--r--src/mapper.rs55
-rw-r--r--src/memory.rs86
-rw-r--r--src/mos6502.rs75
-rw-r--r--src/ppu.rs96
6 files changed, 357 insertions, 167 deletions
diff --git a/src/cartridge.rs b/src/cartridge.rs
index f96c234..b8d2b68 100644
--- a/src/cartridge.rs
+++ b/src/cartridge.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
use core::cell::RefCell;
#[derive(Copy, Clone)]
@@ -16,23 +17,33 @@ pub enum BankType {
}
pub struct Cartridge {
- chr_rom: [u8; 8192],
- prg_rom: RefCell<[u8; 8192]>,
- sram: [u8; 8192],
+ chr_rom: RefCell<Vec<u8>>,
+ prg_rom: RefCell<Vec<u8>>,
+ sram: RefCell<Vec<u8>>,
pub mirror_type: MirrorType
}
impl Cartridge {
- pub fn get_bank_num(&self, kind: BankType) -> usize {0}
- pub fn get_bank(&self, idx: usize, kind: BankType) -> *mut [u8] {
- &mut *self.prg_rom.borrow_mut()
- }
- pub fn new() -> Self {
- Cartridge {
- chr_rom: [0; 8192],
- prg_rom: RefCell::new([0; 8192]),
- sram: [0; 8192],
- mirror_type: MirrorType::Horizontal
+ pub fn get_size(&self, kind: BankType) -> usize {
+ match kind {
+ BankType::PrgRom => self.prg_rom.borrow().len(),
+ BankType::ChrRom => self.chr_rom.borrow().len(),
+ BankType::Sram => self.sram.borrow().len()
}
}
+ pub fn get_bank(&self, base: usize, size: usize, kind: BankType) -> *mut [u8] {
+ &mut (match kind {
+ BankType::PrgRom => self.prg_rom.borrow_mut(),
+ BankType::ChrRom => self.chr_rom.borrow_mut(),
+ BankType::Sram => self.sram.borrow_mut(),
+ })[base..base + size]
+ }
+ pub fn new(chr_rom: Vec<u8>,
+ prg_rom: Vec<u8>,
+ sram: Vec<u8>,
+ mirror_type: MirrorType) -> Self {
+ Cartridge{chr_rom: RefCell::new(chr_rom),
+ prg_rom: RefCell::new(prg_rom),
+ sram: RefCell::new(sram), mirror_type}
+ }
}
diff --git a/src/main.rs b/src/main.rs
index 447fa85..cd39d39 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,24 +4,181 @@ mod mos6502;
mod ppu;
mod cartridge;
mod mapper;
-use core::ptr::null_mut;
+
+use std::fs::File;
+use std::io::Read;
+use core::cell::RefCell;
+use core::intrinsics::transmute;
+use cartridge::*;
+
+
+extern crate sdl2;
+
+use sdl2::pixels::Color;
+use sdl2::rect::Rect;
struct Window {
+ buff: RefCell<[[u8; 256]; 240]>
}
impl ppu::Screen for Window {
- fn put(&mut self, x: u8, y: u8, color: u8) {
- println!("put color 0x{:02x} at ({}, {})", color, x, y);
+ fn put(&self, x: u8, y: u8, color: u8) {
+ self.buff.borrow_mut()[y as usize][x as usize] = color;
}
fn render(&self) {
- println!("a frame has been redrawn");
+ println!("a frame has been redrawn:");
+ for r in self.buff.borrow().iter() {
+ for c in r.iter() {
+ print!("{:02x}", c);
+ }
+ println!("");
+ }
+ }
+}
+
+struct SDLWindow {
+ canvas: RefCell<sdl2::render::WindowCanvas>
+}
+
+impl SDLWindow {
+ fn new() -> Self {
+ let sdl_context = sdl2::init().unwrap();
+ let video_subsystem = sdl_context.video().unwrap();
+ let window = video_subsystem.window("rust-sdl2 demo: Video", 256 * PIXEL_SIZE, 240 * PIXEL_SIZE)
+ .position_centered()
+ .opengl()
+ .build()
+ .unwrap();
+ let mut canvas = window.into_canvas().build().unwrap();
+ canvas.set_draw_color(Color::RGB(255, 255, 255));
+ canvas.clear();
+ canvas.present();
+ SDLWindow {
+ canvas: RefCell::new(canvas)
+ }
}
}
+const PIXEL_SIZE: u32 = 2;
+const COLORS: [u32; 64] = [
+ 0x666666, 0x002A88, 0x1412A7, 0x3B00A4, 0x5C007E, 0x6E0040, 0x6C0600, 0x561D00,
+ 0x333500, 0x0B4800, 0x005200, 0x004F08, 0x00404D, 0x000000, 0x000000, 0x000000,
+ 0xADADAD, 0x155FD9, 0x4240FF, 0x7527FE, 0xA01ACC, 0xB71E7B, 0xB53120, 0x994E00,
+ 0x6B6D00, 0x388700, 0x0C9300, 0x008F32, 0x007C8D, 0x000000, 0x000000, 0x000000,
+ 0xFFFEFF, 0x64B0FF, 0x9290FF, 0xC676FF, 0xF36AFF, 0xFE6ECC, 0xFE8170, 0xEA9E22,
+ 0xBCBE00, 0x88D800, 0x5CE430, 0x45E082, 0x48CDDE, 0x4F4F4F, 0x000000, 0x000000,
+ 0xFFFEFF, 0xC0DFFF, 0xD3D2FF, 0xE8C8FF, 0xFBC2FF, 0xFEC4EA, 0xFECCC5, 0xF7D8A5,
+ 0xE4E594, 0xCFEF96, 0xBDF4AB, 0xB3F3CC, 0xB5EBF2, 0xB8B8B8, 0x000000, 0x000000,
+];
+
+fn get_rgb(color: u8) -> Color {
+ let c = COLORS[color as usize];
+ Color::RGB((c >> 16) as u8, ((c >> 8) & 0xff) as u8, (c & 0xff) as u8)
+}
+
+impl ppu::Screen for SDLWindow {
+ fn put(&self, x: u8, y: u8, color: u8) {
+ let mut canvas = self.canvas.borrow_mut();
+ println!("put {} at {}, {}", color, x, y);
+ canvas.set_draw_color(get_rgb(color));
+ canvas.draw_rect(Rect::new((x as u32 * PIXEL_SIZE) as i32,
+ (y as u32 * PIXEL_SIZE) as i32,
+ PIXEL_SIZE, PIXEL_SIZE));
+ }
+
+ fn render(&self) {
+ let mut canvas = self.canvas.borrow_mut();
+ canvas.present();
+ canvas.clear();
+ }
+}
+
+#[repr(C, packed)]
+struct INesHeader {
+ magic: [u8; 4],
+ prg_rom_nbanks: u8,
+ chr_rom_nbanks: u8,
+ flags6: u8,
+ flags7: u8,
+ prg_ram_nbanks: u8,
+ flags9: u8,
+ flags10: u8,
+ padding: [u8; 5]
+}
+
fn main() {
- //let mut ppu = ppu::PPU::new(
- let mut cart = cartridge::Cartridge::new();
- let mut mapper = mapper::Mapper2::new(&mut cart);
- let mut mem = memory::CPUMemory::new(null_mut(), null_mut(), &mut mapper);
- let cpu = mos6502::CPU::new(&mut mem);
+ let fname = std::env::args().nth(1).unwrap();
+ let mut file = File::open(fname).unwrap();
+ let mut rheader = [0; 16];
+ println!("read {}", file.read(&mut rheader[..]).unwrap());
+ let header = unsafe{transmute::<[u8; 16], INesHeader>(rheader)};
+ let mirror = match ((header.flags6 >> 2) & 2) | (header.flags6 & 1) {
+ 0 => MirrorType::Horizontal,
+ 1 => MirrorType::Vertical,
+ 2 => MirrorType::Single0,
+ 3 => MirrorType::Single1,
+ _ => MirrorType::Four,
+ };
+ let mapper_id = (header.flags7 & 0xf0) | (header.flags6 >> 4);
+ println!("maigc:{} prg:{} chr:{} mirror:{} mapper:{}",
+ std::str::from_utf8(&header.magic).unwrap(),
+ header.prg_rom_nbanks,
+ header.chr_rom_nbanks,
+ mirror as u8,
+ mapper_id);
+ if header.flags6 & 0x04 == 0x04 {
+ let mut trainer: [u8; 512] = unsafe{std::mem::uninitialized()};
+ file.read(&mut trainer[..]);
+ println!("skipping trainer");
+ }
+
+ let prg_len = header.prg_rom_nbanks as usize * 0x4000;
+ let mut chr_len = header.chr_rom_nbanks as usize * 0x2000;
+ if chr_len == 0 {
+ chr_len = 0x2000;
+ }
+ let mut prg_rom = Vec::<u8>::with_capacity(prg_len);
+ let mut chr_rom = Vec::<u8>::with_capacity(chr_len);
+ unsafe {
+ prg_rom.set_len(prg_len);
+ chr_rom.set_len(chr_len);
+ }
+ let sram = vec![0; 0x4000];
+ println!("read prg {}", file.read(&mut prg_rom[..]).unwrap());
+ for (i, v) in prg_rom.iter().enumerate() {
+ print!("{:02x} ", v);
+ if i & 15 == 15 {
+ println!(" {:04x}", i);
+ }
+ }
+ println!("read chr {}", file.read(&mut chr_rom[..]).unwrap());
+ for (i, v) in chr_rom.iter().enumerate() {
+ print!("{:02x} ", v);
+ if i & 15 == 15 {
+ println!("");
+ }
+ }
+ let cart = cartridge::Cartridge::new(chr_rom, prg_rom, sram, mirror);
+ //let win = Window {buff: RefCell::new([[0; 256]; 240])};
+ let win = SDLWindow::new();
+ let mapper = mapper::Mapper2::new(&cart);
+ let pmem = memory::PPUMemory::new(&mapper, &cart);
+ let mem = memory::CPUMemory::new(&mapper);
+ let mut ppu = ppu::PPU::new(&pmem, &win);
+ let mut cpu = mos6502::CPU::new(&mem);
+ mem.init(&mut cpu, &mut ppu);
+
+ loop {
+ cpu.step();
+ //println!("cpu at 0x{:04x}", cpu.get_pc());
+ while cpu.cycle > 0 {
+ for _ in 0..3 {
+ if ppu.tick() {
+ println!("triggering nmi");
+ cpu.trigger_nmi();
+ }
+ }
+ cpu.cycle -= 1;
+ }
+ }
}
diff --git a/src/mapper.rs b/src/mapper.rs
index 7522454..c54acb4 100644
--- a/src/mapper.rs
+++ b/src/mapper.rs
@@ -1,40 +1,44 @@
#![allow(dead_code)]
use memory::VMem;
use cartridge::{Cartridge, BankType};
+use core::cell::RefCell;
+
pub struct Mapper2<'a> {
cart: &'a Cartridge,
- prg_bank1: &'a [u8],
- prg_bank2: &'a [u8],
- chr_bank: &'a mut [u8],
- sram: &'a mut [u8],
- bank_num: usize
+ prg_bank1: RefCell<&'a [u8]>,
+ prg_bank2: RefCell<&'a [u8]>,
+ chr_bank: RefCell<&'a mut [u8]>,
+ sram: RefCell<&'a mut [u8]>,
+ prg_nbank: usize
}
impl<'a> VMem for Mapper2<'a> {
fn read(&self, addr: u16) -> u8 {
let addr = addr as usize;
- if addr < 0x2000 {
- self.chr_bank[addr]
- } else if addr >= 0xc000 {
- self.prg_bank2[addr - 0xc000]
- } else if addr >= 0x8000 {
- self.prg_bank1[addr - 0x8000]
+ if addr < 0x2000 { /* 0x2000 size bank */
+ self.chr_bank.borrow()[addr]
+ } else if addr >= 0xc000 { /* 0x4000 size bank */
+ self.prg_bank2.borrow()[addr - 0xc000]
+ } else if addr >= 0x8000 { /* 0x4000 size bank */
+ self.prg_bank1.borrow()[addr - 0x8000]
} else if addr >= 0x6000 {
- self.sram[addr - 0x6000]
+ self.sram.borrow()[addr - 0x6000]
} else {
panic!("unmapped address: 0x{:04x}", addr)
}
}
- fn write(&mut self, addr: u16, data: u8) {
+ fn write(&self, addr: u16, data: u8) {
let addr = addr as usize;
if addr < 0x2000 {
- self.chr_bank[addr] = data;
+ self.chr_bank.borrow_mut()[addr] = data;
} else if addr >= 0x8000 {
- self.prg_bank1 = unsafe {&*self.cart.get_bank(
- data as usize % self.bank_num, BankType::PrgRom)};
+ (*self.prg_bank1.borrow_mut()) = unsafe {
+ &*self.cart.get_bank(((data as usize) % self.prg_nbank) << 14,
+ 0x4000,
+ BankType::PrgRom)};
} else if addr >= 0x6000 {
- self.sram[addr - 0x6000] = data;
+ self.sram.borrow_mut()[addr - 0x6000] = data;
} else {
panic!("invalid write to address: 0x{:04x}", addr);
}
@@ -42,15 +46,16 @@ impl<'a> VMem for Mapper2<'a> {
}
impl<'a> Mapper2<'a> {
- pub fn new(cart: &'a mut Cartridge) -> Self {
- let bank_num = cart.get_bank_num(BankType::PrgRom);
+ pub fn new(cart: *const Cartridge) -> Self {
unsafe {
- Mapper2{cart,
- prg_bank1: &*cart.get_bank(0, BankType::PrgRom),
- prg_bank2: &*cart.get_bank(bank_num - 1, BankType::PrgRom),
- chr_bank: &mut *cart.get_bank(0, BankType::ChrRom),
- sram: &mut *cart.get_bank(0, BankType::Sram),
- bank_num}
+ let cart = &*cart;
+ let nbank = cart.get_size(BankType::PrgRom) >> 14;
+ Mapper2{cart: &cart,
+ prg_bank1: RefCell::new(&*cart.get_bank(0, 0x4000, BankType::PrgRom)),
+ prg_bank2: RefCell::new(&*cart.get_bank((nbank - 1) << 14, 0x4000, BankType::PrgRom)),
+ chr_bank: RefCell::new(&mut *cart.get_bank(0, 0x2000, BankType::ChrRom)),
+ sram: RefCell::new(&mut *cart.get_bank(0, 0x2000, BankType::Sram)),
+ prg_nbank: nbank}
}
}
}
diff --git a/src/memory.rs b/src/memory.rs
index f506a86..9b5f322 100644
--- a/src/memory.rs
+++ b/src/memory.rs
@@ -1,44 +1,52 @@
+#![allow(dead_code)]
use ppu::PPU;
use mos6502::CPU;
use cartridge::{MirrorType, Cartridge};
-use core::cell::{RefCell, RefMut};
+use core::cell::{RefCell, Cell};
+use core::ptr::null_mut;
pub trait VMem {
fn read(&self, addr: u16) -> u8;
- fn write(&mut self, addr: u16, data: u8);
+ fn write(&self, addr: u16, data: u8);
}
pub struct CPUMemory<'a> {
- internal: [u8; 2048],
- ppu: *mut PPU<'a>,
- cpu: *mut CPU<'a>,
- mapper: &'a mut VMem
+ sram: RefCell<[u8; 2048]>,
+ ppu: Cell<*mut PPU<'a>>,
+ cpu: Cell<*mut CPU<'a>>,
+ mapper: &'a VMem
}
impl<'a> CPUMemory<'a> {
- pub fn new(cpu: *mut CPU<'a>,
- ppu: *mut PPU<'a>,
- mapper: &'a mut VMem) -> Self {
- CPUMemory{internal: [0; 2048],
- cpu, ppu,
+ pub fn new(mapper: &'a VMem) -> Self {
+ CPUMemory{sram: RefCell::new([0; 2048]),
+ cpu: Cell::new(null_mut()),
+ ppu: Cell::new(null_mut()),
mapper}
}
+
+ pub fn init(&self,
+ cpu: *mut CPU<'a>,
+ ppu: *mut PPU<'a>) {
+ self.cpu.set(cpu);
+ self.ppu.set(ppu);
+ }
}
impl<'a> VMem for CPUMemory<'a> {
fn read(&self, addr: u16) -> u8 {
match addr {
_ => if addr < 0x2000 {
- self.internal[(addr & 0x07ff) as usize]
+ self.sram.borrow()[(addr & 0x07ff) as usize]
} else if addr < 0x4000 {
- let ppu = unsafe {&mut *self.ppu};
+ let ppu = unsafe {&mut *self.ppu.get()};
match addr & 0x7 {
0x2 => ppu.read_status(),
0x4 => ppu.read_oamdata(),
0x7 => ppu.read_data(),
- _ => panic!("invalid ppu reg read access at 0x{:04x}", addr)
+ _ => 0
}
- } else if addr < 0x4020 {
+ } else if addr < 0x6000 {
println!("feeding dummy data for 0x{:04x}", addr);
0
} else {
@@ -46,11 +54,11 @@ impl<'a> VMem for CPUMemory<'a> {
}
}
}
- fn write(&mut self, addr: u16, data: u8) {
- let ppu = unsafe {&mut *self.ppu};
- let cpu = unsafe {&mut *self.cpu};
+ fn write(&self, addr: u16, data: u8) {
+ let ppu = unsafe {&mut *self.ppu.get()};
+ let cpu = unsafe {&mut *self.cpu.get()};
if addr < 0x2000 {
- self.internal[(addr & 0x07ff) as usize] = data;
+ self.sram.borrow_mut()[(addr & 0x07ff) as usize] = data;
} else if addr < 0x4000 {
match addr & 0x7 {
0x0 => ppu.write_ctl(data),
@@ -67,6 +75,7 @@ impl<'a> VMem for CPUMemory<'a> {
0x4014 => ppu.write_oamdma(data, cpu),
_ => println!("ignore writing for 0x{:04x}", addr)
}
+ } else if addr < 0x6000 {
} else {
self.mapper.write(addr, data)
}
@@ -74,20 +83,20 @@ impl<'a> VMem for CPUMemory<'a> {
}
pub struct PPUMemory<'a> {
- pattern_table: [u8; 0x2000],
- nametable: [u8; 0x1000],
- palette: [u8; 0x20],
+ pattern_table: RefCell<[u8; 0x2000]>,
+ nametable: RefCell<[u8; 0x1000]>,
+ palette: RefCell<[u8; 0x20]>,
cart: &'a Cartridge,
- mapper: &'a mut VMem,
+ mapper: &'a VMem,
}
impl<'a> PPUMemory<'a> {
- pub fn new(mapper: &'a mut VMem,
+ pub fn new(mapper: &'a VMem,
cart: &'a Cartridge) -> Self {
PPUMemory{
- pattern_table: [0; 0x2000],
- nametable: [0; 0x1000],
- palette: [0; 0x20],
+ pattern_table: RefCell::new([0; 0x2000]),
+ nametable: RefCell::new([0; 0x1000]),
+ palette: RefCell::new([0; 0x20]),
cart,
mapper}
}
@@ -115,31 +124,36 @@ fn mirror_palette(addr: u16) -> u16 {
}
impl<'a> VMem for PPUMemory<'a> {
- fn read(&self, addr: u16) -> u8 {
+ fn read(&self, mut addr: u16) -> u8 {
+ addr &= 0x3fff;
if addr < 0x2000 {
- //self.pattern_table[addr as usize]
self.mapper.read(addr)
} else if addr < 0x3f00 {
let kind = self.cart.mirror_type;
- self.nametable[(get_mirror_addr(kind, addr) & 0x07ff) as usize]
+ self.nametable.borrow()
+ [(get_mirror_addr(kind, addr) & 0x07ff) as usize]
} else if addr < 0x4000 {
- self.palette[mirror_palette(addr & 0x1f) as usize]
+ self.palette.borrow()
+ [mirror_palette(addr & 0x1f) as usize]
} else {
panic!("invalid ppu read access at 0x{:04x}", addr)
}
}
- fn write(&mut self, addr: u16, data: u8) {
+ fn write(&self, mut addr: u16, data: u8) {
+ addr &= 0x3fff;
+ println!("writing 0x{:02x} to 0x{:04x}", data, addr);
if addr < 0x2000 {
- //self.pattern_table[addr as usize] = data
self.mapper.write(addr, data)
} else if addr < 0x3f00 {
let kind = self.cart.mirror_type;
- self.nametable[(get_mirror_addr(kind, addr) & 0x07ff) as usize] = data
+ self.nametable.borrow_mut()
+ [(get_mirror_addr(kind, addr) & 0x07ff) as usize] = data
} else if addr < 0x4000 {
- self.palette[mirror_palette(addr & 0x1f) as usize] = data
+ self.palette.borrow_mut()
+ [mirror_palette(addr & 0x1f) as usize] = data
} else {
- panic!("invalid ppu read access at 0x{:04x}", addr)
+ panic!("invalid ppu write access at 0x{:04x}", addr)
}
}
diff --git a/src/mos6502.rs b/src/mos6502.rs
index 58ac217..c439700 100644
--- a/src/mos6502.rs
+++ b/src/mos6502.rs
@@ -132,7 +132,7 @@ pub mod disasm {
format!("${:02x}, y", code.next().unwrap())
}
fn rel(code: T) -> String {
- let b = *code.next().unwrap() as i8;
+ let b = *code.next().unwrap() as i8 as i16;
if b >= 0 {
format!("+${:02x}, x", b)
} else {
@@ -229,10 +229,9 @@ mod ops {
let opr1 = cpu.a as u16;
let opr2 = match cpu.addr_mode {
AddrMode::Immediate => cpu.imm_val,
- AddrMode::Accumulator => cpu.a,
- AddrMode::EffAddr => cpu.mem.read(cpu.ea)
+ _ => cpu.mem.read(cpu.ea)
} as u16;
- let res = opr1 + opr2 + cpu.get_carry() as u16;
+ let res = opr1 + opr2 + (cpu.get_carry() as u16);
let mut status = cpu.status & !(CARRY_FLAG | ZERO_FLAG | OVER_FLAG | NEG_FLAG);
cpu.a = res as u8;
status |= (res > 0xff) as u8; /* carry flag */
@@ -248,10 +247,9 @@ mod ops {
let opr1 = cpu.a as u16;
let opr2 = match cpu.addr_mode {
AddrMode::Immediate => cpu.imm_val,
- AddrMode::Accumulator => cpu.a,
- AddrMode::EffAddr => cpu.mem.read(cpu.ea)
+ _ => cpu.mem.read(cpu.ea)
} as u16;
- let res = opr1 + (0xff - opr2) + cpu.get_carry() as u16;
+ let res = opr1 + (0xff - opr2) + (cpu.get_carry() as u16);
let mut status = cpu.status & !(CARRY_FLAG | ZERO_FLAG | OVER_FLAG | NEG_FLAG);
cpu.a = res as u8;
status |= (res > 0xff) as u8; /* carry flag */
@@ -269,9 +267,9 @@ mod ops {
AddrMode::Immediate => cpu.imm_val,
_ => cpu.mem.read(cpu.ea)
} as u16;
- let res = opr1 - opr2;
+ let res = opr1.wrapping_sub(opr2);
let mut status = cpu.status & !(CARRY_FLAG | ZERO_FLAG | NEG_FLAG);
- status |= (res < 0x100) as u8; /* carry flag */
+ status |= (res < 0x100) as u8; /* if opr1 >= opr2 */
check_zero!(status, res);
check_neg!(status, res);
cpu.status = status;
@@ -286,16 +284,16 @@ mod ops {
macro_rules! make_delta {
($f: ident, $d: expr) => (
fn $f(cpu: &mut CPU) {
- let res = cpu.mem.read(cpu.ea) as u16 + $d;
+ let res = cpu.mem.read(cpu.ea).wrapping_add($d);
let mut status = cpu.status & !(ZERO_FLAG | NEG_FLAG);
- cpu.mem.write(cpu.ea, res as u8);
+ cpu.mem.write(cpu.ea, res);
check_zero!(status, res);
check_neg!(status, res);
cpu.status = status;
});
($f: ident, $d: expr, $r: ident) => (
fn $f(cpu: &mut CPU) {
- let res = cpu.$r as u16 + $d;
+ let res = cpu.$r.wrapping_add($d);
let mut status = cpu.status & !(ZERO_FLAG | NEG_FLAG);
cpu.$r = res as u8;
check_zero!(status, res);
@@ -514,8 +512,11 @@ mod ops {
macro_rules! make_ld {
($f: ident, $r: ident) => (fn $f(cpu: &mut CPU) {
let mut status = cpu.status & !(ZERO_FLAG | NEG_FLAG);
- let res = cpu.mem.read(cpu.ea);
- cpu.a = res;
+ let res = match cpu.addr_mode {
+ AddrMode::Immediate => cpu.imm_val,
+ _ => cpu.mem.read(cpu.ea)
+ };
+ cpu.$r = res;
check_zero!(status, res);
check_neg!(status, res);
cpu.status = status;
@@ -612,20 +613,20 @@ mod addr {
fn zpx(cpu: &mut CPU) {
cpu.addr_mode = AddrMode::EffAddr;
cpu.ea = (cpu.mem.read(cpu.opr)
- .wrapping_add(cpu.x)) as u16;
+ .wrapping_add(cpu.x)) as u16;
}
fn zpy(cpu: &mut CPU) {
cpu.addr_mode = AddrMode::EffAddr;
cpu.ea = (cpu.mem.read(cpu.opr)
- .wrapping_add(cpu.y)) as u16;
+ .wrapping_add(cpu.y)) as u16;
}
fn rel(cpu: &mut CPU) {
cpu.addr_mode = AddrMode::EffAddr;
let base = cpu.pc;
let offset = cpu.mem.read(cpu.opr) as i8 as i16;
- let sum = (base & 0xff) + offset as u16;
+ let sum = ((base & 0xff) as i16 + offset) as u16;
cpu.ea = (base & 0xff00).wrapping_add(sum);
cpu.cycle += (sum >> 8) as u32;
}
@@ -638,7 +639,7 @@ mod addr {
fn abx(cpu: &mut CPU) {
cpu.addr_mode = AddrMode::EffAddr;
let base = read16!(cpu.mem, cpu.opr);
- let sum = (base & 0xff) + cpu.x as u16;
+ let sum = (base & 0xff) + (cpu.x as u16);
cpu.ea = (base & 0xff00).wrapping_add(sum);
cpu.cycle += (sum >> 8) as u32; /* boundary cross if carry */
}
@@ -646,7 +647,7 @@ mod addr {
fn aby(cpu: &mut CPU) {
cpu.addr_mode = AddrMode::EffAddr;
let base = read16!(cpu.mem, cpu.opr);
- let sum = (base & 0xff) + cpu.y as u16;
+ let sum = (base & 0xff) + (cpu.y as u16);
cpu.ea = (base & 0xff00).wrapping_add(sum);
cpu.cycle += (sum >> 8) as u32; /* boundary cross if carry */
}
@@ -659,17 +660,15 @@ mod addr {
fn xin(cpu: &mut CPU) {
cpu.addr_mode = AddrMode::EffAddr;
- let addr = cpu.mem.read(
- cpu.mem.read(cpu.opr)
- .wrapping_add(cpu.x) as u16) as u16;
- cpu.ea = read16!(cpu.mem, addr);
+ cpu.ea = read16!(cpu.mem,
+ cpu.mem.read(cpu.opr)
+ .wrapping_add(cpu.x) as u16) as u16;
}
fn iny(cpu: &mut CPU) {
cpu.addr_mode = AddrMode::EffAddr;
- let addr = cpu.mem.read(cpu.mem.read(cpu.opr) as u16) as u16;
- let base = read16!(cpu.mem, addr);
- let sum = (base & 0xff) + cpu.y as u16;
+ let base = read16!(cpu.mem, cpu.mem.read(cpu.opr) as u16);
+ let sum = (base & 0xff) + (cpu.y as u16);
cpu.ea = (base & 0xff00).wrapping_add(sum);
cpu.cycle += (sum >> 8) as u32; /* boundary cross if carry */
}
@@ -703,7 +702,7 @@ pub struct CPU<'a> {
imm_val: u8,
pub cycle: u32,
int: Option<IntType>,
- pub mem: &'a mut VMem
+ pub mem: &'a VMem
}
macro_rules! make_int {
@@ -728,7 +727,7 @@ impl<'a> CPU<'a> {
#[inline(always)] pub fn get_over(&self) -> u8 { (self.status >> 6) & 1 }
#[inline(always)] pub fn get_neg(&self) -> u8 { (self.status >> 7) & 1 }
- pub fn new(mem: &'a mut VMem) -> Self {
+ pub fn new(mem: &'a VMem) -> Self {
let pc = read16!(mem, RESET_VECTOR as u16);
/* nes power up state */
let a = 0;
@@ -750,14 +749,21 @@ impl<'a> CPU<'a> {
make_int!(irq, IRQ_VECTOR);
pub fn step(&mut self) {
- let pc = self.pc;
match self.int {
Some(IntType::NMI) => self.nmi(),
Some(IntType::IRQ) => self.irq(),
_ => ()
}
self.int = None;
+ let pc = self.pc;
let opcode = self.mem.read(pc) as usize;
+ let len = INST_LENGTH[opcode];
+ let mut code = vec![0; len as usize];
+ for i in 0..len as u16 {
+ code[i as usize] = self.mem.read(pc + i);
+ }
+ println!("0x{:04x} {} a:{} x:{} y:{}",
+ pc, disasm::parse(opcode as u8, &code[1..]), self.a, self.x, self.y);
/* update opr pointing to operands of current inst */
self.opr = pc.wrapping_add(1);
/* update program counter pointing to next inst */
@@ -769,16 +775,7 @@ impl<'a> CPU<'a> {
self.cycle += INST_CYCLE[opcode] as u32;
}
- pub fn powerup(&mut self) {
- self.pc = read16!(self.mem, RESET_VECTOR as u16);
- /* nes power up state */
- self.a = 0;
- self.x = 0;
- self.y = 0;
- self.sp = 0xfd;
- self.status = 0x34;
- self.cycle = 0;
- }
+ pub fn get_pc(&self) -> u16 { self.pc }
pub fn reset(&mut self) {
self.pc = read16!(self.mem, RESET_VECTOR as u16);
diff --git a/src/ppu.rs b/src/ppu.rs
index 6aea1fc..dd3d01e 100644
--- a/src/ppu.rs
+++ b/src/ppu.rs
@@ -4,7 +4,7 @@ use mos6502::CPU;
use core::intrinsics::transmute;
pub trait Screen {
- fn put(&mut self, x: u8, y: u8, color: u8);
+ fn put(&self, x: u8, y: u8, color: u8);
fn render(&self);
}
@@ -18,9 +18,6 @@ struct Sprite {
}
pub struct PPU<'a> {
- /* internal srams */
- nametable_ram: [u8; 2048],
- palette_ram: [u8; 32],
scanline: u16,
/* registers */
ppuctl: u8,
@@ -38,7 +35,7 @@ pub struct PPU<'a> {
/* rendering regs & latches */
/* background registers */
bg_bitmap: [u16; 2],
- bg_palette: [u8; 2],
+ bg_palette: [u16; 2],
/* background latches */
bg_nt: u8,
bg_attr: u8,
@@ -53,8 +50,8 @@ pub struct PPU<'a> {
rendering: bool,
buffered_read: u8,
/* IO */
- mem: &'a mut VMem,
- scr: &'a mut Screen,
+ mem: &'a VMem,
+ scr: &'a Screen,
}
impl<'a> PPU<'a> {
@@ -196,7 +193,7 @@ impl<'a> PPU<'a> {
/* 0x-??0 */
((self.bg_nt as u16) << 4) |
/* 0x---? (0 - 7) */
- (self.v >> 12) | 0x0);
+ ((self.v >> 12) & 7) | 0x0);
}
#[inline(always)]
@@ -206,7 +203,7 @@ impl<'a> PPU<'a> {
/* 0x-??0 */
((self.bg_nt as u16) << 4) |
/* 0x---? (8 - f) */
- (self.v >> 12) | 0x8);
+ ((self.v >> 12) & 7) | 0x8);
}
#[inline(always)]
@@ -214,21 +211,25 @@ impl<'a> PPU<'a> {
/* load the tile bitmap to high 8 bits of bitmap,
* assume the high 8 bits are zeros */
assert!(self.bg_bitmap[0] >> 8 == 0 &&
- self.bg_bitmap[1] >> 8 == 0);
- self.bg_bitmap[0] |= (self.bg_bit_low as u16) << 8;
- self.bg_bitmap[1] |= (self.bg_bit_high as u16) << 8;
- self.bg_palette[0] |= (self.bg_attr & 1) * 0xff;
- self.bg_palette[1] |= ((self.bg_attr >> 1) & 1) * 0xff;
+ self.bg_bitmap[1] >> 8 == 0 &&
+ self.bg_palette[0] >> 8 == 0 &&
+ self.bg_palette[1] >> 8 == 0);
+ self.bg_bitmap[0] |= (PPU::reverse_byte(self.bg_bit_low) as u16) << 8;
+ self.bg_bitmap[1] |= (PPU::reverse_byte(self.bg_bit_high) as u16) << 8;
+ self.bg_palette[0] |= (self.bg_attr & 1) as u16 * 0xff00;
+ self.bg_palette[1] |= ((self.bg_attr >> 1) & 1) as u16 * 0xff00;
}
#[inline(always)]
fn shift_sprites(&mut self) {
for (i, c) in self.sp_cnt.iter_mut().enumerate() {
+ if self.oam2[i].y == 0xff { break }
let c0 = *c;
match c0 {
0 => {
- self.sp_bitmap[i][0] >>= 1;
- self.sp_bitmap[i][1] >>= 1;
+ let t = &mut self.sp_bitmap[i];
+ t[0] = t[0].wrapping_shr(1);
+ t[1] = t[1].wrapping_shr(1);
},
_ => *c = c0 - 1
}
@@ -237,10 +238,12 @@ impl<'a> PPU<'a> {
#[inline(always)]
fn shift_bgtile(&mut self, d: u8) {
- self.bg_bitmap[0] >>= d;
- self.bg_bitmap[1] >>= d;
- self.bg_palette[0] >>= d;
- self.bg_palette[1] >>= d;
+ let t1 = &mut self.bg_bitmap;
+ let t2 = &mut self.bg_palette;
+ t1[0] = t1[0].wrapping_shr(d as u32);
+ t1[1] = t1[1].wrapping_shr(d as u32);
+ t2[0] = t2[0].wrapping_shr(d as u32);
+ t2[1] = t2[1].wrapping_shr(d as u32);
}
#[inline(always)]
@@ -260,12 +263,12 @@ impl<'a> PPU<'a> {
false => self.v += 0x1000, /* fine y < 7 */
true => {
self.v &= !0x7000u16; /* fine y <- 0 */
- self.v = (self.v & !0x03e0u16) |
- (match (self.v & 0x03e0) >> 5 {
+ let y = match (self.v & 0x03e0) >> 5 {
29 => {self.v ^= 0x0800; 0}, /* at bottom of scanline */
31 => 0, /* do not switch nt */
y => y + 1
- }) << 5;
+ };
+ self.v = (self.v & !0x03e0u16) | (y << 5);
}
}
}
@@ -333,25 +336,26 @@ impl<'a> PPU<'a> {
fn fetch_sprite(&mut self) {
/* we use scanline here because s.y is the (actual y) - 1 */
- for (i, v) in self.oam2.iter().enumerate() {
- let vflip = (v.attr & 0x80) == 0x80;
- let y0 = self.scanline - v.y as u16;
+ for (i, s) in self.oam2.iter().enumerate() {
+ if s.y == 0xff { break }
+ let vflip = (s.attr & 0x80) == 0x80;
+ let y0 = self.scanline - s.y as u16;
let (ptable, tidx, y) = match self.get_spritesize() {
0 => {
let y = if vflip {7 - y0 as u8} else {y0 as u8};
- ((self.ppuctl as u16 & 0x08) << 9, v.tile, y)
+ ((self.ppuctl as u16 & 0x08) << 9, s.tile, y)
},
_ => {
let y = if vflip {15 - y0 as u8} else {y0 as u8};
- ((v.tile as u16 & 1) << 12,
- (v.tile & !1u8) | (y >> 3),
+ ((s.tile as u16 & 1) << 12,
+ (s.tile & !1u8) | (y >> 3),
y & 0x7)
}
};
- self.sp_cnt[i] = v.x;
+ self.sp_cnt[i] = s.x;
let mut low = self.mem.read(ptable | ((tidx as u16) << 4) | 0x0 | y as u16);
let mut high = self.mem.read(ptable | ((tidx as u16) << 4) | 0x8 | y as u16);
- if (v.attr & 0x40) == 0x40 {
+ if (s.attr & 0x40) != 0x40 {
low = PPU::reverse_byte(low);
high = PPU::reverse_byte(high);
}
@@ -375,6 +379,7 @@ impl<'a> PPU<'a> {
}
fn render_pixel(&mut self) {
+ println!("ppuctl:{} ppumask:{}", self.ppuctl, self.ppumask);
let x = self.cycle - 1;
let bg_pidx =
if x >= 8 || self.get_show_leftmost_bg() {self.get_bg_pidx()}
@@ -384,6 +389,7 @@ impl<'a> PPU<'a> {
let mut pri = 0x1;
if x >= 8 || self.get_show_leftmost_sp() {
for i in 0..8 {
+ if self.oam2[i].y == 0xff { break }
if self.sp_cnt[i] != 0 { continue; } /* not active */
match self.get_sp_pidx(i) {
0x0 => (),
@@ -401,7 +407,7 @@ impl<'a> PPU<'a> {
}
assert!(0 < self.cycle && self.cycle < 257);
assert!(self.scanline < 240);
- self.scr.put(self.cycle as u8 - 1,
+ self.scr.put((self.cycle - 1) as u8,
self.scanline as u8,
if (pri == 0 || bg_pidx == 0) && sp_pidx != 0 {
self.mem.read(0x3f10 |
@@ -415,7 +421,7 @@ impl<'a> PPU<'a> {
});
}
- pub fn new(mem: &'a mut VMem, scr: &'a mut Screen) -> Self {
+ pub fn new(mem: &'a VMem, scr: &'a Screen) -> Self {
let ppuctl = 0x00;
let ppumask = 0x00;
let ppustatus = 0xa0;
@@ -425,8 +431,6 @@ impl<'a> PPU<'a> {
let cycle = 370;
let scanline = 240;
PPU {
- nametable_ram: [0; 2048],
- palette_ram: [0; 32],
scanline,
ppuctl,
ppumask,
@@ -468,22 +472,24 @@ impl<'a> PPU<'a> {
let visible = self.scanline < 240;
let pre_render = self.scanline == 261;
self.rendering = pre_render || visible;
- if pre_render {
- if cycle == 1 {
- /* clear vblank, sprite zero hit & overflow */
- self.ppustatus &= !(PPU::FLAG_VBLANK |
- PPU::FLAG_SPRITE_ZERO | PPU::FLAG_OVERFLOW);
- } else if 279 < cycle && cycle < 305 {
- self.reset_y();
+ if self.rendering && (self.get_show_bg() || self.get_show_sp()) {
+ if pre_render {
+ if cycle == 1 {
+ /* clear vblank, sprite zero hit & overflow */
+ self.ppustatus &= !(PPU::FLAG_VBLANK |
+ PPU::FLAG_SPRITE_ZERO | PPU::FLAG_OVERFLOW);
+ } else if 279 < cycle && cycle < 305 {
+ self.reset_y();
+ }
}
- }
- if self.rendering {
let shifting = 0 < cycle && cycle < 257; /* 1..256 */
let fetch = shifting || (320 < cycle && cycle < 337);
if fetch { /* 1..256 and 321..336 */
match cycle & 0x7 {
1 => {
- self.load_bgtile();
+ if shifting {
+ self.load_bgtile();
+ }
self.fetch_nametable_byte();
},
3 => self.fetch_attrtable_byte(),
Powered by cgit, Themed by Ted Yin.