chore: prevent bitrot

closes #1

.vscode/extensions.json

@@ -1,8 +1,9 @@
 {
     "recommendations": [
-        "matklad.rust-analyzer",
+        "rust-lang.rust-analyzer",
         "tamasfe.even-better-toml",
         "serayuzgur.crates",
         "vadimcn.vscode-lldb",
+        "donaldhays.rgbds-z80"
     ]
 }

Cargo.toml

@@ -8,21 +8,21 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0"
-bitfield = "0.13"
-clap = "2.33"
-gilrs = "0.8"
-winit = "0.25"
-egui = "0.15"
-wgpu = "0.11"
-egui_wgpu_backend = "0.14"
-egui_winit_platform = "0.11"
-pollster = "0.2"
-rodio = "0.14"
-rtrb = "0.2"
+bitfield = "0.17"
+clap = { version = "4.0", features = ["cargo"] }
+gilrs = "0.11"
+winit = "0.28"
+egui = "0.21"
+egui_wgpu_backend = "0.22"
+egui_winit_platform = "0.18"
+pollster = "0.3"
+rodio = "0.19"
+rtrb = "0.3"
 directories-next = "2.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["std", "env-filter"] }
-thiserror = "1.0.30"
+thiserror = "1.0"
+once_cell = "1.10"
 
 [profile.release]
 debug = true

README.md

@@ -1,10 +1,9 @@
 # Rekai's Gameboy Emulator
