implement oam and sprite rendering

Duckulus · Duckulus · commit 0dfaeb90a961 · 2025-11-03T09:04:41.000+01:00
diff --git a/src/cpu.rs b/src/cpu.rs
@@ -827,7 +827,7 @@ impl Cpu {
         let hi = self.next();
         let data = u16::from(lo) | (u16::from(hi) << 8);
         if data == instr_addr {
-            // panic!("Trapped at {:#x}", instr_addr);
+            panic!("Trapped at {:#x}", instr_addr);
         }
         self.registers.pc = data;
     }
@@ -1322,7 +1322,6 @@ impl Cpu {
     }
 
     fn interrupt_nmi(&mut self) {
-        println!("NMI");
         self.push_stack((self.registers.pc >> 8) as u8);
         self.push_stack((self.registers.pc & 0xFF) as u8);
 
diff --git a/src/cpu/bus.rs b/src/cpu/bus.rs
@@ -3,7 +3,7 @@ use crate::cpu::{INTERRUPT_VECTOR_RES_HI, INTERRUPT_VECTOR_RES_LO};
 use crate::memory::{Memory, Ram};
 use crate::nes_rom::NesRom;
 use crate::ppu::ppu_memory::PpuMemory;
-use crate::ppu::Ppu;
+use crate::ppu::{Ppu, OAM_SIZE};
 
 pub struct Bus {
     sram: Ram,
@@ -47,26 +47,25 @@ impl Bus {
             let register = (a - 0x2000) % 8;
             match register {
                 2 => self.ppu.read_ppu_status(),
-                4 => unimplemented!(),
+                4 => self.ppu.read_oam_data(),
                 7 => self.ppu.read_ppu_data(),
                 _ => panic!(
                     "Unexpected PPU register read: {:#X} (Register {})",
                     a, register
                 ),
             }
-        } else if a == 0x4016  {
+        } else if a == 0x4016 {
             self.controller.read()
         } else if a == 0x4017 {
             // TODO player 2 controller
             0
-        }else if (0x6000..0x8000).contains(&a) {
+        } else if (0x6000..0x8000).contains(&a) {
             self.prg_ram.read(a - 0x6000)
         } else if a >= 0x8000 {
             self.rom.prg_rom[(a as usize - 0x8000) % self.rom.prg_rom.len()]
         } else {
             println!("Tried to read unmapped address: {:#X}", a);
             0
-            // panic!("Tried to read unmapped address: {:#X}", a)
         }
     }
 
@@ -78,10 +77,8 @@ impl Bus {
             match register {
                 0 => self.ppu.write_ppu_ctrl(v),
                 1 => self.ppu.write_ppu_mask(v),
-                3 => {
-                    // unimplemented!()
-                }
-                4 => unimplemented!(),
+                3 => self.ppu.write_oam_addr(v),
+                4 => self.ppu.write_oam_data(v),
                 5 => self.ppu.write_ppu_scroll(v),
                 6 => self.ppu.write_ppu_addr(v),
                 7 => self.ppu.write_ppu_data(v),
@@ -91,10 +88,14 @@ impl Bus {
                 ),
             };
         } else if a == 0x4014 {
-            // unimplemented!()
+            for i in 0..OAM_SIZE {
+                let addr = ((v as u16) << 8) | (i as u16);
+                let value = self.read(addr);
+                self.ppu.write_oam_data(value);
+            }
         } else if a == 0x4016 {
             self.controller.write(v);
-        }else if (0x4000..=0x4017).contains(&a) {
+        } else if (0x4000..=0x4017).contains(&a) {
             // TODO APU
         } else if (0x6000..0x8000).contains(&a) {
             self.prg_ram.write(a - 0x6000, v);
@@ -104,8 +105,12 @@ impl Bus {
     }
 
     pub fn reset_vector(&self) -> u16 {
-        let hi = self.rom.prg_rom[(INTERRUPT_VECTOR_RES_HI - 0x8000) as usize % self.rom.prg_rom.len()] as u16;
-        let lo = self.rom.prg_rom[(INTERRUPT_VECTOR_RES_LO - 0x8000) as usize % self.rom.prg_rom.len()] as u16;
+        let hi = self.rom.prg_rom
+            [(INTERRUPT_VECTOR_RES_HI - 0x8000) as usize % self.rom.prg_rom.len()]
+            as u16;
+        let lo = self.rom.prg_rom
+            [(INTERRUPT_VECTOR_RES_LO - 0x8000) as usize % self.rom.prg_rom.len()]
+            as u16;
         (hi << 8) | lo
     }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -20,7 +20,7 @@ mod render;
 async fn main() -> Result<(), anyhow::Error> {
     println!("Starting Emulator!");
 
-    // let rom = NesRom::read_from_file("./vendor/nestest/nestest.nes")?;
+    // let rom = NesRom::read_from_file("vendor/nes-test-roms/blargg_litewall/litewall5.nes")?;
     let rom = NesRom::read_from_file("./Thwaite.nes")?;
     println!("{rom:#?}");
 
@@ -41,7 +41,6 @@ async fn main() -> Result<(), anyhow::Error> {
         } else {
             if cpu.poll_new_frame() {
                 render_frame(&mut cpu).await;
-                println!("frame");
             }
             cpu.tick();
             handle_keyboard_input(&mut cpu);
@@ -50,8 +49,8 @@ async fn main() -> Result<(), anyhow::Error> {
 }
 
 fn handle_keyboard_input(cpu: &mut Cpu) {
-    cpu.bus.controller.button_states[CONTROLLER_BUTTON_A] = is_key_down(KeyCode::A);
-    cpu.bus.controller.button_states[CONTROLLER_BUTTON_B] = is_key_down(KeyCode::S);
+    cpu.bus.controller.button_states[CONTROLLER_BUTTON_A] = is_key_down(KeyCode::S);
+    cpu.bus.controller.button_states[CONTROLLER_BUTTON_B] = is_key_down(KeyCode::A);
     cpu.bus.controller.button_states[CONTROLLER_BUTTON_SELECT] = is_key_down(KeyCode::LeftShift);
     cpu.bus.controller.button_states[CONTROLLER_BUTTON_START] = is_key_down(KeyCode::Enter);
     cpu.bus.controller.button_states[CONTROLLER_BUTTON_UP] = is_key_down(KeyCode::Up);
diff --git a/src/ppu.rs b/src/ppu.rs
@@ -1,4 +1,4 @@
-use crate::memory::Memory;
+use crate::memory::{Memory, Ram};
 use crate::nes_rom::NametableMirroring;
 use crate::ppu::ppu_memory::PpuMemory;
 
@@ -110,12 +110,13 @@ const SCANLINES: u32 = 262;
 const VISIBLE_SCANLIENS: u32 = 240;
 const SCANLINE_CYCLES: u32 = 341;
 
+pub const OAM_SIZE: usize = 0x100;
+
 pub struct Ppu<M: Memory> {
     ctrl: u8,
     mask: u8,
     status: u8,
     oam_addr: u8,
-    oam_data: u8,
     scroll: PpuScroll,
     addr: PpuAddr,
     data_buffer: u8,
@@ -127,6 +128,7 @@ pub struct Ppu<M: Memory> {
     new_frame: bool,
 
     pub memory: M,
+    pub oam: [u8; OAM_SIZE],
 }
 
 impl Ppu<PpuMemory> {
@@ -136,7 +138,6 @@ impl Ppu<PpuMemory> {
             mask: 0,
             status: 0,
             oam_addr: 0,
-            oam_data: 0,
             scroll: PpuScroll::new(),
             addr: PpuAddr::new(),
             data_buffer: 0,
@@ -146,6 +147,7 @@ impl Ppu<PpuMemory> {
             nmi: false,
             new_frame: false,
             memory: PpuMemory::new(chr_rom, mirroring),
+            oam: [0; OAM_SIZE],
         }
     }
 }
@@ -202,8 +204,6 @@ impl<M: Memory> Ppu<M> {
         self.ctrl >> bit & 1 == 1
     }
 
-
-
     pub fn write_ppu_mask(&mut self, value: u8) {
         self.mask = value;
     }
@@ -240,6 +240,19 @@ impl<M: Memory> Ppu<M> {
         }
     }
 
+    pub fn write_oam_addr(&mut self, value: u8) {
+        self.oam_addr = value;
+    }
+
+    pub fn read_oam_data(&mut self) -> u8 {
+        self.oam[self.oam_addr as usize]
+    }
+
+    pub fn write_oam_data(&mut self, value: u8) {
+        self.oam[self.oam_addr as usize] = value;
+        self.oam_addr = self.oam_addr.wrapping_add(1);
+    }
+
     pub fn write_ppu_scroll(&mut self, value: u8) {
         self.scroll.set(value);
     }
@@ -276,6 +289,14 @@ impl<M: Memory> Ppu<M> {
         }
     }
 
+    pub fn sprite_pattern_addr(&self) -> u16 {
+        if self.get_ctrl_bit(PPU_CTRL_SPRITE_PATTERN_ADDR_BIT) {
+            0x1000
+        } else {
+            0x0
+        }
+    }
+
     pub fn background_pattern_addr(&self) -> u16 {
         if self.get_ctrl_bit(PPU_CTRL_BACKRGROUND_ADDR_BIT) {
             0x1000
@@ -291,11 +312,11 @@ impl<M: Memory> Ppu<M> {
 
 #[cfg(test)]
 mod test {
-    use crate::memory::{Memory};
-    use crate::ppu::{Ppu, PpuAddr, PpuScroll, PPU_CTRL_VRAM_ADD_INCREMENT_BIT};
+    use crate::memory::test::DummyMemory;
+    use crate::memory::{Memory, Ram};
+    use crate::ppu::{Ppu, PpuAddr, PpuScroll, OAM_SIZE, PPU_CTRL_VRAM_ADD_INCREMENT_BIT};
     use std::cell::RefCell;
     use std::rc::Rc;
-    use crate::memory::test::DummyMemory;
 
     impl<M: Memory> Ppu<M> {
         fn new_with_memory(memory: M) -> Self {
@@ -304,7 +325,6 @@ mod test {
                 mask: 0,
                 status: 0,
                 oam_addr: 0,
-                oam_data: 0,
                 scroll: PpuScroll::new(),
                 addr: PpuAddr::new(),
                 data_buffer: 0,
@@ -314,6 +334,7 @@ mod test {
                 nmi: false,
                 new_frame: false,
                 memory,
+                oam: [0; OAM_SIZE],
             }
         }
 
diff --git a/src/ppu/ppu_memory.rs b/src/ppu/ppu_memory.rs
@@ -57,7 +57,7 @@ impl Memory for PpuMemory {
 
     fn write(&mut self, addr: u16, data: u8) {
         if addr < 0x2000 {
-            // panic!("Attempted write to CHR ROM at {:#X}", addr);
+            println!("Attempted write to CHR ROM at {:#X}", addr);
         } else if (0x2000..0x3000).contains(&addr) {
             let vram_addr = addr - 0x2000;
             self.vram.write(self.mirror_vram_addr(vram_addr), data);
diff --git a/src/render.rs b/src/render.rs
@@ -1,11 +1,17 @@
+mod sprite;
+
 use crate::cpu::Cpu;
 use crate::memory::Memory;
 use crate::nes_rom::NesRom;
 use crate::ppu::ppu_memory::PpuMemory;
-use crate::ppu::Ppu;
+use crate::ppu::{Ppu, OAM_SIZE};
+use crate::render::sprite::Sprite;
 use macroquad::color::{Color, BLACK, BLUE, RED, WHITE};
 use macroquad::prelude::{draw_rectangle, next_frame, request_new_screen_size};
 
+const SCREEN_WIDTH: u16 = 256;
+const SCREEN_HEIGHT: u16 = 240;
+
 const RENDER_SCALE: f32 = 4.;
 const TILE_SIZE: f32 = RENDER_SCALE * 8.;
 
@@ -21,10 +27,10 @@ const SYSTEM_PALLETE: [u32; 64] = [
 ];
 
 pub fn get_color(idx: u8) -> Color {
-    Color::from_hex(SYSTEM_PALLETE[idx as usize])
+    Color::from_hex(SYSTEM_PALLETE[idx as usize % 64])
 }
 
-pub fn get_palette(ppu: &Ppu<PpuMemory>, palette_idx: u16) -> [Color; 4] {
+pub fn get_bg_palette(ppu: &Ppu<PpuMemory>, palette_idx: u16) -> [Color; 4] {
     [
         get_color(ppu.memory.palette_table.read(0)),
         get_color(ppu.memory.palette_table.read(palette_idx * 4 + 1)),
@@ -33,15 +39,27 @@ pub fn get_palette(ppu: &Ppu<PpuMemory>, palette_idx: u16) -> [Color; 4] {
     ]
 }
 
+pub fn get_sprite_palette(ppu: &Ppu<PpuMemory>, palette_idx: u16) -> [Color; 4] {
+    get_bg_palette(ppu, palette_idx + 4)
+}
+
 pub async fn render_frame(cpu: &mut Cpu) {
     let ppu = &mut cpu.bus.ppu;
-    let bank = ppu.background_pattern_addr();
 
     request_new_screen_size(
         RENDER_SCALE * (8 * 32) as f32,
         RENDER_SCALE * (8 * 30) as f32,
     );
 
+    render_background(ppu).await;
+    render_sprites(ppu).await;
+
+    next_frame().await
+}
+
+async fn render_background(ppu: &mut Ppu<PpuMemory>) {
+    let bank = ppu.background_pattern_addr();
+
     fn calc_screen_pos(tile_index: usize, pixel_index: usize) -> (f32, f32) {
         let tile_x = (tile_index % 32) as f32;
         let tile_y = (tile_index / 32) as f32;
@@ -59,7 +77,7 @@ pub async fn render_frame(cpu: &mut Cpu) {
         // which tile are we rendering?
         let tile = ppu.memory.read(nametable_addr + tile_index) as u16;
         let chr_data = ppu.memory.chr_rom
-            [(bank + tile * 16) as usize..=(bank + tile * 16 + 15) as usize]
+            [(bank + tile * 16) as usize..(bank + tile * 16 + 16) as usize]
             .to_vec();
         let pixels = chr_data_to_pixels(chr_data);
 
@@ -75,7 +93,7 @@ pub async fn render_frame(cpu: &mut Cpu) {
             (1, 1) => (meta_palette >> 6) & 0b11,
             _ => panic!("unexpected tile position"),
         };
-        let colors = get_palette(ppu, palette_idx);
+        let colors = get_bg_palette(ppu, palette_idx);
 
         for i in 0..pixels.len() {
             let (screen_x, screen_y) = calc_screen_pos(tile_index as usize, i);
@@ -88,7 +106,48 @@ pub async fn render_frame(cpu: &mut Cpu) {
             )
         }
     }
-    next_frame().await
+}
+
+async fn render_sprites(ppu: &Ppu<PpuMemory>) {
+    for oam_idx in (0..OAM_SIZE).step_by(4).rev() {
+        let sprite = Sprite::from_data(&ppu.oam[oam_idx..oam_idx + 4]);
+        if !sprite.visible {
+            continue;
+        }
+        let bank = ppu.sprite_pattern_addr();
+        let tile = sprite.tile_index as u16;
+        let chr_data = ppu.memory.chr_rom
+            [(bank + tile * 16) as usize..(bank + tile * 16 + 16) as usize]
+            .to_vec();
+        let pixels = chr_data_to_pixels(chr_data);
+
+        let colors = get_sprite_palette(ppu, sprite.palette as u16);
+
+        for x in 0..8 {
+            for y in 0..8 {
+                let pixel_idx = (y * 8 + x) as usize;
+                if pixels[pixel_idx] == 0 {
+                    continue;
+                }
+
+                let x = if sprite.flip_horizontally { 7 - x } else { x };
+                let y = if sprite.flip_vertically { 7 - y } else { y };
+
+                if sprite.x as u16 + x > SCREEN_WIDTH || sprite.y as u16 + y > SCREEN_HEIGHT {
+                    continue;
+                }
+                let (screen_x, screen_y) = (sprite.x as u16 + x, sprite.y as u16 + y);
+
+                draw_rectangle(
+                    screen_x as f32 * RENDER_SCALE,
+                    screen_y as f32 * RENDER_SCALE,
+                    RENDER_SCALE,
+                    RENDER_SCALE,
+                    colors[pixels[pixel_idx] as usize],
+                )
+            }
+        }
+    }
 }
 
 pub async fn debug_chr_rom(rom: &NesRom) {
diff --git a/src/render/sprite.rs b/src/render/sprite.rs

Original file line number	Diff line number	Diff line change
`@@ -827,7 +827,7 @@ impl Cpu {`
`827`	`827`	`let hi = self.next();`
`828`	`828`	`let data = u16::from(lo) \| (u16::from(hi) << 8);`
`829`	`829`	`if data == instr_addr {`
`830`		`- // panic!("Trapped at {:#x}", instr_addr);`
	`830`	`+ panic!("Trapped at {:#x}", instr_addr);`
`831`	`831`	`}`
`832`	`832`	`self.registers.pc = data;`
`833`	`833`	`}`
`@@ -1322,7 +1322,6 @@ impl Cpu {`
`1322`	`1322`	`}`
`1323`	`1323`
`1324`	`1324`	`fn interrupt_nmi(&mut self) {`
`1325`		`- println!("NMI");`
`1326`	`1325`	`self.push_stack((self.registers.pc >> 8) as u8);`
`1327`	`1326`	`self.push_stack((self.registers.pc & 0xFF) as u8);`
`1328`	`1327`