implement ppu addr and data registers

Author: Duckulus

src/cpu/cpu_memory.rs

@@ -1,5 +1,5 @@
 use crate::nes_rom::NesRom;
-use crate::ram::Ram;
+use crate::memory::{Memory, Ram};
 
 pub struct CpuMemory {
     sram: Ram,

src/main.rs

@@ -1,7 +1,7 @@
 mod cpu;
 mod nes_rom;
 mod ppu;
-mod ram;
+mod memory;
 
 use crate::nes_rom::NesRom;
 use crate::ppu::Ppu;
@@ -17,7 +17,7 @@ const COLORS: [Color; 4] = [BLACK, DARKGRAY, LIGHTGRAY, WHITE];
 async fn main() -> Result<(), anyhow::Error> {
     println!("Starting Emulator!");
 
-    let rom = NesRom::read_from_file("./tetris.nes")?;
+    let rom = NesRom::read_from_file("./dk.nes")?;
     println!("{rom:#?}");
 
     let memory_map = CpuMemory::new(rom.clone());

src/memory.rs

@@ -0,0 +1,77 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub trait Memory {
+    fn read(&self, addr: u16) -> u8;
+    fn write(&mut self, addr: u16, data: u8);
+}
+
+pub struct Ram(Vec<u8>);
+
+impl Ram {
+    pub fn new(size: usize) -> Self {
+        Self(vec![0; size])
+    }
+}
+
+impl Memory for Ram {
+    #[inline]
+    fn read(&self, a: u16) -> u8 {
+        self.0[a as usize]
+    }
+
+    #[inline]
+    fn write(&mut self, a: u16, v: u8) {
+        self.0[a as usize] = v;
+    }
+}
+
+pub struct DummyMemory {
+    last_read_addr: RefCell<u16>,
+    last_write_addr: u16,
+    last_write_value: u8
+}
+
+impl DummyMemory {
+    pub fn new() -> Self {
+        DummyMemory {
+            last_read_addr: RefCell::new(0),
+            last_write_addr: 0,
+            last_write_value: 0
+        }
+    }
+
+    pub fn last_read_addr(&self) -> u16 {
+        *self.last_read_addr.borrow()
+    }
+
+    pub fn last_write_addr(&self) -> u16 {
+        self.last_write_addr
+    }
+
+    pub fn last_write_value(&self) -> u8 {
+        self.last_write_value
+    }
+}
+
+impl Memory for DummyMemory {
+    fn read(&self, addr: u16) -> u8 {
+        *self.last_read_addr.borrow_mut() = addr;
+        (addr & 0xFF) as u8
+    }
+
+    fn write(&mut self, addr: u16, data: u8) {
+        self.last_write_addr = addr;
+        self.last_write_value = data;
+    }
+}
+
+impl<T: Memory> Memory for Rc<RefCell<T>> {
+    fn read(&self, addr: u16) -> u8 {
+        self.as_ref().borrow().read(addr)
+    }
+
+    fn write(&mut self, addr: u16, data: u8) {
+        self.as_ref().borrow_mut().write(addr, data);
+    }
+}

src/ppu.rs

@@ -1,3 +1,4 @@
+use crate::memory::Memory;
 use crate::nes_rom::NametableMirroring;
 use crate::ppu::ppu_memory::PpuMemory;
 
@@ -33,8 +34,10 @@ impl PpuAddr {
         ((self.hi as u16) << 8 | (self.lo as u16)) & PPU_ADDR_MASK
     }
 
-    fn increment_addr(&mut self, amount: u16) {
-        //TODO
+    fn increment_addr(&mut self, amount: u8) {
+        let new_addr = self.get_addr().wrapping_add(amount as u16);
+        self.hi = (new_addr >> 8) as u8;
+        self.lo = (new_addr & 0xFF) as u8;
     }
 }
 
@@ -46,7 +49,7 @@ const PPU_SPRITE_SIZE_BIT: u8 = 5;
 const PPU_MASTER_SLAVE_SELECT_BIT: u8 = 6;
 const PPU_VBLANK_NMI_BIT: u8 = 7;
 
-struct PpuRegisters {
+pub struct Ppu<M: Memory> {
     ctrl: u8,
     mask: u8,
     status: u8,
@@ -56,10 +59,12 @@ struct PpuRegisters {
     addr: PpuAddr,
     data_buffer: u8,
     oam_dma: u8,
+
+    memory: M,
 }
 
-impl PpuRegisters {
-    pub fn new() -> Self {
+impl Ppu<PpuMemory> {
+    pub fn new(chr_rom: Vec<u8>, mirroring: NametableMirroring) -> Self {
         Self {
             ctrl: 0,
             mask: 0,
@@ -70,20 +75,117 @@ impl PpuRegisters {
             addr: PpuAddr::new(),
             data_buffer: 0,
             oam_dma: 0,
+            memory: PpuMemory::new(chr_rom, mirroring),
         }
     }
 }
 
-pub struct Ppu {
-    registers: PpuRegisters,
-    memory: PpuMemory,
-}
-
-impl Ppu {
-    pub fn new(chr_rom: Vec<u8>, mirroring: NametableMirroring) -> Self {
+impl<M: Memory> Ppu<M> {
+    fn new_with_memory(memory: M) -> Self {
         Self {
-            registers: PpuRegisters::new(),
-            memory: PpuMemory::new(chr_rom, mirroring),
+            ctrl: 0,
+            mask: 0,
+            status: 0,
+            oam_addr: 0,
+            oam_data: 0,
+            scroll: 0,
+            addr: PpuAddr::new(),
+            data_buffer: 0,
+            oam_dma: 0,
+            memory,
         }
     }
+
+    pub fn write_ppu_addr(&mut self, value: u8) {
+        self.addr.set(value)
+    }
+
+    pub fn read_ppu_data(&mut self) -> u8 {
+        let addr = self.addr.get_addr();
+        let result = if (0x3F00..=0x3FFF).contains(&addr) {
+            self.memory.read(addr)
+        } else {
+            let value = self.data_buffer;
+            self.data_buffer = self.memory.read(addr);
+            value
+        };
+
+        self.addr.increment_addr(self.addr_increment_amount());
+        result
+    }
+
+    pub fn write_ppu_data(&mut self, value: u8) {
+        self.memory.write(self.addr.get_addr(), value);
+
+        self.addr.increment_addr(self.addr_increment_amount());
+    }
+
+    pub fn get_ctrl_bit(&self, bit: u8) -> bool {
+        self.ctrl >> bit & 1 == 1
+    }
+
+    pub fn set_ctrl_bit(&mut self, bit: u8, value: bool) {
+        if value {
+            self.ctrl |= 1 << bit;
+        } else {
+            self.ctrl &= !(1 << bit);
+        }
+    }
+
+    fn addr_increment_amount(&self) -> u8 {
+        if !self.get_ctrl_bit(PPU_VRAM_ADD_INCREMENT_BIT) {
+            1 // across
+        } else {
+            32 // down
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::memory::DummyMemory;
+    use crate::ppu::{Ppu, PPU_VRAM_ADD_INCREMENT_BIT};
+    use std::cell::RefCell;
+    use std::rc::Rc;
+
+    #[test]
+    pub fn test_ppu_addr() {
+        let memory = Rc::new(RefCell::new(DummyMemory::new()));
+        let mut ppu = Ppu::new_with_memory(memory.clone());
+
+        ppu.set_ctrl_bit(PPU_VRAM_ADD_INCREMENT_BIT, false);
+
+        ppu.write_ppu_addr(0x34);
+        ppu.write_ppu_addr(0x56);
+        assert_eq!(ppu.addr.get_addr(), 0x3456);
+
+        ppu.read_ppu_data();
+        assert_eq!(memory.borrow().last_read_addr(), 0x3456);
+        assert_eq!(ppu.addr.get_addr(), 0x3457);
+
+        assert_eq!(ppu.read_ppu_data(), 0x56); // read on dummy memory returns low byte of address
+        assert_eq!(memory.borrow().last_read_addr(), 0x3457);
+        assert_eq!(ppu.addr.get_addr(), 0x3458);
+
+        ppu.write_ppu_data(0xCA);
+        assert_eq!(memory.borrow().last_read_addr(), 0x3457);
+        assert_eq!(memory.borrow().last_write_addr(), 0x3458);
+        assert_eq!(memory.borrow().last_write_value(), 0xCA);
+        assert_eq!(ppu.addr.get_addr(), 0x3459);
+
+        ppu.set_ctrl_bit(PPU_VRAM_ADD_INCREMENT_BIT, true);
+        ppu.read_ppu_data();
+        assert_eq!(ppu.addr.get_addr(), 0x3479); // now it increments by 0x20 because of the changed ctrl bit
+        ppu.set_ctrl_bit(PPU_VRAM_ADD_INCREMENT_BIT, false);
+
+        ppu.addr.set(0x3f);
+        ppu.addr.set(0xBD);
+        assert_eq!(ppu.addr.get_addr(), 0x3fBD);
+        assert_eq!(ppu.read_ppu_data(), 0xBD); // read in palette range returns value immediately
+
+        ppu.addr.set(0x3f);
+        ppu.addr.set(0xff);
+        ppu.read_ppu_data();
+        assert_eq!(ppu.addr.get_addr(), 0x0000); // wraparound after 0x3fff
+    }
 }

src/ppu/ppu_memory.rs

@@ -1,3 +1,4 @@
+use crate::memory::Memory;
 use crate::nes_rom::NametableMirroring;
 
 pub struct PpuMemory {
@@ -9,7 +10,9 @@ impl PpuMemory {
     pub fn new(chr_rom: Vec<u8>, mirroring: NametableMirroring) -> Self {
         Self { chr_rom, mirroring }
     }
+}
 
+impl Memory for PpuMemory {
     fn read(&self, addr: u16) -> u8 {
         if addr < 0x2000 {
             self.chr_rom[addr as usize]