-[![Build Status](https://ci.paoda.moe/api/badges/paoda/gb/status.svg)](https://ci.paoda.moe/paoda/gb)
 
 ### Status
 * From [Blargg Test ROMs](https://github.com/L-P/blargg-test-roms/)
     * [x] cpu_instrs
-    * [ ] instr_timing (kind of)
+    * [x] instr_timing
     * [x] mem_timing
     * [x] mem_timing-2
     * [ ] dmg_sound (partial) 
@@ -21,9 +20,15 @@
 Supports: ROM-only, MBC1, MBC2, MBC3 and MBC5 games.
 
 
+### Compiling
+This project was last successfully built on [Rust 1.64.0](https://github.com/rust-lang/rust/tree/1.64.0)
+
+1. `git clone https://github.com/paoda/gb`
+2. `cd gb`
+3. `cargo run --release`
 
 ### Controls
-Controls are defined [here](https://git.musuka.dev/paoda/gb/src/branch/main/src/joypad.rs#L114)
+Controls are defined [here](https://github.com/paoda/gb/blob/85940c874460b9cb31bf9b8211bf7dda596d114a/src/joypad.rs#L114)
 
 Key | Button
 --- | ---

src/apu.rs

@@ -587,7 +587,7 @@ impl Channel1 {
 pub(crate) struct Channel2 {
     /// 0xFF16 | NR21 - Channel 2 Sound length / Wave Pattern Duty
     duty: SoundDuty,
-    /// 0xFF17 | NR22 - Channel 2 Volume ENvelope
+    /// 0xFF17 | NR22 - Channel 2 Volume Envelope
     envelope: VolumeEnvelope,
     /// 0xFF18 | NR23 - Channel 2 Frequency low (lower 8 bits only)
     freq_lo: u8,
@@ -619,12 +619,12 @@ impl Channel2 {
         self.length_counter = 64 - self.duty.sound_length() as u16;
     }
 
-    /// 0xFF17 | NR22 - Channel 2 Volume ENvelope
+    /// 0xFF17 | NR22 - Channel 2 Volume Envelope
     pub(crate) fn envelope(&self) -> u8 {
         u8::from(self.envelope)
     }
 
-    /// 0xFF17 | NR22 - Channel 2 Volume ENvelope
+    /// 0xFF17 | NR22 - Channel 2 Volume Envelope
     pub(crate) fn set_envelope(&mut self, byte: u8) {
         self.envelope = byte.into();
 

src/apu/types.rs

@@ -169,7 +169,7 @@ pub(super) mod ch4 {
             match byte & 0x01 {
                 0b00 => Self::Short,
                 0b01 => Self::Long,
-                _ => unreachable!("{:#04X} is not a valid value for CounterWidth"),
+                _ => unreachable!("{:#04X} is not a valid value for CounterWidth", byte),
             }
         }
     }

src/bus.rs

@@ -10,7 +10,7 @@ use crate::work_ram::{VariableWorkRam, WorkRam};
 
 pub(crate) const BOOT_SIZE: usize = 0x100;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Bus {
     boot: Option<[u8; BOOT_SIZE]>, // Boot ROM is 256b long
     pub(crate) cart: Option<Cartridge>,
@@ -25,24 +25,6 @@ pub struct Bus {
     pub(crate) joyp: Joypad,
 }
 
-impl Default for Bus {
-    fn default() -> Self {
-        Self {
-            boot: None,
-            cart: None,
-            ppu: Default::default(),
-            work_ram: Default::default(),
-            var_ram: Default::default(),
-            timer: Default::default(),
-            int: Default::default(),
-            apu: Default::default(),
-            high_ram: Default::default(),
-            serial: Default::default(),
-            joyp: Default::default(),
-        }
-    }
-}
-
 impl Bus {
     pub(crate) fn with_boot(rom: [u8; 256]) -> Self {
         Self {

src/cartridge.rs

@@ -15,7 +15,7 @@ const ROM_MANUFACTURER_START: usize = 0x13F;
 pub(crate) struct Cartridge {
     mem: Vec<u8>,
     pub(crate) title: Option<String>,
-    mbc: Box<dyn MBCIo>,
+    mbc: Box<dyn MbcIo>,
 }
 
 impl Cartridge {
@@ -44,7 +44,7 @@ impl Cartridge {
         self.mbc.tick()
     }
 
-    fn detect_mbc(mem: &[u8]) -> Box<dyn MBCIo> {
+    fn detect_mbc(mem: &[u8]) -> Box<dyn MbcIo> {
         let ram_size: RamSize = mem[RAM_SIZE_ADDRESS].into();
         let rom_size: RomSize = mem[ROM_SIZE_ADDRESS].into();
         let mbc_kind = Self::detect_mbc_kind(mem[MBC_KIND_ADDRESS]);
@@ -56,61 +56,64 @@ impl Cartridge {
         tracing::info!("MBC kind: {:?}", mbc_kind);
 
         match mbc_kind {
-            MBCKind::None => Box::new(NoMBC),
-            MBCKind::MBC1(hw) => Box::new(MBC1::new(hw, ram_size, rom_size)),
-            MBCKind::MBC2(hw) => Box::new(MBC2::new(hw, rom_cap)),
-            MBCKind::MBC3(hw @ MBC3Hardware::RTC) => Box::new(MBC3::new(hw, ram_cap)),
-            MBCKind::MBC3(hw @ MBC3Hardware::RTCAndBatteryRAM) => Box::new(MBC3::new(hw, ram_cap)),
-            MBCKind::MBC5(hw @ MBC5Hardware::None) => Box::new(MBC5::new(hw, ram_cap, rom_cap)),
-            MBCKind::MBC5(hw @ MBC5Hardware::BatteryRAM) => {
-                Box::new(MBC5::new(hw, ram_cap, rom_cap))
+            MbcKind::None => Box::new(NoMbc),
+            MbcKind::Mbc1(hw) => Box::new(Mbc1::new(hw, ram_size, rom_size)),
+            MbcKind::Mbc2(hw) => Box::new(Mbc2::new(hw, rom_cap)),
+            MbcKind::Mbc3(hw @ Mbc3Hardware::Rtc) => Box::new(Mbc3::new(hw, ram_cap)),
+            MbcKind::Mbc3(hw @ Mbc3Hardware::RtcBatteryRam) => Box::new(Mbc3::new(hw, ram_cap)),
+            MbcKind::Mbc3(hw @ Mbc3Hardware::BatteryRam) => Box::new(Mbc3::new(hw, ram_cap)),
+            MbcKind::Mbc5(hw @ Mbc5Hardware::None) => Box::new(Mbc5::new(hw, ram_cap, rom_cap)),
+            MbcKind::Mbc5(hw @ Mbc5Hardware::BatteryRam) => {
+                Box::new(Mbc5::new(hw, ram_cap, rom_cap))
             }
             kind => todo!("ROMS with {:?} are currently unsupported", kind),
         }
     }
 
     fn detect_title(title_mem: &[u8; ROM_TITLE_MAX_SIZE]) -> Option<String> {
+        use std::str::from_utf8;
+
         const ALT_TITLE_LEN: usize = ROM_MANUFACTURER_START - ROM_TITLE_START;
 
-        // byte slice we have here is purposely not null terminated
+        // ascii byte slie does not have a null-terminator
         let ascii = match title_mem.iter().position(|b| *b == 0x00) {
-            Some(end) => &title_mem[0..end],
-            None => &title_mem[0..ROM_TITLE_MAX_SIZE],
+            Some(end) => &title_mem[..end],
+            None => &title_mem[..ROM_TITLE_MAX_SIZE],
         };
 
-        match std::str::from_utf8(ascii).ok() {
-            None => match std::str::from_utf8(&title_mem[0..ALT_TITLE_LEN]).ok() {
+        match from_utf8(ascii).map(str::trim).ok() {
+            None => match from_utf8(&title_mem[..ALT_TITLE_LEN]).map(str::trim).ok() {
                 Some("") | None => None,
-                Some(title) => Some(String::from(title.trim())),
+                Some(title) => Some(String::from(title)),
             },
             Some("") => None,
-            Some(title) => Some(String::from(title.trim())),
+            Some(title) => Some(String::from(title)),
         }
     }
 
-    fn detect_mbc_kind(id: u8) -> MBCKind {
-        use MBCKind::*;
+    fn detect_mbc_kind(id: u8) -> MbcKind {
+        use MbcKind::*;
 
         match id {
             0x00 => None,
-            0x01 => MBC1(MBC1Hardware::None),
-            0x02 => MBC1(MBC1Hardware::RAM),
-            0x03 => MBC1(MBC1Hardware::BatteryRAM),
-            0x05 => MBC2(MBC2Hardware::None),
-            0x06 => MBC2(MBC2Hardware::BatteryRAM),
+            0x01 => Mbc1(Mbc1Hardware::None),
+            0x02 => Mbc1(Mbc1Hardware::Ram),
+            0x03 => Mbc1(Mbc1Hardware::BatteryRam),
+            0x05 => Mbc2(Mbc2Hardware::None),
+            0x06 => Mbc2(Mbc2Hardware::BatteryRam),
             0x08 | 0x09 => unimplemented!("NoMBC + RAM and NoMBC + Battery unsupported"),
             0x0B | 0x0C | 0x0D => unimplemented!("MM01 unsupported"),
-            0x0F => MBC3(MBC3Hardware::RTC),
-            0x10 => MBC3(MBC3Hardware::RTCAndBatteryRAM),
-            0x11 => MBC3(MBC3Hardware::None),
-            0x12 => MBC3(MBC3Hardware::RAM),
-            0x13 => MBC3(MBC3Hardware::BatteryRAM),
-            0x19 => MBC5(MBC5Hardware::None),
-            0x1A => MBC5(MBC5Hardware::RAM),
-            0x1B => MBC5(MBC5Hardware::BatteryRAM),
-            0x1C => MBC5(MBC5Hardware::Rumble),
-            0x1D => MBC5(MBC5Hardware::RumbleRAM),
-            0x1E => MBC5(MBC5Hardware::RumbleBatteryRAM),
+            0x0F => Mbc3(Mbc3Hardware::Rtc),
+            0x10 => Mbc3(Mbc3Hardware::RtcBatteryRam),
+            0x11 => Mbc3(Mbc3Hardware::None),
+            0x12 => Mbc3(Mbc3Hardware::Ram),
+            0x13 => Mbc3(Mbc3Hardware::BatteryRam),
+            0x19 => Mbc5(Mbc5Hardware::None),
+            0x1A => Mbc5(Mbc5Hardware::Ram),
+            0x1B => Mbc5(Mbc5Hardware::BatteryRam),
+            0x1C => Mbc5(Mbc5Hardware::Rumble),
+            0x1D => Mbc5(Mbc5Hardware::RumbleRam),
+            0x1E => Mbc5(Mbc5Hardware::RumbleBatteryRam),
             id => unimplemented!("MBC with code {:#04X} is unsupported", id),
         }
     }
@@ -118,7 +121,7 @@ impl Cartridge {
 
 impl BusIo for Cartridge {
     fn read_byte(&self, addr: u16) -> u8 {
-        use MBCResult::*;
+        use MbcResult::*;
 
         match self.mbc.handle_read(addr) {
             Addr(addr) => self.mem[addr],
@@ -132,7 +135,7 @@ impl BusIo for Cartridge {
 }
 
 #[derive(Debug)]
-struct MBC1 {
+struct Mbc1 {
     /// 5-bit number
     rom_bank: u8,
     /// 2-bit number
@@ -143,11 +146,11 @@ struct MBC1 {
     rom_size: RomSize,
     mem_enabled: bool,
 
-    hw: MBC1Hardware,
+    hw: Mbc1Hardware,
 }
 
-impl MBC1 {
-    fn new(hw: MBC1Hardware, ram_size: RamSize, rom_size: RomSize) -> Self {
+impl Mbc1 {
+    fn new(hw: Mbc1Hardware, ram_size: RamSize, rom_size: RomSize) -> Self {
         Self {
             rom_bank: 0x01,
             mem: vec![0; ram_size.capacity() as usize],
@@ -225,25 +228,25 @@ impl MBC1 {
     }
 }
 
-impl Savable for MBC1 {
+impl Savable for Mbc1 {
     fn ext_ram(&self) -> Option<&[u8]> {
         match self.hw {
-            MBC1Hardware::BatteryRAM => Some(&self.mem),
+            Mbc1Hardware::BatteryRam => Some(&self.mem),
             _ => None,
         }
     }
 
     fn ext_ram_mut(&mut self) -> Option<&mut [u8]> {
         match self.hw {
-            MBC1Hardware::BatteryRAM => Some(&mut self.mem),
+            Mbc1Hardware::BatteryRam => Some(&mut self.mem),
             _ => None,
         }
     }
 }
 
-impl MBCIo for MBC1 {
-    fn handle_read(&self, addr: u16) -> MBCResult {
-        use MBCResult::*;
+impl MbcIo for Mbc1 {
+    fn handle_read(&self, addr: u16) -> MbcResult {
+        use MbcResult::*;
 
         match addr {
             0x0000..=0x3FFF if self.mode => {
@@ -277,7 +280,7 @@ impl MBCIo for MBC1 {
     }
 }
 
-impl RtClockTick for MBC1 {
+impl RtcTick for Mbc1 {
     fn tick(&mut self) {}
 }
 
@@ -309,7 +312,7 @@ impl RtClock {
     }
 }
 
-impl RtClockTick for RtClock {
+impl RtcTick for RtClock {
     fn tick(&mut self) {
         // This is the sort of situation where you'd want to use a scheduler.
         if self.day_high.halt() {
@@ -341,7 +344,7 @@ impl RtClockTick for RtClock {
     }
 }
 
-trait RtClockTick {
+trait RtcTick {
     fn tick(&mut self);
 }
 
@@ -379,41 +382,41 @@ impl From<DayHigh> for u8 {
 }
 
 #[derive(Debug, Clone, Copy)]
-enum MBC3Device {
-    ExternalRam,
-    Clock(RtcRegister),
+enum Mbc3Device {
+    Ram,
+    Rtc(RtcRegister),
 }
 
 #[derive(Debug, Clone, Copy)]
 enum RtcRegister {
-    Second,
-    Minute,
-    Hour,
+    Sec,
+    Min,
+    Hr,
     DayLow,
     DayHigh,
 }
 
 #[derive(Debug)]
-struct MBC3 {
+struct Mbc3 {
     /// 7-bit Number
     rom_bank: u8,
     /// 2-bit Number
     ram_bank: u8,
 
     devs_enabled: bool,
-    mapped: Option<MBC3Device>,
+    mapped: Option<Mbc3Device>,
     mem: Vec<u8>,
 
     // RTC Data Latch Previous Write
     prev_latch_write: Option<u8>,
 
-    hw: MBC3Hardware,
+    hw: Mbc3Hardware,
     rtc: RtClock,
     rtc_latch: Option<RtClock>,
 }
 
-impl MBC3 {
-    fn new(hw: MBC3Hardware, ram_cap: usize) -> Self {
+impl Mbc3 {
+    fn new(hw: Mbc3Hardware, ram_cap: usize) -> Self {
         Self {
             mem: vec![0; ram_cap],
             rom_bank: Default::default(),
@@ -428,41 +431,41 @@ impl MBC3 {
     }
 }
 
-impl Savable for MBC3 {
+impl Savable for Mbc3 {
     fn ext_ram(&self) -> Option<&[u8]> {
         match self.hw {
-            MBC3Hardware::BatteryRAM | MBC3Hardware::RTCAndBatteryRAM => Some(&self.mem),
+            Mbc3Hardware::BatteryRam | Mbc3Hardware::RtcBatteryRam => Some(&self.mem),
             _ => None,
         }
     }
 
     fn ext_ram_mut(&mut self) -> Option<&mut [u8]> {
         match self.hw {
-            MBC3Hardware::BatteryRAM | MBC3Hardware::RTCAndBatteryRAM => Some(&mut self.mem),
+            Mbc3Hardware::BatteryRam | Mbc3Hardware::RtcBatteryRam => Some(&mut self.mem),
             _ => None,
         }
     }
 }
 
-impl MBCIo for MBC3 {
-    fn handle_read(&self, addr: u16) -> MBCResult {
-        use MBCResult::*;
+impl MbcIo for Mbc3 {
+    fn handle_read(&self, addr: u16) -> MbcResult {
+        use MbcResult::*;
         use RtcRegister::*;
 
         let res = match addr {
             0x0000..=0x3FFF => Addr(addr as usize),
             0x4000..=0x7FFF => Addr(0x4000 * self.rom_bank as usize + (addr as usize - 0x4000)),
             0xA000..=0xBFFF => match self.mapped {
-                Some(MBC3Device::ExternalRam) if self.devs_enabled => {
+                Some(Mbc3Device::Ram) if self.devs_enabled => {
                     Byte(self.mem[0x2000 * self.ram_bank as usize + (addr as usize - 0xA000)])
                 }
-                Some(MBC3Device::Clock(reg)) if self.devs_enabled => Byte(
+                Some(Mbc3Device::Rtc(reg)) if self.devs_enabled => Byte(
                     self.rtc_latch
                         .as_ref()
                         .map(|rtc| match reg {
-                            Second => rtc.sec,
-                            Minute => rtc.min,
-                            Hour => rtc.hr,
+                            Sec => rtc.sec,
+                            Min => rtc.min,
+                            Hr => rtc.hr,
                             DayLow => rtc.day_low,
                             DayHigh => rtc.day_high.into(),
                         })
@@ -490,13 +493,13 @@ impl MBCIo for MBC3 {
             0x4000..=0x5FFF => match byte {
                 0x00 | 0x01 | 0x02 | 0x03 => {
                     self.ram_bank = byte & 0x03;
-                    self.mapped = Some(MBC3Device::ExternalRam);
+                    self.mapped = Some(Mbc3Device::Ram);
                 }
-                0x08 => self.mapped = Some(MBC3Device::Clock(Second)),
-                0x09 => self.mapped = Some(MBC3Device::Clock(Minute)),
-                0x0A => self.mapped = Some(MBC3Device::Clock(Hour)),
-                0x0B => self.mapped = Some(MBC3Device::Clock(DayLow)),
-                0x0C => self.mapped = Some(MBC3Device::Clock(DayHigh)),
+                0x08 => self.mapped = Some(Mbc3Device::Rtc(Sec)),
+                0x09 => self.mapped = Some(Mbc3Device::Rtc(Min)),
+                0x0A => self.mapped = Some(Mbc3Device::Rtc(Hr)),
+                0x0B => self.mapped = Some(Mbc3Device::Rtc(DayLow)),
+                0x0C => self.mapped = Some(Mbc3Device::Rtc(DayHigh)),
 
                 _ => {}
             },
@@ -509,17 +512,17 @@ impl MBCIo for MBC3 {
                 self.prev_latch_write = Some(byte);
             }
             0xA000..=0xBFFF => match self.mapped {
-                Some(MBC3Device::ExternalRam) if self.devs_enabled => {
+                Some(Mbc3Device::Ram) if self.devs_enabled => {
                     self.mem[0x2000 * self.ram_bank as usize + (addr as usize - 0xA000)] = byte
                 }
-                Some(MBC3Device::Clock(rtc_reg)) if self.devs_enabled => match rtc_reg {
-                    Second => {
+                Some(Mbc3Device::Rtc(rtc_reg)) if self.devs_enabled => match rtc_reg {
+                    Sec => {
                         self.rtc.sec = byte & 0x3F;
                         // Writing to RTC S resets the internal sub-second counter
                         self.rtc.cycles = 0;
                     }
-                    Minute => self.rtc.min = byte & 0x3F,
-                    Hour => self.rtc.hr = byte & 0x1F,
+                    Min => self.rtc.min = byte & 0x3F,
+                    Hr => self.rtc.hr = byte & 0x1F,
                     DayLow => self.rtc.day_low = byte,
                     DayHigh => self.rtc.day_high = (byte & 0xC1).into(),
                 },
@@ -530,16 +533,16 @@ impl MBCIo for MBC3 {
     }
 }
 
-impl RtClockTick for MBC3 {
+impl RtcTick for Mbc3 {
     fn tick(&mut self) {
-        if let MBC3Hardware::RTCAndBatteryRAM | MBC3Hardware::RTC = self.hw {
+        if let Mbc3Hardware::RtcBatteryRam | Mbc3Hardware::Rtc = self.hw {
             self.rtc.tick();
         }
     }
 }
 
 #[derive(Debug)]
-struct MBC5 {
+struct Mbc5 {
     /// 9-bit number
     rom_bank: u16,
     /// 4-bit number
@@ -549,11 +552,11 @@ struct MBC5 {
     mem: Vec<u8>,
     mem_enabled: bool,
 
-    hw: MBC5Hardware,
+    hw: Mbc5Hardware,
 }
 
-impl MBC5 {
-    fn new(hw: MBC5Hardware, ram_cap: usize, rom_cap: usize) -> Self {
+impl Mbc5 {
+    fn new(hw: Mbc5Hardware, ram_cap: usize, rom_cap: usize) -> Self {
         Self {
             rom_bank: 0x01,
             mem: vec![0; ram_cap],
@@ -569,25 +572,25 @@ impl MBC5 {
     }
 }
 
-impl Savable for MBC5 {
+impl Savable for Mbc5 {
     fn ext_ram(&self) -> Option<&[u8]> {
         match self.hw {
-            MBC5Hardware::RumbleBatteryRAM | MBC5Hardware::BatteryRAM => Some(&self.mem),
+            Mbc5Hardware::RumbleBatteryRam | Mbc5Hardware::BatteryRam => Some(&self.mem),
             _ => None,
         }
     }
 
     fn ext_ram_mut(&mut self) -> Option<&mut [u8]> {
         match self.hw {
-            MBC5Hardware::RumbleBatteryRAM | MBC5Hardware::BatteryRAM => Some(&mut self.mem),
+            Mbc5Hardware::RumbleBatteryRam | Mbc5Hardware::BatteryRam => Some(&mut self.mem),
             _ => None,
         }
     }
 }
 
-impl MBCIo for MBC5 {
-    fn handle_read(&self, addr: u16) -> MBCResult {
-        use MBCResult::*;
+impl MbcIo for Mbc5 {
+    fn handle_read(&self, addr: u16) -> MbcResult {
+        use MbcResult::*;
 
         match addr {
             0x0000..=0x3FFF => Addr(addr as usize),
@@ -615,25 +618,25 @@ impl MBCIo for MBC5 {
     }
 }
 
-impl RtClockTick for MBC5 {
+impl RtcTick for Mbc5 {
     fn tick(&mut self) {}
 }
 
 #[derive(Debug)]
-struct MBC2 {
+struct Mbc2 {
     /// 4-bit number
     rom_bank: u8,
     mem: Box<[u8; Self::RAM_SIZE]>,
 
     mem_enabled: bool,
     rom_cap: usize,
-    hw: MBC2Hardware,
+    hw: Mbc2Hardware,
 }
 
-impl MBC2 {
+impl Mbc2 {
     const RAM_SIZE: usize = 0x0200;
 
-    fn new(hw: MBC2Hardware, rom_cap: usize) -> Self {
+    fn new(hw: Mbc2Hardware, rom_cap: usize) -> Self {
         Self {
             rom_bank: 0x01,
             mem: Box::new([0; Self::RAM_SIZE]),
@@ -648,25 +651,25 @@ impl MBC2 {
     }
 }
 
-impl Savable for MBC2 {
+impl Savable for Mbc2 {
     fn ext_ram(&self) -> Option<&[u8]> {
         match self.hw {
-            MBC2Hardware::BatteryRAM => Some(self.mem.as_ref()),
-            MBC2Hardware::None => None,
+            Mbc2Hardware::BatteryRam => Some(self.mem.as_ref()),
+            Mbc2Hardware::None => None,
         }
     }
 
     fn ext_ram_mut(&mut self) -> Option<&mut [u8]> {
         match self.hw {
-            MBC2Hardware::BatteryRAM => Some(self.mem.as_mut()),
-            MBC2Hardware::None => None,
+            Mbc2Hardware::BatteryRam => Some(self.mem.as_mut()),
+            Mbc2Hardware::None => None,
         }
     }
 }
 
-impl MBCIo for MBC2 {
-    fn handle_read(&self, addr: u16) -> MBCResult {
-        use MBCResult::*;
+impl MbcIo for Mbc2 {
+    fn handle_read(&self, addr: u16) -> MbcResult {
+        use MbcResult::*;
 
         match addr {
             0x0000..=0x3FFF => Addr(addr as usize),
@@ -698,14 +701,14 @@ impl MBCIo for MBC2 {
     }
 }
 
-impl RtClockTick for MBC2 {
+impl RtcTick for Mbc2 {
     fn tick(&mut self) {}
 }
 
 #[derive(Debug)]
-struct NoMBC;
+struct NoMbc;
 
-impl Savable for NoMBC {
+impl Savable for NoMbc {
     fn ext_ram(&self) -> Option<&[u8]> {
         None
     }
@@ -715,9 +718,9 @@ impl Savable for NoMBC {
     }
 }
 
-impl MBCIo for NoMBC {
-    fn handle_read(&self, addr: u16) -> MBCResult {
-        MBCResult::Addr(addr as usize)
+impl MbcIo for NoMbc {
+    fn handle_read(&self, addr: u16) -> MbcResult {
+        MbcResult::Addr(addr as usize)
     }
 
     fn handle_write(&mut self, _: u16, byte: u8) {
@@ -725,60 +728,60 @@ impl MBCIo for NoMBC {
     }
 }
 
-impl RtClockTick for NoMBC {
+impl RtcTick for NoMbc {
     fn tick(&mut self) {}
 }
 
-trait MBCIo: Savable + RtClockTick {
-    fn handle_read(&self, addr: u16) -> MBCResult;
+trait MbcIo: Savable + RtcTick {
+    fn handle_read(&self, addr: u16) -> MbcResult;
     fn handle_write(&mut self, addr: u16, byte: u8);
 }
 
 #[derive(Debug, Clone, Copy)]
-enum MBCResult {
+enum MbcResult {
     Addr(usize),
     Byte(u8),
 }
 
 #[derive(Debug, Clone, Copy)]
-enum MBCKind {
+enum MbcKind {
     None,
-    MBC1(MBC1Hardware),
-    MBC2(MBC2Hardware),
-    MBC3(MBC3Hardware),
-    MBC5(MBC5Hardware),
+    Mbc1(Mbc1Hardware),
+    Mbc2(Mbc2Hardware),
+    Mbc3(Mbc3Hardware),
+    Mbc5(Mbc5Hardware),
 }
 
 #[derive(Debug, Clone, Copy)]
-enum MBC1Hardware {
+enum Mbc1Hardware {
     None,
-    RAM,
-    BatteryRAM,
+    Ram,
+    BatteryRam,
 }
 
 #[derive(Debug, Clone, Copy)]
-enum MBC2Hardware {
+enum Mbc2Hardware {
     None,
-    BatteryRAM,
+    BatteryRam,
 }
 
 #[derive(Debug, Clone, Copy)]
-enum MBC3Hardware {
-    RTC,
-    RTCAndBatteryRAM,
+enum Mbc3Hardware {
+    Rtc,
+    RtcBatteryRam,
     None,
-    RAM,
-    BatteryRAM,
+    Ram,
+    BatteryRam,
 }
 
 #[derive(Debug, Clone, Copy)]
-enum MBC5Hardware {
+enum Mbc5Hardware {
     None,
-    RAM,
-    BatteryRAM,
+    Ram,
+    BatteryRam,
     Rumble,
-    RumbleRAM,
-    RumbleBatteryRAM,
+    RumbleRam,
+    RumbleBatteryRam,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -874,7 +877,7 @@ impl From<u8> for RomSize {
     }
 }
 
-impl std::fmt::Debug for Box<dyn MBCIo> {
+impl std::fmt::Debug for Box<dyn MbcIo> {
     fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         todo!("Implement Debug for Box<dyn MBC> Trait Object");
     }
@@ -950,4 +953,14 @@ mod tests {
             Cartridge::detect_title(&title)
         );
     }
+
+    #[test]
+    fn all_whitespace_title() {
+        let title = [
+            0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00,
+        ];
+
+        assert_eq!(None, Cartridge::detect_title(&title));
+    }
 }

src/cpu.rs

@@ -485,3 +485,39 @@ pub(crate) enum ImeState {
     Pending,
     Enabled,
 }
+
+pub(crate) mod dbg {
+    use super::{Cpu, ImeState, RegisterPair};
+
+    pub(crate) fn flags(cpu: &Cpu) -> u8 {
+        cpu.flags.into()
+    }
+
+    pub(crate) fn af(cpu: &Cpu) -> u16 {
+        cpu.register_pair(RegisterPair::AF)
+    }
+
+    pub(crate) fn bc(cpu: &Cpu) -> u16 {
+        cpu.register_pair(RegisterPair::BC)
+    }
+
+    pub(crate) fn de(cpu: &Cpu) -> u16 {
+        cpu.register_pair(RegisterPair::DE)
+    }
+
+    pub(crate) fn hl(cpu: &Cpu) -> u16 {
+        cpu.register_pair(RegisterPair::HL)
+    }
+
+    pub(crate) fn sp(cpu: &Cpu) -> u16 {
+        cpu.register_pair(RegisterPair::SP)
+    }
+
+    pub(crate) fn pc(cpu: &Cpu) -> u16 {
+        cpu.register_pair(RegisterPair::PC)
+    }
+
+    pub(crate) fn ime(cpu: &Cpu) -> bool {
+        matches!(cpu.ime, ImeState::Enabled)
+    }
+}

src/emu.rs

@@ -18,7 +18,13 @@ pub const CYCLES_IN_FRAME: Cycle = 456 * 154; // 456 Cycles times 154 scanlines
 pub(crate) const SM83_CLOCK_SPEED: u64 = 0x40_0000; // Hz which is 4.194304Mhz
 const DEFAULT_TITLE: &str = "Game Boy Screen";
 
-pub fn run_frame(cpu: &mut Cpu, gamepad: &mut Gilrs, key: KeyboardInput) -> Cycle {
+#[inline]
+pub fn run_frame(cpu: &mut Cpu, gamepad: &mut Gilrs, key: KeyboardInput) {
+    run(cpu, gamepad, key, CYCLES_IN_FRAME)
+}
+
+#[inline]
+pub fn run(cpu: &mut Cpu, gamepad: &mut Gilrs, key: KeyboardInput, cycles: Cycle) {
     let mut elapsed = 0;
 
     if let Some(event) = gamepad.next_event() {
@@ -26,11 +32,9 @@ pub fn run_frame(cpu: &mut Cpu, gamepad: &mut Gilrs, key: KeyboardInput) -> Cycl
     }
     crate::joypad::handle_keyboard_input(&mut cpu.bus.joyp, key);
 
-    while elapsed < CYCLES_IN_FRAME {
+    while elapsed < cycles {
         elapsed += cpu.step();
     }
-
-    elapsed
 }
 
 pub fn save_and_exit(cpu: &Cpu, control_flow: &mut ControlFlow) {
@@ -40,7 +44,8 @@ pub fn save_and_exit(cpu: &Cpu, control_flow: &mut ControlFlow) {
 
 #[inline]
 pub fn pixel_buf(cpu: &Cpu) -> &[u8; GB_HEIGHT * GB_WIDTH * 4] {
-    cpu.bus.ppu.frame_buf.as_ref()
+    use crate::ppu::Device;
+    cpu.bus.ppu.frame_buf.get(Device::Host)
 }
 
 pub fn from_boot_rom<P: AsRef<Path>>(path: P) -> std::io::Result<Cpu> {
@@ -60,8 +65,7 @@ pub fn rom_title(cpu: &Cpu) -> &str {
     cpu.bus
         .cart
         .as_ref()
-        .map(|c| c.title.as_deref())
-        .flatten()
+        .and_then(|c| c.title.as_deref())
         .unwrap_or(DEFAULT_TITLE)
 }
 

src/gui.rs

@@ -1,17 +1,20 @@
-use egui::{ClippedMesh, CtxRef, TextureId};
-use egui_wgpu_backend::{BackendError, RenderPass, ScreenDescriptor};
+use egui::{Context, TextureId};
+use egui_wgpu_backend::{wgpu, RenderPass, ScreenDescriptor};
 use egui_winit_platform::Platform;
 use wgpu::{
     Adapter, CommandEncoder, Device, Extent3d, FilterMode, Instance, Queue, RequestDeviceError,
-    Surface, SurfaceConfiguration, SurfaceTexture, Texture, TextureFormat, TextureUsages,
-    TextureView,
+    Surface, SurfaceCapabilities, SurfaceConfiguration, Texture, TextureView,
+    TextureViewDescriptor,
 };
+
+use winit::dpi::PhysicalSize;
 use winit::error::OsError;
-use winit::event::{ElementState, KeyboardInput};
-use winit::event_loop::EventLoop;
+use winit::event::{ElementState, Event, KeyboardInput};
+use winit::event_loop::{ControlFlow, EventLoop};
 use winit::window::Window;
 
-use crate::{GB_HEIGHT, GB_WIDTH};
+use crate::cpu::Cpu;
+use crate::{emu, GB_HEIGHT, GB_WIDTH};
 
 const EGUI_DIMENSIONS: (usize, usize) = (1280, 720);
 const FILTER_MODE: FilterMode = FilterMode::Nearest;
@@ -19,21 +22,287 @@ const WINDOW_TITLE: &str = "DMG-01 Emulator";
 
 const SCALE: f32 = 3.0;
 
-/// Holds GUI State
-#[derive(Debug, Clone)]
-pub struct GuiState {
-    /// When true, egui winit should exit the application
-    pub quit: bool,
+pub struct Gui {
+    pub should_quit: bool,
     pub title: String,
+    pub mode: EmuMode,
+
+    window: Window,
+    platform: Platform,
+
+    surface: Surface,
+    device: Device,
+    queue: Queue,
+    surface_config: SurfaceConfiguration,
+    render_pass: RenderPass,
+
+    texture: Texture,
+    texture_size: Extent3d,
+    texture_id: TextureId,
 }
 
-impl GuiState {
-    pub fn new(title: String) -> Self {
+impl Gui {
+    pub fn new<T>(title: String, event_loop: &EventLoop<T>, cpu: &Cpu) -> Self {
+        use wgpu::InstanceDescriptor;
+
+        let window = build_window(event_loop).expect("build window");
+
+        let instance = Instance::new(InstanceDescriptor::default());
+        let surface = unsafe {
+            instance
+                .create_surface(&window)
+                .expect("create wgpu instance surface")
+        };
+
+        let adapter = request_adapter(&instance, &surface).expect("request adaptor");
+        let (device, queue) = request_device(&adapter).expect("request device");
+
+        let capabilities = surface.get_capabilities(&adapter);
+
+        let surface_config = surface_config(&window, capabilities);
+        surface.configure(&device, &surface_config);
+        let platform = platform(&window);
+        let mut render_pass = RenderPass::new(&device, surface_config.format, 1);
+
+        let texture_size = texture_size();
+        let texture = create_texture(&device, texture_size);
+        write_to_texture(&queue, &texture, emu::pixel_buf(cpu), texture_size);
+
+        let view = texture.create_view(&TextureViewDescriptor::default());
+        let texture_id = expose_texture_to_egui(&mut render_pass, &device, &view);
+
         Self {
+            should_quit: Default::default(),
             title,
-            quit: Default::default(),
+            mode: EmuMode::Running,
+
+            window,
+            platform,
+
+            surface,
+            device,
+            queue,
+            surface_config,
+            render_pass,
+
+            texture,
+            texture_size,
+            texture_id,
         }
     }
+
+    pub fn maybe_quit(&self, cpu: &Cpu, control_flow: &mut ControlFlow) {
+        if self.should_quit {
+            emu::save_and_exit(cpu, control_flow);
+        }
+    }
+
+    pub fn request_redraw(&self) {
+        self.window.request_redraw();
+    }
+
+    pub fn handle_event<T>(&mut self, event: &Event<T>) {
+        self.platform.handle_event(event);
+    }
+
+    pub fn update_time(&mut self, elapsed_seconds: f64) {
+        self.platform.update_time(elapsed_seconds);
+    }
+
+    pub fn resize(&mut self, size: PhysicalSize<u32>) {
+        // See: https://github.com/rust-windowing/winit/issues/208
+        if size.width > 0 && size.height > 0 {
+            self.surface_config.width = size.width;
+            self.surface_config.height = size.height;
+            self.surface.configure(&self.device, &self.surface_config);
+        }
+    }
+
+    pub fn paint(&mut self, cpu: &Cpu) {
+        use wgpu::{Color, SurfaceError};
+
+        let data = emu::pixel_buf(cpu);
+        write_to_texture(&self.queue, &self.texture, data, self.texture_size);
+
+        let output_frame = match self.surface.get_current_texture() {
+            Ok(frame) => frame,
+            Err(SurfaceError::Outdated) => return, // Occurs on minimization on Windows
+            Err(e) => {
+                eprintln!("Dropped frame with error: {}", e);
+                return;
+            }
+        };
+
+        let output_view = output_frame
+            .texture
+            .create_view(&TextureViewDescriptor::default());
+
+        // Begin to draw Egui components
+        self.platform.begin_frame();
+        self.draw_egui(cpu, &self.platform.context(), self.texture_id);
+
+        // End the UI frame. We could now handle the output and draw the UI with the backend.
+        let full_output = self.platform.end_frame(Some(&self.window));
+        let paint_jobs = self.platform.context().tessellate(full_output.shapes);
+
+        let mut encoder = create_command_encoder(&self.device);
+        let screen_descriptor = create_screen_descriptor(&self.window, &self.surface_config);
+        let tdelta = full_output.textures_delta;
+        // Upload all resources for the GPU.
+        self.render_pass
+            .add_textures(&self.device, &self.queue, &tdelta)
+            .expect("add texture ok");
+        self.render_pass
+            .update_buffers(&self.device, &self.queue, &paint_jobs, &screen_descriptor);
+
+        // Record all render passes.
+        self.render_pass
+            .execute(
+                &mut encoder,
+                &output_view,
+                &paint_jobs,
+                &screen_descriptor,
+                Some(Color::BLACK),
+            )
+            .expect("execute render pass");
+
+        // Submit the commands.
+        self.queue.submit(std::iter::once(encoder.finish()));
+
+        // Redraw egui
+        output_frame.present();
+
+        self.render_pass
+            .remove_textures(tdelta)
+            .expect("remove texture delta");
+    }
+
+    #[inline]
+    pub fn draw_egui(&mut self, cpu: &Cpu, ctx: &Context, texture_id: TextureId) {
+        use crate::{cpu, instruction, ppu};
+
+        fn selectable_text(ui: &mut egui::Ui, mut text: &str) -> egui::Response {
+            ui.add(egui::TextEdit::multiline(&mut text).code_editor())
+        }
+
+        egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
+            ui.menu_button("File", |ui| {
+                if ui.button("Quit").clicked() {
+                    self.should_quit = true;
+                }
+            });
+
+            egui::Window::new(&self.title).show(ctx, |ui| {
+                ui.image(
+                    texture_id,
+                    [GB_WIDTH as f32 * SCALE, GB_HEIGHT as f32 * SCALE],
+                );
+            });
+
+            egui::Window::new("Disassembly").show(ctx, |ui| {
+                selectable_text(ui, &instruction::dbg::tmp_disasm(cpu, 20));
+            });
+
+            egui::Window::new("Settings").show(ctx, |ui| {
+                egui::ComboBox::from_label("Emulation Mode")
+                    .selected_text(format!("{:?}", self.mode))
+                    .show_ui(ui, |ui| {
+                        ui.selectable_value(&mut self.mode, EmuMode::Running, "Running");
+                        ui.selectable_value(&mut self.mode, EmuMode::Stopped, "Stopped");
+                        ui.selectable_value(&mut self.mode, EmuMode::StepFrame, "Step Frame");
+                        ui.selectable_value(&mut self.mode, EmuMode::Step, "Step");
+                    })
+            });
+
+            egui::Window::new("GB Info").show(ctx, |ui| {
+                ui.horizontal(|ui| {
+                    ui.vertical(|ui| {
+                        ui.heading("CPU");
+
+                        ui.monospace(format!("AF: {:#06X}", cpu::dbg::af(cpu)));
+                        ui.monospace(format!("BC: {:#06X}", cpu::dbg::bc(cpu)));
+                        ui.monospace(format!("DE: {:#06X}", cpu::dbg::de(cpu)));
+                        ui.monospace(format!("HL: {:#06X}", cpu::dbg::hl(cpu)));
+                        ui.add_space(10.0);
+                        ui.monospace(format!("SP: {:#06X}", cpu::dbg::sp(cpu)));
+                        ui.monospace(format!("PC: {:#06X}", cpu::dbg::pc(cpu)));
+                    });
+
+                    ui.vertical(|ui| {
+                        let ppu = &cpu.bus.ppu;
+
+                        ui.heading("PPU");
+
+                        ui.monospace(format!("LY: {}", ppu::dbg::ly(ppu)));
+                        ui.horizontal(|ui| {
+                            ui.monospace(format!("SCX: {}", ppu::dbg::scx(ppu)));
+                            ui.monospace(format!("SCY: {}", ppu::dbg::scy(ppu)));
+                        });
+                        ui.horizontal(|ui| {
+                            ui.monospace(format!("WX: {}", ppu::dbg::wx(ppu)));
+                            ui.monospace(format!("WY: {}", ppu::dbg::wy(ppu)));
+                        });
+
+                        ui.monospace(format!(
+                            "Mode: {:?} {}",
+                            ppu::dbg::mode(ppu),
+                            ppu::dbg::dot(ppu)
+                        ))
+                    });
+                });
+
+                ui.add_space(10.0);
+
+                let _ = ui.selectable_label(cpu::dbg::ime(cpu), "IME");
+                ui.horizontal(|ui| {
+                    let irq = cpu.int_request();
+
+                    ui.label("IRQ:");
+                    let _ = ui.selectable_label(irq & 0b01 == 0x01, "VBlank");
+                    let _ = ui.selectable_label(irq >> 1 & 0x01 == 0x01, "LCD STAT");
+                    let _ = ui.selectable_label(irq >> 2 & 0x01 == 0x01, "Timer");
+                    let _ = ui.selectable_label(irq >> 3 & 0x01 == 0x01, "Serial");
+                    let _ = ui.selectable_label(irq >> 4 & 0x01 == 0x01, "Joypad");
+                });
+
+                ui.horizontal(|ui| {
+                    let ie = cpu.int_enable();
+
+                    // TODO: Reimplement this
+                    // let r_len = ctx.fonts().glyph_width(egui::TextStyle::Body, 'R');
+                    // let e_len = ctx.fonts().glyph_width(egui::TextStyle::Body, 'E');
+                    // let q_len = ctx.fonts().glyph_width(egui::TextStyle::Body, 'Q');
+
+                    ui.label("IE:");
+                    // ui.add_space(q_len - (e_len - r_len));
+                    let _ = ui.selectable_label(ie & 0b01 == 0x01, "VBlank");
+                    let _ = ui.selectable_label(ie >> 1 & 0x01 == 0x01, "LCD STAT");
+                    let _ = ui.selectable_label(ie >> 2 & 0x01 == 0x01, "Timer");
+                    let _ = ui.selectable_label(ie >> 3 & 0x01 == 0x01, "Serial");
+                    let _ = ui.selectable_label(ie >> 4 & 0x01 == 0x01, "Joypad");
+                });
+
+                ui.add_space(10.0);
+
+                ui.horizontal(|ui| {
+                    let flags = cpu::dbg::flags(cpu);
+
+                    let _ = ui.selectable_label((flags >> 7 & 0x01) == 0x01, "Zero");
+                    let _ = ui.selectable_label((flags >> 6 & 0x01) == 0x01, "Negative");
+                    let _ = ui.selectable_label((flags >> 5 & 0x01) == 0x01, "Half-Carry");
+                    let _ = ui.selectable_label((flags >> 4 & 0x01) == 0x01, "Carry");
+                })
+            })
+        });
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EmuMode {
+    Running,
+    StepFrame,
+    Stopped,
+    Step,
 }
 
 /// To avoid using an [Option<KeyboardInput>] to keep track of user input from winit,
@@ -50,8 +319,7 @@ pub fn unused_key() -> KeyboardInput {
     }
 }
 
-pub fn build_window<T>(event_loop: &EventLoop<T>) -> Result<Window, OsError> {
-    use winit::dpi::PhysicalSize;
+fn build_window<T>(event_loop: &EventLoop<T>) -> Result<Window, OsError> {
     use winit::window::WindowBuilder;
 
     WindowBuilder::new()
@@ -66,51 +334,45 @@ pub fn build_window<T>(event_loop: &EventLoop<T>) -> Result<Window, OsError> {
         .build(event_loop)
 }
 
-pub fn create_surface(window: &Window) -> (Instance, Surface) {
-    use wgpu::Backends;
-
-    let instance = Instance::new(Backends::PRIMARY);
-    let surface = unsafe { instance.create_surface(window) };
-    (instance, surface)
-}
-
-pub fn request_adapter(instance: &Instance, surface: &Surface) -> Option<Adapter> {
+fn request_adapter(instance: &Instance, surface: &Surface) -> Option<Adapter> {
     use wgpu::{PowerPreference, RequestAdapterOptions};
 
     pollster::block_on(instance.request_adapter(&RequestAdapterOptions {
         power_preference: PowerPreference::HighPerformance,
-        force_fallback_adapter: false, // TODO: What do I want to do with this?
         compatible_surface: Some(surface),
+        force_fallback_adapter: false, // TODO: What do I want to do with this?
     }))
 }
 
-pub fn request_device(adapter: &Adapter) -> Result<(Device, Queue), RequestDeviceError> {
+fn request_device(adapter: &Adapter) -> Result<(Device, Queue), RequestDeviceError> {
     use wgpu::{DeviceDescriptor, Features, Limits};
 
     pollster::block_on(adapter.request_device(
         &DeviceDescriptor {
-            label: None,
             features: Features::default(),
             limits: Limits::default(),
+            label: None,
         },
         None,
     ))
 }
 
-pub fn surface_config(window: &Window, format: TextureFormat) -> SurfaceConfiguration {
-    use wgpu::PresentMode;
+fn surface_config(window: &Window, capabilities: SurfaceCapabilities) -> SurfaceConfiguration {
+    use egui_wgpu_backend::wgpu::{PresentMode, TextureFormat, TextureUsages};
 
     let size = window.inner_size();
     SurfaceConfiguration {
         usage: TextureUsages::RENDER_ATTACHMENT,
-        format,
+        format: capabilities.formats[0],
         width: size.width as u32,
         height: size.height as u32,
-        present_mode: PresentMode::Mailbox,
+        present_mode: PresentMode::Fifo,
+        alpha_mode: capabilities.alpha_modes[0],
+        view_formats: vec![TextureFormat::Rgba8UnormSrgb],
     }
 }
 
-pub fn platform_desc(window: &Window) -> Platform {
+fn platform(window: &Window) -> Platform {
     use egui::FontDefinitions;
     use egui_winit_platform::PlatformDescriptor;
 
@@ -124,7 +386,7 @@ pub fn platform_desc(window: &Window) -> Platform {
     })
 }
 
-pub fn texture_size() -> Extent3d {
+fn texture_size() -> Extent3d {
     Extent3d {
         width: GB_WIDTH as u32,
         height: GB_HEIGHT as u32,
@@ -132,22 +394,23 @@ pub fn texture_size() -> Extent3d {
     }
 }
 
-pub fn create_texture(device: &Device, size: Extent3d) -> Texture {
-    use wgpu::{TextureDescriptor, TextureDimension};
+fn create_texture(device: &Device, size: Extent3d) -> Texture {
+    use wgpu::{TextureDescriptor, TextureDimension, TextureFormat, TextureUsages};
 
     device.create_texture(&TextureDescriptor {
         size,
         mip_level_count: 1,
         sample_count: 1,
         dimension: TextureDimension::D2,
-        format: TextureFormat::Rgba8UnormSrgb,
+        format: TextureFormat::Bgra8Unorm,
         usage: TextureUsages::COPY_DST | TextureUsages::TEXTURE_BINDING,
         label: Some("gb_pixel_buffer"),
+        view_formats: &[TextureFormat::Bgra8Unorm],
     })
 }
 
 #[inline]
-pub fn write_to_texture(
+fn write_to_texture(
     queue: &Queue,
     texture: &Texture,
     data: &[u8; GB_WIDTH * 4 * GB_HEIGHT],
@@ -173,23 +436,16 @@ pub fn write_to_texture(
     );
 }
 
-pub fn expose_texture_to_egui(
+fn expose_texture_to_egui(
     render_pass: &mut RenderPass,
     device: &Device,
-    texture: &Texture,
+    view: &TextureView,
 ) -> TextureId {
-    render_pass.egui_texture_from_wgpu_texture(device, texture, FILTER_MODE)
+    render_pass.egui_texture_from_wgpu_texture(device, view, FILTER_MODE)
 }
 
 #[inline]
-pub fn create_view(frame: &SurfaceTexture) -> TextureView {
-    use wgpu::TextureViewDescriptor;
-
-    frame.texture.create_view(&TextureViewDescriptor::default())
-}
-
-#[inline]
-pub fn create_command_encoder(device: &Device) -> CommandEncoder {
+fn create_command_encoder(device: &Device) -> CommandEncoder {
     use wgpu::CommandEncoderDescriptor;
 
     device.create_command_encoder(&CommandEncoderDescriptor {
@@ -198,10 +454,7 @@ pub fn create_command_encoder(device: &Device) -> CommandEncoder {
 }
 
 #[inline]
-pub fn create_screen_descriptor(
-    window: &Window,
-    config: &SurfaceConfiguration,
-) -> ScreenDescriptor {
+fn create_screen_descriptor(window: &Window, config: &SurfaceConfiguration) -> ScreenDescriptor {
     ScreenDescriptor {
         physical_width: config.width,
         physical_height: config.height,
@@ -209,31 +462,11 @@ pub fn create_screen_descriptor(
     }
 }
 
-#[inline]
-pub fn execute_render_pass(
-    render_pass: &mut RenderPass,
-    encoder: &mut CommandEncoder,
-    view: &TextureView,
-    jobs: Vec<ClippedMesh>,
-    descriptor: &ScreenDescriptor,
-) -> Result<(), BackendError> {
-    render_pass.execute(encoder, view, &jobs, descriptor, Some(wgpu::Color::BLACK))
-}
+pub mod kbd {
+    use winit::event::{ElementState, KeyboardInput, VirtualKeyCode};
 
-#[inline]
-pub fn draw_egui(app: &mut GuiState, ctx: &CtxRef, texture_id: TextureId) {
-    egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
-        egui::menu::menu(ui, "File", |ui| {
-            if ui.button("Quit").clicked() {
-                app.quit = true;
-            }
-        });
-
-        egui::Window::new(&app.title).show(ctx, |ui| {
-            ui.image(
-                texture_id,
-                [GB_WIDTH as f32 * SCALE, GB_HEIGHT as f32 * SCALE],
-            );
-        })
-    });
+    pub fn space_released(input: &KeyboardInput) -> bool {
+        let keycode = input.virtual_keycode;
+        matches!(input.state, ElementState::Released if keycode == Some(VirtualKeyCode::Space))
+    }
 }

src/high_ram.rs

@@ -17,11 +17,11 @@ impl Default for HighRam {
 }
 
 impl BusIo for HighRam {
-    fn write_byte(&mut self, addr: u16, byte: u8) {
-        self.buf[addr as usize - HIGH_RAM_START_ADDRESS] = byte;
-    }
-
     fn read_byte(&self, addr: u16) -> u8 {
         self.buf[addr as usize - HIGH_RAM_START_ADDRESS]
     }
+
+    fn write_byte(&mut self, addr: u16, byte: u8) {
+        self.buf[addr as usize - HIGH_RAM_START_ADDRESS] = byte;
+    }
 }

src/instruction.rs

@@ -1,6 +1,6 @@
 use self::add::{Source as AddSource, Target as AddTarget};
 use self::alu::Source as AluSource;
-use self::jump::{JumpCondition, JumpLocation};
+use self::jump::{JpCond, JpLoc};
 use self::load::{Source as LDSource, Target as LDTarget};
 use self::table::{
     alu_imm_instr, alu_reg_instr, flag_instr, group1, group2, group3, jump_cond, prefix_alu,
@@ -16,7 +16,7 @@ use crate::Cycle;
 pub(crate) enum Instruction {
     NOP,
     STOP,
-    JR(JumpCondition),
+    JR(JpCond),
     LD(LDTarget, LDSource),
     ADD(AddTarget, AddSource),
     LDHL,
@@ -38,13 +38,13 @@ pub(crate) enum Instruction {
     XOR(AluSource),
     OR(AluSource),
     CP(AluSource),
-    RET(JumpCondition),
+    RET(JpCond),
     POP(Group3RegisterPair),
     RETI,
-    JP(JumpCondition, JumpLocation),
+    JP(JpCond, JpLoc),
     DI,
     EI,
-    CALL(JumpCondition),
+    CALL(JpCond),
     PUSH(Group3RegisterPair),
     RST(u8),
     RLC(Register),
@@ -58,6 +58,7 @@ pub(crate) enum Instruction {
     BIT(u8, Register),
     RES(u8, Register),
     SET(u8, Register),
+    Invalid,
 }
 
 impl std::fmt::Debug for Instruction {
@@ -109,6 +110,7 @@ impl std::fmt::Debug for Instruction {
             BIT(b, r) => write!(f, "BIT {}, {:?}", b, r),
             RES(b, r) => write!(f, "RES {}, {:?}", b, r),
             SET(b, r) => write!(f, "SET {}, {:?}", b, r),
+            Invalid => f.write_str("???"),
         }
     }
 }
@@ -293,7 +295,7 @@ impl Instruction {
                 let addr = pc.wrapping_add(byte as u16);
 
                 match cond {
-                    JumpCondition::NotZero => {
+                    JpCond::NotZero => {
                         if !flags.z() {
                             Self::jump(cpu, addr);
                             12
@@ -301,7 +303,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::Zero => {
+                    JpCond::Zero => {
                         if flags.z() {
                             Self::jump(cpu, addr);
                             12
@@ -309,7 +311,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::NotCarry => {
+                    JpCond::NotCarry => {
                         if !flags.c() {
                             Self::jump(cpu, addr);
                             12
@@ -317,7 +319,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::Carry => {
+                    JpCond::Carry => {
                         if flags.c() {
                             Self::jump(cpu, addr);
                             12
@@ -325,7 +327,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::Always => {
+                    JpCond::Always => {
                         Self::jump(cpu, addr);
                         12
                     }
@@ -837,7 +839,7 @@ impl Instruction {
                 let flags: Flags = *cpu.flags();
 
                 match cond {
-                    JumpCondition::NotZero => {
+                    JpCond::NotZero => {
                         cpu.bus.clock(); // internal branch decision
 
                         if !flags.z() {
@@ -848,7 +850,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::Zero => {
+                    JpCond::Zero => {
                         cpu.bus.clock(); // internal branch decision
 
                         if flags.z() {
@@ -859,7 +861,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::NotCarry => {
+                    JpCond::NotCarry => {
                         cpu.bus.clock(); // internal branch decision
 
                         if !flags.c() {
@@ -870,7 +872,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::Carry => {
+                    JpCond::Carry => {
                         cpu.bus.clock(); // internal branch decision
 
                         if flags.c() {
@@ -881,7 +883,7 @@ impl Instruction {
                             8
                         }
                     }
-                    JumpCondition::Always => {
+                    JpCond::Always => {
                         let addr = Self::pop(cpu);
                         Self::jump(cpu, addr);
                         16
@@ -908,13 +910,13 @@ impl Instruction {
                 16
             }
             Instruction::JP(cond, location) => match location {
-                JumpLocation::HL => {
+                JpLoc::HL => {
                     // JP HL | Store HL in program counter
                     let right = cpu.register_pair(RegisterPair::HL);
                     cpu.set_register_pair(RegisterPair::PC, right);
                     4
                 }
-                JumpLocation::ImmediateWord => {
+                JpLoc::ImmediateWord => {
                     // JP cond u16 | Store u16 in program counter if condition is true
                     // JP u16      | Store u16 in program counter
                     let flags: Flags = *cpu.flags();
@@ -922,7 +924,7 @@ impl Instruction {
                     let addr = Self::imm_word(cpu);
 
                     match cond {
-                        JumpCondition::NotZero => {
+                        JpCond::NotZero => {
                             if !flags.z() {
                                 Self::jump(cpu, addr);
                                 16
@@ -930,7 +932,7 @@ impl Instruction {
                                 12
                             }
                         }
-                        JumpCondition::Zero => {
+                        JpCond::Zero => {
                             if flags.z() {
                                 Self::jump(cpu, addr);
                                 16
@@ -938,7 +940,7 @@ impl Instruction {
                                 12
                             }
                         }
-                        JumpCondition::NotCarry => {
+                        JpCond::NotCarry => {
                             if !flags.c() {
                                 Self::jump(cpu, addr);
                                 16
@@ -946,7 +948,7 @@ impl Instruction {
                                 12
                             }
                         }
-                        JumpCondition::Carry => {
+                        JpCond::Carry => {
                             if flags.c() {
                                 Self::jump(cpu, addr);
                                 16
@@ -954,7 +956,7 @@ impl Instruction {
                                 12
                             }
                         }
-                        JumpCondition::Always => {
+                        JpCond::Always => {
                             Self::jump(cpu, addr);
                             16
                         }
@@ -980,7 +982,7 @@ impl Instruction {
                 let return_addr = cpu.register_pair(RegisterPair::PC);
 
                 match cond {
-                    JumpCondition::NotZero => {
+                    JpCond::NotZero => {
                         if !flags.z() {
                             cpu.bus.clock(); // internal branch decision
                             Self::push(cpu, return_addr);
@@ -990,7 +992,7 @@ impl Instruction {
                             12
                         }
                     }
-                    JumpCondition::Zero => {
+                    JpCond::Zero => {
                         if flags.z() {
                             cpu.bus.clock(); // internal branch decision
                             Self::push(cpu, return_addr);
@@ -1000,7 +1002,7 @@ impl Instruction {
                             12
                         }
                     }
-                    JumpCondition::NotCarry => {
+                    JpCond::NotCarry => {
                         if !flags.c() {
                             cpu.bus.clock(); // internal branch decision
                             Self::push(cpu, return_addr);
@@ -1010,7 +1012,7 @@ impl Instruction {
                             12
                         }
                     }
-                    JumpCondition::Carry => {
+                    JpCond::Carry => {
                         if flags.c() {
                             cpu.bus.clock(); // internal branch decision
                             Self::push(cpu, return_addr);
@@ -1020,7 +1022,7 @@ impl Instruction {
                             12
                         }
                     }
-                    JumpCondition::Always => {
+                    JpCond::Always => {
                         cpu.bus.clock(); // internal branch decision
                         Self::push(cpu, return_addr);
                         cpu.set_register_pair(RegisterPair::PC, addr);
@@ -1294,6 +1296,7 @@ impl Instruction {
                     }
                 }
             }
+            Instruction::Invalid => panic!("Attempted to execute invalid instruction"),
         }
     }
 
@@ -1557,7 +1560,7 @@ impl Instruction {
             // STOP
             0o020 => STOP,
             // JR i8
-            0o030 => JR(JumpCondition::Always),
+            0o030 => JR(JpCond::Always),
             // JR cond i8
             0o040 | 0o050 | 0o060 | 0o070 => JR(jump_cond((byte >> 3) & 0x03)),
             // LD r16, u16
@@ -1622,16 +1625,16 @@ impl Instruction {
             // POP r16
             0o301 | 0o321 | 0o341 | 0o361 => POP(group3((byte >> 4) & 0x03)),
             // RET
-            0o311 => RET(JumpCondition::Always),
+            0o311 => RET(JpCond::Always),
             // RETI
             0o331 => RETI,
             // JP HL
-            0o351 => JP(JumpCondition::Always, JumpLocation::HL),
+            0o351 => JP(JpCond::Always, JpLoc::HL),
             // LD SP, HL
             0o371 => LD(LDTarget::SP, LDSource::HL),
             // JP cond u16
             0o302 | 0o312 | 0o322 | 0o332 => {
-                JP(jump_cond((byte >> 3) & 0x03), JumpLocation::ImmediateWord)
+                JP(jump_cond((byte >> 3) & 0x03), JpLoc::ImmediateWord)
             }
             // LD (0xFF00 + C), A
             0o342 => LD(LDTarget::IoWithC, LDSource::A),
@@ -1642,9 +1645,7 @@ impl Instruction {
             // LD A, (u16)
             0o372 => LD(LDTarget::A, LDSource::IndirectImmediateWord),
             // JP u16
-            0o303 => JP(JumpCondition::Always, JumpLocation::ImmediateWord),
-            // 0xCB Prefix
-            0o313 => unreachable!("{:#04X} should be handled by the prefixed decoder", byte),
+            0o303 => JP(JpCond::Always, JpLoc::ImmediateWord),
             // DI
             0o363 => DI,
             // EI
@@ -1653,12 +1654,14 @@ impl Instruction {
             0o304 | 0o314 | 0o324 | 0o334 => CALL(jump_cond((byte >> 3) & 0x03)),
             // PUSH r16
             0o305 | 0o325 | 0o345 | 0o365 => PUSH(group3((byte >> 4) & 0x03)),
-            0o315 => CALL(JumpCondition::Always),
+            // CALL u16
+            0o315 => CALL(JpCond::Always),
+            // ADD, ADC, SUB, SBC, AND, XOR, OR, and CP
             0o306 | 0o316 | 0o326 | 0o336 | 0o346 | 0o356 | 0o366 | 0o376 => {
                 alu_imm_instr((byte >> 3) & 0x07)
             }
             0o307 | 0o317 | 0o327 | 0o337 | 0o347 | 0o357 | 0o367 | 0o377 => RST(byte & 0b00111000),
-            _ => panic!("{:#04X} is an illegal opcode", byte),
+            _ => Invalid, // 0xCB is 0o313
         }
     }
 
@@ -1681,7 +1684,7 @@ impl Instruction {
 mod jump {
 
     #[derive(Clone, Copy)]
-    pub(crate) enum JumpCondition {
+    pub(crate) enum JpCond {
         Always,
         NotZero,
         Zero,
@@ -1689,9 +1692,9 @@ mod jump {
         Carry,
     }
 
-    impl std::fmt::Debug for JumpCondition {
+    impl std::fmt::Debug for JpCond {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            use JumpCondition::*;
+            use JpCond::*;
 
             match self {
                 Always => f.write_str(""),
@@ -1704,14 +1707,14 @@ mod jump {
     }
 
     #[derive(Clone, Copy)]
-    pub(crate) enum JumpLocation {
+    pub(crate) enum JpLoc {
         HL,
         ImmediateWord,
     }
 
-    impl std::fmt::Debug for JumpLocation {
+    impl std::fmt::Debug for JpLoc {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            use JumpLocation::*;
+            use JpLoc::*;
 
             match *self {
                 HL => f.write_str("HL"),
@@ -1871,7 +1874,7 @@ mod load {
 mod table {
     use super::add::{Source as AddSource, Target as AddTarget};
     use super::alu::Source as AluSource;
-    use super::{Instruction, JumpCondition};
+    use super::{Instruction, JpCond};
     use crate::cpu::{Register as CpuRegister, RegisterPair};
 
     #[derive(Clone, Copy)]
@@ -2070,12 +2073,12 @@ mod table {
             0b101 => L,
             0b110 => IndirectHL,
             0b111 => A,
-            _ => unreachable!("{:#04X} is not a valid Register"),
+            _ => unreachable!("{:#04X} is not a valid Register", code),
         }
     }
 
-    pub(crate) fn jump_cond(code: u8) -> JumpCondition {
-        use JumpCondition::*;
+    pub(crate) fn jump_cond(code: u8) -> JpCond {
+        use JpCond::*;
 
         match code {
             0b00 => NotZero,
@@ -2150,3 +2153,268 @@ mod table {
         }
     }
 }
+
+pub(crate) mod dbg {
+    use std::borrow::Cow;
+
+    use super::add::{Source as AddSource, Target as AddTarget};
+    use super::alu::Source as AluSource;
+    use super::jump::{JpCond, JpLoc};
+    use super::load::{Source as LDSource, Target as LDTarget};
+    use super::{AllRegisters, BusIo, Cpu, Instruction, RegisterPair};
+
+    pub(crate) fn tmp_disasm(cpu: &Cpu, limit: u8) -> String {
+        let mut sm83_asm = String::new();
+        let mut pc = cpu.register_pair(RegisterPair::PC);
+
+        for _ in 0..limit {
+            let opcode = cpu.read_byte(pc);
+            pc += 1;
+
+            let maybe_instr = if opcode == 0xCB {
+                let opcode = cpu.read_byte(pc);
+                pc += 1;
+
+                Instruction::prefixed(opcode)
+            } else {
+                Instruction::unprefixed(opcode)
+            };
+
+            match maybe_instr {
+                Instruction::Invalid => {}
+                instr => {
+                    let asm = format!("{:04X} {:?}\n", pc - 1, instr);
+                    sm83_asm.push_str(&asm);
+                    pc += delta::pc_inc_count(instr)
+                }
+            }
+        }
+
+        sm83_asm
+    }
+
+    pub(crate) fn new_disasm(cpu: &Cpu, limit: u8) -> String {
+        let mut assembly = String::new();
+        let mut pc = cpu.register_pair(RegisterPair::PC);
+
+        for _ in 0..limit {
+            let opcode = cpu.read_byte(pc);
+            pc += 1;
+
+            let maybe_instr = if opcode == 0xCB {
+                let opcode = cpu.read_byte(pc);
+                pc += 1;
+
+                Instruction::prefixed(opcode)
+            } else {
+                Instruction::unprefixed(opcode)
+            };
+
+            match maybe_instr {
+                Instruction::Invalid => {}
+                instr => {
+                    let output = format!("${:04X} {}\n", pc - 1, disasm(cpu, pc, instr));
+                    assembly.push_str(&output);
+                    pc += delta::pc_inc_count(instr);
+                }
+            }
+        }
+
+        assembly
+    }
+
+    // TODO: It might be better if I pass in a mutable writer instead of usnig a String
+    fn disasm(cpu: &Cpu, pc: u16, instr: Instruction) -> Cow<str> {
+        use Instruction::*;
+
+        let imm_byte = cpu.read_byte(pc + 1);
+        let imm_word = (cpu.read_byte(pc + 2) as u16) << 8 | imm_byte as u16;
+
+        match instr {
+            // Unprefixed Instructions
+            NOP => "NOP".into(),
+            LD(LDTarget::IndirectImmediateWord, LDSource::SP) => {
+                format!("LD ({:#06X}), SP", imm_word).into()
+            }
+            STOP => "STOP".into(),
+            JR(JpCond::Always) => format!("JR {}", imm_byte as i8).into(),
+            JR(cond) => format!("JR {:?} {}", cond, imm_byte as i8).into(),
+            LD(LDTarget::Group1(rp), LDSource::ImmediateWord) => {
+                format!("LD {:?} {:#06X}", rp, imm_word).into()
+            }
+            ADD(AddTarget::HL, AddSource::Group1(rp)) => format!("ADD HL, {:?}", rp).into(),
+            LD(LDTarget::IndirectGroup2(rp), LDSource::A) => format!("LD ({:?}), A", rp).into(),
+            LD(LDTarget::A, LDSource::IndirectGroup2(rp)) => format!("LD A, ({:?})", rp).into(),
+            INC(AllRegisters::Group1(rp)) => format!("INC {:?}", rp).into(),
+            DEC(AllRegisters::Group1(rp)) => format!("DEC {:?}", rp).into(),
+            INC(AllRegisters::Register(reg)) => format!("INC {:?}", reg).into(),
+            DEC(AllRegisters::Register(reg)) => format!("DEC {:?}", reg).into(),
+            LD(LDTarget::Register(reg), LDSource::ImmediateByte) => {
+                format!("LD {:?}, {:#04X}", reg, imm_byte).into()
+            }
+            RLCA => "RLCA".into(),
+            RRCA => "RRCA".into(),
+            RLA => "RLA".into(),
+            RRA => "RRA".into(),
+            DAA => "DAA".into(),
+            CPL => "CPL".into(),
+            SCF => "SCF".into(),
+            CCF => "CCF".into(),
+            HALT => "HALT".into(),
+            LD(LDTarget::Register(left), LDSource::Register(right)) => {
+                format!("LD {:?}, {:?}", left, right).into()
+            }
+            ADD(AddTarget::A, AddSource::Register(reg)) => format!("ADD A, {:?}", reg).into(),
+            ADC(AluSource::Register(reg)) => format!("ADC {:?}", reg).into(),
+            SUB(AluSource::Register(reg)) => format!("SUB {:?}", reg).into(),
+            SBC(AluSource::Register(reg)) => format!("SBC {:?}", reg).into(),
+            AND(AluSource::Register(reg)) => format!("AND {:?}", reg).into(),
+            XOR(AluSource::Register(reg)) => format!("XOR {:?}", reg).into(),
+            OR(AluSource::Register(reg)) => format!("OR {:?}", reg).into(),
+            CP(AluSource::Register(reg)) => format!("CP {:?}", reg).into(),
+            RET(JpCond::Always) => "RET".into(),
+            RET(cond) => format!("RET {:?}", cond).into(),
+            LD(LDTarget::IoWithImmediateOffset, LDSource::A) => {
+                format!("LD ({:#06X}) , A", 0xFF00 + imm_byte as u16).into()
+            }
+            ADD(AddTarget::SP, AddSource::ImmediateSignedByte) => {
+                format!("ADD SP, {}", imm_byte as i8).into()
+            }
+            LD(LDTarget::A, LDSource::IoWithImmediateOffset) => {
+                format!("LD A, ({:#06X})", 0xFF00 + imm_byte as u16).into()
+            }
+            LDHL => format!("LD HL, SP + {}", imm_byte as i8).into(),
+            POP(rp) => format!("POP {:?}", rp).into(),
+            RETI => "RETI".into(),
+            JP(JpCond::Always, JpLoc::HL) => "JP HL".into(),
+            LD(LDTarget::SP, LDSource::HL) => "LD SP, HL".into(),
+            JP(JpCond::Always, JpLoc::ImmediateWord) => format!("JP {:#06X}", imm_word).into(),
+            JP(cond, JpLoc::ImmediateWord) => format!("JP {:?} {:#06X}", cond, imm_word).into(),
+            LD(LDTarget::IoWithC, LDSource::A) => "LD (0xFF00 + C), A".into(),
+            LD(LDTarget::IndirectImmediateWord, LDSource::A) => {
+                format!("LD ({:#06X}), A", imm_byte).into()
+            }
+            LD(LDTarget::A, LDSource::IoWithC) => "LD A, (0xFF00 + C)".into(),
+            LD(LDTarget::A, LDSource::IndirectImmediateWord) => {
+                format!("LD A, ({:#06X})", imm_word).into()
+            }
+            DI => "DI".into(),
+            EI => "EI".into(),
+            CALL(cond) => format!("CALL {:?} {:#06X}", cond, imm_word).into(),
+            PUSH(rp) => format!("PUSH {:?}", rp).into(),
+            ADD(AddTarget::A, AddSource::ImmediateByte) => {
+                format!("ADD A, {:#04X}", imm_byte).into()
+            }
+            ADC(AluSource::ImmediateByte) => format!("ADC {:#04X}", imm_byte).into(),
+            SUB(AluSource::ImmediateByte) => format!("SUB {:#04X}", imm_byte).into(),
+            SBC(AluSource::ImmediateByte) => format!("SBC {:#04X}", imm_byte).into(),
+            AND(AluSource::ImmediateByte) => format!("AND {:#04X}", imm_byte).into(),
+            XOR(AluSource::ImmediateByte) => format!("XOR {:#04X}", imm_byte).into(),
+            OR(AluSource::ImmediateByte) => format!("OR {:#04X}", imm_byte).into(),
+            CP(AluSource::ImmediateByte) => format!("CP {:#04X}", imm_byte).into(),
+            RST(v) => format!("RST {:#04X}", v).into(),
+
+            // Prefixed Instructions
+            RLC(reg) => format!("RLC {:?}", reg).into(),
+            RRC(reg) => format!("RRC {:?}", reg).into(),
+            RL(reg) => format!("RL {:?}", reg).into(),
+            RR(reg) => format!("RR {:?}", reg).into(),
+            SLA(reg) => format!("SLA {:?}", reg).into(),
+            SRA(reg) => format!("SRA {:?}", reg).into(),
+            SWAP(reg) => format!("SWAP {:?}", reg).into(),
+            SRL(reg) => format!("SRL {:?}", reg).into(),
+            BIT(bit, reg) => format!("BIT {}, {:?}", bit, reg).into(),
+            RES(bit, reg) => format!("RES {}, {:?}", bit, reg).into(),
+            SET(bit, reg) => format!("SET {}, {:?}", bit, reg).into(),
+            _ => unreachable!("{:?} is an illegal instruction", instr),
+        }
+    }
+
+    mod delta {
+        use super::super::add::{Source as AddSource, Target as AddTarget};
+        use super::super::alu::Source as AluSource;
+        use super::super::jump::{JpCond, JpLoc};
+        use super::super::load::{Source as LDSource, Target as LDTarget};
+        use super::super::{AllRegisters, Instruction};
+
+        pub(super) fn pc_inc_count(instr: Instruction) -> u16 {
+            use Instruction::*;
+
+            match instr {
+                // Unprefixed
+                NOP => 0,
+                LD(LDTarget::IndirectImmediateWord, LDSource::SP) => 2,
+                STOP => 0,
+                JR(_) => 1,
+                LD(LDTarget::Group1(_), LDSource::ImmediateWord) => 2,
+                ADD(AddTarget::HL, AddSource::Group1(_)) => 0,
+                LD(LDTarget::IndirectGroup2(_), LDSource::A) => 0,
+                LD(LDTarget::A, LDSource::IndirectGroup2(_)) => 0,
+                INC(AllRegisters::Group1(_)) => 0,
+                DEC(AllRegisters::Group1(_)) => 0,
+                INC(AllRegisters::Register(_)) => 0,
+                DEC(AllRegisters::Register(_)) => 0,
+                LD(LDTarget::Register(_), LDSource::ImmediateByte) => 1,
+                RLCA => 0,
+                RRCA => 0,
+                RLA => 0,
+                RRA => 0,
+                DAA => 0,
+                CPL => 0,
+                SCF => 0,
+                CCF => 0,
+                HALT => 0,
+                LD(LDTarget::Register(_), LDSource::Register(_)) => 0,
+                ADD(AddTarget::A, AddSource::Register(_)) => 0,
+                ADC(AluSource::Register(_)) => 0,
+                SUB(AluSource::Register(_)) => 0,
+                SBC(AluSource::Register(_)) => 0,
+                AND(AluSource::Register(_)) => 0,
+                XOR(AluSource::Register(_)) => 0,
+                OR(AluSource::Register(_)) => 0,
+                CP(AluSource::Register(_)) => 0,
+                RET(_) => 0,
+                LD(LDTarget::IoWithImmediateOffset, LDSource::A) => 1,
+                ADD(AddTarget::SP, AddSource::ImmediateSignedByte) => 1,
+                LD(LDTarget::A, LDSource::IoWithImmediateOffset) => 1,
+                LDHL => 1,
+                POP(_) => 0,
+                RETI => 0,
+                JP(JpCond::Always, JpLoc::HL) => 0,
+                LD(LDTarget::SP, LDSource::HL) => 0,
+                JP(_, JpLoc::ImmediateWord) => 2,
+                LD(LDTarget::IoWithC, LDSource::A) => 0,
+                LD(LDTarget::IndirectImmediateWord, LDSource::A) => 2,
+                LD(LDTarget::A, LDSource::IoWithC) => 0,
+                LD(LDTarget::A, LDSource::IndirectImmediateWord) => 2,
+                DI => 0,
+                EI => 0,
+                CALL(_) => 0,
+                PUSH(_) => 0,
+                ADD(AddTarget::A, AddSource::ImmediateByte) => 1,
+                ADC(AluSource::ImmediateByte) => 1,
+                SUB(AluSource::ImmediateByte) => 1,
+                SBC(AluSource::ImmediateByte) => 1,
+                AND(AluSource::ImmediateByte) => 1,
+                XOR(AluSource::ImmediateByte) => 1,
+                OR(AluSource::ImmediateByte) => 1,
+                CP(AluSource::ImmediateByte) => 1,
+                RST(_) => 0,
+
+                // Prefixed
+                RLC(_) => 0,
+                RRC(_) => 0,
+                RL(_) => 0,
+                RR(_) => 0,
+                SLA(_) => 0,
+                SRA(_) => 0,
+                SWAP(_) => 0,
+                SRL(_) => 0,
+                BIT(_, _) => 0,
+                RES(_, _) => 0,
+                SET(_, _) => 0,
+                _ => unreachable!("{:?} is an illegal instruction", instr),
+            }
+        }
+    }
+}

src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::derivable_impls)] // Will remove this if bitfield-rs allows default impls
+
 pub use apu::gen::init as spsc_init;
 pub type Cycle = u64;
 

src/main.rs

@@ -1,38 +1,28 @@
+use std::path::PathBuf;
 use std::time::Instant;
 
-use clap::{crate_authors, crate_description, crate_name, crate_version, App, Arg};
-use egui_wgpu_backend::RenderPass;
-use gb::emu;
-use gb::gui::GuiState;
+use clap::{arg, command, value_parser};
+use gb::gui::{EmuMode, Gui};
+use gb::{emu, gui};
 use gilrs::Gilrs;
 use rodio::{OutputStream, Sink};
 use tracing_subscriber::EnvFilter;
 use winit::event::{Event, WindowEvent};
-use winit::event_loop::EventLoop;
+use winit::event_loop::{EventLoop, EventLoopBuilder};
 
 const AUDIO_ENABLED: bool = true;
 
 fn main() {
-    let app = App::new(crate_name!())
-        .version(crate_version!())
-        .author(crate_authors!())
-        .about(crate_description!());
-
-    let m = app
+    let m = command!()
         .arg(
-            Arg::with_name("rom")
-                .value_name("ROM_FILE")
-                .takes_value(true)
-                .index(1)
-                .help("Path to the Game ROM"),
+            arg!(-b --boot <FILE> "path to boot ROM")
+                .required(false)
+                .value_parser(value_parser!(PathBuf)),
         )
         .arg(
-            Arg::with_name("boot")
-                .short("b")
-                .long("boot")
-                .value_name("FILE")
-                .takes_value(true)
-                .help("Path to Boot ROM"),
+            arg!([ROM_FILE] "path to game ROM")
+                .required(true)
+                .value_parser(value_parser!(PathBuf)),
         )
         .get_matches();
 
@@ -45,25 +35,8 @@ fn main() {
         .with_env_filter(EnvFilter::from_default_env())
         .init();
 
-    // --Here lies a lot of Winit + WGPU Boilerplate--
-    let event_loop: EventLoop<Event<()>> = EventLoop::with_user_event();
-    let window = gb::gui::build_window(&event_loop).expect("build window");
-
-    let (instance, surface) = gb::gui::create_surface(&window);
-    let adapter = gb::gui::request_adapter(&instance, &surface).expect("request adaptor");
-    let (device, queue) = gb::gui::request_device(&adapter).expect("request device");
-    let format = surface
-        .get_preferred_format(&adapter)
-        .expect("get surface format");
-
-    let mut config = gb::gui::surface_config(&window, format);
-    surface.configure(&device, &config);
-    let mut platform = gb::gui::platform_desc(&window);
-    let mut render_pass = RenderPass::new(&device, format, 1);
-
-    // We interrupt your boiler plate to initialize the emulator so that
-    // we can copy it's empty pixel buffer to the GPU
-    let mut cpu = match m.value_of("boot") {
+    // Init CPU
+    let mut cpu = match m.get_one::<PathBuf>("boot") {
         Some(path) => {
             tracing::info!("User-provided boot ROM");
             emu::from_boot_rom(path).expect("initialize emulator with custom boot rom")
@@ -74,20 +47,12 @@ fn main() {
         }
     };
 
-    // Set up the WGPU (and then EGUI) texture we'll be working with.
-    let texture_size = gb::gui::texture_size();
-    let texture = gb::gui::create_texture(&device, texture_size);
-    gb::gui::write_to_texture(&queue, &texture, gb::emu::pixel_buf(&cpu), texture_size);
-    let texture_id = gb::gui::expose_texture_to_egui(&mut render_pass, &device, &texture);
-
     // Load ROM if filepath was provided
-    if let Some(path) = m.value_of("rom") {
+    if let Some(path) = m.get_one::<PathBuf>("ROM_FILE") {
         tracing::info!("User-provided cartridge ROM");
         emu::read_game_rom(&mut cpu, path).expect("read game rom from path");
     }
-
     emu::load_save(&mut cpu);
-
     let rom_title = emu::rom_title(&cpu).to_string();
 
     tracing::info!("Initialize Gamepad");
@@ -114,80 +79,44 @@ fn main() {
     }
 
     // Set up state for the Immediate-mode GUI
-    let mut app = GuiState::new(rom_title);
-    let mut last_key = gb::gui::unused_key();
+    let event_loop: EventLoop<Event<()>> = EventLoopBuilder::with_user_event().build();
+
+    let mut app = Gui::new(rom_title, &event_loop, &cpu);
+    let mut last_key = gui::unused_key(); // TODO: Fix this awful impl
 
     // used for egui animations
     let start_time = Instant::now();
 
     event_loop.run(move |event, _, control_flow| {
-        platform.handle_event(&event);
+        app.handle_event(&event);
 
         match event {
             Event::MainEventsCleared => {
-                if app.quit {
-                    emu::save_and_exit(&cpu, control_flow);
-                }
+                app.maybe_quit(&cpu, control_flow);
 
-                gb::emu::run_frame(&mut cpu, &mut gamepad, last_key);
+                match app.mode {
+                    EmuMode::Running => emu::run_frame(&mut cpu, &mut gamepad, last_key),
+                    EmuMode::StepFrame if gui::kbd::space_released(&last_key) => {
+                        emu::run_frame(&mut cpu, &mut gamepad, last_key)
+                    }
+                    EmuMode::Step if gui::kbd::space_released(&last_key) => {
+                        emu::run(&mut cpu, &mut gamepad, last_key, 4);
+                    }
+                    _ => {}
+                };
 
-                window.request_redraw();
+                // Input has been consumed, reset it
+                last_key = gui::unused_key();
+
+                app.request_redraw();
             }
             Event::RedrawRequested(..) => {
-                platform.update_time(start_time.elapsed().as_secs_f64());
-
-                let data = gb::emu::pixel_buf(&cpu);
-                gb::gui::write_to_texture(&queue, &texture, data, texture_size);
-
-                let output_frame = match surface.get_current_texture() {
-                    Ok(frame) => frame,
-                    Err(e) => {
-                        eprintln!("Dropped frame with error: {}", e);
-                        return;
-                    }
-                };
-                let output_view = gb::gui::create_view(&output_frame);
-
-                // Begin to draw Egui components
-                platform.begin_frame();
-                gb::gui::draw_egui(&mut app, &platform.context(), texture_id);
-                // End the UI frame. We could now handle the output and draw the UI with the backend.
-                let (_, paint_commands) = platform.end_frame(Some(&window));
-                let paint_jobs = platform.context().tessellate(paint_commands);
-
-                let mut encoder = gb::gui::create_command_encoder(&device);
-                let screen_descriptor = gb::gui::create_screen_descriptor(&window, &config);
-
-                // Upload all resources for the GPU.
-                render_pass.update_texture(&device, &queue, &platform.context().texture());
-                render_pass.update_user_textures(&device, &queue);
-                render_pass.update_buffers(&device, &queue, &paint_jobs, &screen_descriptor);
-
-                // Record all render passes.
-                gb::gui::execute_render_pass(
-                    &mut render_pass,
-                    &mut encoder,
-                    &output_view,
-                    paint_jobs,
-                    &screen_descriptor,
-                )
-                .expect("record render passes");
-
-                // Submit the commands.
-                queue.submit(std::iter::once(encoder.finish()));
-
-                // Redraw egui
-                output_frame.present();
+                app.update_time(start_time.elapsed().as_secs_f64());
+                app.paint(&cpu);
             }
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::Resized(size) => {
-                    config.width = size.width;
-                    config.height = size.height;
-                    surface.configure(&device, &config);
-                }
-                WindowEvent::CloseRequested => {
-                    emu::save_and_exit(&cpu, control_flow);
-                }
+                WindowEvent::Resized(size) => app.resize(size),
+                WindowEvent::CloseRequested => emu::save_and_exit(&cpu, control_flow),
                 WindowEvent::KeyboardInput { input, .. } => last_key = input,
                 _ => {}
             },

src/ppu.rs

@@ -10,6 +10,8 @@ use types::{
     ObjectPaletteKind, ObjectSize, Pixels, RenderPriority, TileDataAddress,
 };
 
+use once_cell::sync::Lazy;
+
 mod dma;
 mod types;
 
@@ -32,6 +34,14 @@ const LIGHT_GRAY: [u8; 4] = 0xAEBA89FFu32.to_be_bytes();
 const DARK_GRAY: [u8; 4] = 0x5E6745FFu32.to_be_bytes();
 const BLACK: [u8; 4] = 0x202020FFu32.to_be_bytes();
 
+static BLANK_SCREEN: Lazy<Box<[u8; (GB_WIDTH * 4) * GB_HEIGHT]>> = Lazy::new(|| {
+    WHITE
+        .repeat(GB_WIDTH * GB_HEIGHT)
+        .into_boxed_slice()
+        .try_into()
+        .unwrap()
+});
+
 #[derive(Debug)]
 pub struct Ppu {
     pub(crate) int: Interrupt,
@@ -48,7 +58,7 @@ pub struct Ppu {
     fetch: PixelFetcher,
     fifo: PixelFifo,
     obj_buffer: ObjectBuffer,
-    pub(crate) frame_buf: Box<[u8; GB_WIDTH * GB_HEIGHT * 4]>,
+    pub(crate) frame_buf: FrameBuffer,
     win_stat: WindowStatus,
 
     scanline_start: bool,
@@ -70,15 +80,26 @@ impl BusIo for Ppu {
 
 impl Ppu {
     pub(crate) fn tick(&mut self) {
-        self.dot += 1;
-
         if !self.ctrl.lcd_enabled() {
+            if self.dot > 0 {
+                // Check ensures this expensive operation only happens once
+                self.frame_buf
+                    .get_mut(Device::Guest)
+                    .copy_from_slice(BLANK_SCREEN.as_ref());
+            }
+
+            self.stat.set_mode(PpuMode::HBlank);
+            self.pos.line_y = 0;
+            self.dot = 0;
             return;
         }
 
+        self.dot += 1;
+
         match self.stat.mode() {
             PpuMode::OamScan => {
                 // Cycles 1 -> 80
+
                 if self.dot >= 80 {
                     self.x_pos = 0;
                     self.scanline_start = true;
@@ -104,12 +125,7 @@ impl Ppu {
                 self.scan_oam();
             }
             PpuMode::Drawing => {
-                if self.ctrl.lcd_enabled() {
-                    // Only Draw when the LCD Is Enabled
-                    self.draw();
-                } else {
-                    self.reset();
-                }
+                self.draw();
 
                 if self.x_pos == 160 {
                     if self.stat.hblank_int() {
@@ -164,6 +180,9 @@ impl Ppu {
                             self.int.set_lcd_stat(true);
                         }
 
+                        // Screen is done drawing
+                        self.frame_buf.swap();
+
                         PpuMode::VBlank
                     } else {
                         if self.stat.oam_int() {
@@ -265,7 +284,7 @@ impl Ppu {
                 TileLowB => {
                     let obj_size = self.ctrl.obj_size();
 
-                    let addr = PixelFetcher::get_obj_addr(attr, &self.pos, obj_size);
+                    let addr = PixelFetcher::obj_addr(attr, &self.pos, obj_size);
 
                     let byte = self.read_byte(addr);
                     self.fetch.obj.tile.with_low(byte);
@@ -276,7 +295,7 @@ impl Ppu {
                 TileHighB => {
                     let obj_size = self.ctrl.obj_size();
 
-                    let addr = PixelFetcher::get_obj_addr(attr, &self.pos, obj_size);
+                    let addr = PixelFetcher::obj_addr(attr, &self.pos, obj_size);
 
                     let byte = self.read_byte(addr + 1);
                     self.fetch.obj.tile.with_high(byte);
@@ -397,8 +416,8 @@ impl Ppu {
                 let x = self.x_pos as usize;
 
                 let i = (GB_WIDTH * 4) * y + (x * 4);
-                self.frame_buf[i..(i + rgba.len())].copy_from_slice(&rgba);
 
+                self.frame_buf.get_mut(Device::Guest)[i..(i + rgba.len())].copy_from_slice(&rgba);
                 self.x_pos += 1;
             }
 
@@ -415,14 +434,6 @@ impl Ppu {
         }
     }
 
-    fn reset(&mut self) {
-        self.pos.line_y = 0;
-        self.stat.set_mode(PpuMode::HBlank);
-
-        let mut blank = WHITE.repeat(self.frame_buf.len() / 4);
-        self.frame_buf.swap_with_slice(&mut blank);
-    }
-
     fn clock_fifo(&mut self) -> Option<GrayShade> {
         use RenderPriority::*;
 
@@ -441,7 +452,7 @@ impl Ppu {
 
     fn obj_pixel(&self, obj: ObjPixelProperty) -> GrayShade {
         use ObjectPaletteKind::*;
-        assert!(obj.shade_id != 0);
+        assert_ne!(obj.shade_id, 0);
 
         let p0 = &self.monochrome.obj_palette_0;
         let p1 = &self.monochrome.obj_palette_1;
@@ -468,7 +479,7 @@ impl Default for Ppu {
         Self {
             vram: Box::new([0u8; VRAM_SIZE]),
             dot: Default::default(),
-            frame_buf: Box::new([0; GB_WIDTH * GB_HEIGHT * 4]),
+            frame_buf: FrameBuffer::new().expect("create frame buffers"),
             int: Default::default(),
             ctrl: LCDControl(0),
             monochrome: Default::default(),
@@ -683,7 +694,7 @@ impl PixelFetcher {
         Ok(())
     }
 
-    fn get_obj_addr(attr: &ObjectAttr, pos: &ScreenPosition, size: ObjectSize) -> u16 {
+    fn obj_addr(attr: &ObjectAttr, pos: &ScreenPosition, size: ObjectSize) -> u16 {
         let line_y = pos.line_y;
 
         // TODO: Why is the offset 14 and 30 respectively?
@@ -797,21 +808,12 @@ impl Default for BackgroundFetcher {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 struct ObjectFetcher {
     state: FetcherState,
     tile: TileBuilder,
 }
 
-impl Default for ObjectFetcher {
-    fn default() -> Self {
-        Self {
-            state: Default::default(),
-            tile: Default::default(),
-        }
-    }
-}
-
 impl Fetcher for ObjectFetcher {
     fn reset(&mut self) {
         self.state = Default::default();
@@ -919,3 +921,96 @@ struct WindowStatus {
     /// drawing from the window tile map is true
     enabled: bool,
 }
+
+pub(crate) mod dbg {
+    use super::{Ppu, PpuMode};
+    use crate::Cycle;
+
+    pub(crate) fn ly(ppu: &Ppu) -> u8 {
+        ppu.pos.line_y
+    }
+
+    pub(crate) fn scx(ppu: &Ppu) -> u8 {
+        ppu.pos.scroll_x
+    }
+
+    pub(crate) fn scy(ppu: &Ppu) -> u8 {
+        ppu.pos.scroll_y
+    }
+
+    pub(crate) fn mode(ppu: &Ppu) -> PpuMode {
+        ppu.stat.mode()
+    }
+
+    pub(crate) fn wx(ppu: &Ppu) -> i16 {
+        ppu.pos.window_x as i16
+    }
+
+    pub(crate) fn wy(ppu: &Ppu) -> i16 {
+        ppu.pos.window_y as i16
+    }
+
+    pub(crate) fn dot(ppu: &Ppu) -> Cycle {
+        ppu.dot
+    }
+}
+
+#[derive(Debug)]
+pub struct FrameBuffer {
+    buf: [Box<[u8; Self::FRAME_LEN]>; 2],
+    current: bool,
+}
+
+#[derive(PartialEq)]
+pub enum Device {
+    Guest,
+    Host,
+}
+
+impl FrameBuffer {
+    const FRAME_LEN: usize = GB_WIDTH * std::mem::size_of::<u32>() * GB_HEIGHT;
+
+    pub fn new() -> Result<Self, FrameBufferError> {
+        Ok(Self {
+            buf: [
+                vec![0; Self::FRAME_LEN]
+                    .into_boxed_slice()
+                    .try_into()
+                    .map_err(|_| FrameBufferError::TryFrom)?,
+                vec![0; Self::FRAME_LEN]
+                    .into_boxed_slice()
+                    .try_into()
+                    .map_err(|_| FrameBufferError::TryFrom)?,
+            ],
+            current: false,
+        })
+    }
+
+    pub fn swap(&mut self) {
+        self.current = !self.current;
+    }
+
+    pub fn get_mut(&mut self, device: Device) -> &mut [u8; Self::FRAME_LEN] {
+        let idx = match device {
+            Device::Guest => self.current,
+            Device::Host => !self.current,
+        };
+
+        &mut *self.buf[idx as usize]
+    }
+
+    pub fn get(&self, device: Device) -> &[u8; Self::FRAME_LEN] {
+        let idx = match device {
+            Device::Guest => self.current,
+            Device::Host => !self.current,
+        };
+
+        &*self.buf[idx as usize]
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum FrameBufferError {
+    #[error("Failed to coerce boxed slice to boxed array")]
+    TryFrom,
+}

src/ppu/types.rs

@@ -335,7 +335,7 @@ impl From<ObjectPaletteKind> for u8 {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum RenderPriority {
     Object = 0,
     BackgroundAndWindow = 1,

src/scheduler.rs

@@ -1,79 +0,0 @@
-use crate::Cycle;
-use std::collections::BinaryHeap;
-
-#[derive(Debug)]
-pub(crate) struct Scheduler {
-    timestamp: Cycle,
-    queue: BinaryHeap<Event>,
-}
-
-impl Scheduler {
-    pub(crate) fn init() -> Self {
-        let mut scheduler = Self {
-            timestamp: Default::default(),
-            queue: Default::default(),
-        };
-
-        scheduler.push(Event {
-            kind: EventKind::TimestampOverflow,
-            timestamp: Cycle::MAX,
-            cb: |_delay| panic!("Reached Cycle::MAX"),
-        });
-
-        scheduler
-    }
-
-    pub(crate) fn push(&mut self, event: Event) {
-        self.queue.push(event);
-    }
-
-    pub(crate) fn step(&mut self, cycles: Cycle) {
-        self.timestamp += cycles;
-
-        loop {
-            let should_pop = match self.queue.peek() {
-                Some(event) => self.timestamp >= event.timestamp,
-                None => false,
-            };
-
-            if !should_pop {
-                break;
-            }
-
-            let event = self.queue.pop().expect("Pop Event from Scheduler Queue");
-
-            (event.cb)(self.timestamp - event.timestamp);
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Event {
-    kind: EventKind,
-    cb: fn(Cycle),
-    pub(crate) timestamp: Cycle,
-}
-
-impl Eq for Event {}
-impl PartialEq for Event {
-    fn eq(&self, other: &Self) -> bool {
-        self.kind == other.kind && self.timestamp == other.timestamp
-    }
-}
-
-impl PartialOrd for Event {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Event {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.timestamp.cmp(&other.timestamp)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum EventKind {
-    TimestampOverflow,
-}

src/work_ram.rs

@@ -11,13 +11,13 @@ pub(crate) struct WorkRam {
 }
 
 impl BusIo for WorkRam {
-    fn write_byte(&mut self, addr: u16, byte: u8) {
-        self.bank[addr as usize - WORK_RAM_START_ADDRESS] = byte;
-    }
-
     fn read_byte(&self, addr: u16) -> u8 {
         self.bank[addr as usize - WORK_RAM_START_ADDRESS]
     }
+
+    fn write_byte(&mut self, addr: u16, byte: u8) {
+        self.bank[addr as usize - WORK_RAM_START_ADDRESS] = byte;
+    }
 }
 
 impl Default for WorkRam {
@@ -42,11 +42,11 @@ impl Default for VariableWorkRam {
 }
 
 impl BusIo for VariableWorkRam {
-    fn write_byte(&mut self, addr: u16, byte: u8) {
-        self.buf[addr as usize - VARIABLE_WORK_RAM_START_ADDRESS] = byte;
-    }
-
     fn read_byte(&self, addr: u16) -> u8 {
         self.buf[addr as usize - VARIABLE_WORK_RAM_START_ADDRESS]
     }
+
+    fn write_byte(&mut self, addr: u16, byte: u8) {
+        self.buf[addr as usize - VARIABLE_WORK_RAM_START_ADDRESS] = byte;
+    }
 }