Fmt and clean up

Author: RaoulLuque

src/interrupts.rs

@@ -138,19 +138,6 @@ impl InterruptEnableRegister {
         let interrupt_enable = InterruptEnableRegister::get_interrupt_enable_register(memory_bus);
         interrupt.is_set(interrupt_enable)
     }
-
-    /// Sets the value of the provided [Interrupt] in the interrupt enable register to the provided
-    /// value.
-    pub fn set_flag(memory_bus: &mut MemoryBus, interrupt: Interrupt, value: bool) {
-        let mut interrupt_enable =
-            InterruptEnableRegister::get_interrupt_enable_register(memory_bus);
-        interrupt_enable = if value {
-            interrupt.set(interrupt_enable)
-        } else {
-            interrupt.clear(interrupt_enable)
-        };
-        InterruptEnableRegister::set_interrupt_enable_register(memory_bus, interrupt_enable);
-    }
 }
 
 impl InterruptFlagRegister {

src/lib.rs

@@ -104,7 +104,7 @@ impl RustBoy {
     pub fn new_before_boot(debugging_flags: DebugInfo) -> RustBoy {
         RustBoy {
             memory_bus: MemoryBus::new_before_boot(&debugging_flags),
-            ppu: PPU::new_empty(&debugging_flags),
+            ppu: PPU::new_empty(),
             timer_info: TimerInfo::new(),
             cpu: CPU::new_before_boot_rom(debugging_flags),
         }

src/ppu.rs

@@ -3,11 +3,10 @@ pub(crate) mod object_handling;
 pub mod registers;
 pub(crate) mod tile_handling;
 
+use crate::MemoryBus;
 use crate::cpu::is_bit_set;
-use crate::debugging::{DebugInfo, DebuggingFlagsWithoutFileHandles};
 use crate::interrupts::{Interrupt, InterruptFlagRegister};
 use crate::ppu::registers::LCDCRegister;
-use crate::MemoryBus;
 use information_for_shader::BuffersForRendering;
 use registers::PPURegisters;
 
@@ -45,7 +44,6 @@ pub(crate) const PPU_MODE_WHILE_LCD_TURNED_OFF: RenderingMode = RenderingMode::H
 pub struct PPU {
     pub(crate) rendering_info: RenderingInfo,
     pub(crate) buffers_for_rendering: BuffersForRendering,
-    pub ppu_registers: PPURegisters,
 }
 
 /// Struct to collect the information about the current rendering state of the GPU.
@@ -291,13 +289,10 @@ impl PPU {
     /// The lcd_was_turned_off flag is set to
     /// true, so the GPU starts off in HBlank mode instead of OAMScan, which is the supposed
     /// behavior after the LCD was turned on (for the first time or after being turned off).
-    pub fn new_empty(debugging_flags: &DebugInfo) -> Self {
-        let debugging_flags =
-            DebuggingFlagsWithoutFileHandles::from_debugging_flags(debugging_flags);
+    pub fn new_empty() -> Self {
         Self {
             rendering_info: RenderingInfo::new_initial_state(),
             buffers_for_rendering: BuffersForRendering::new_empty(),
-            ppu_registers: PPURegisters::new(debugging_flags),
         }
     }
 }

src/ppu/registers.rs

@@ -1,11 +1,8 @@
-use super::{
-    PPU, PPU_MODE_WHILE_LCD_TURNED_OFF, RenderingMode,
-};
+use super::{PPU, PPU_MODE_WHILE_LCD_TURNED_OFF, RenderingMode};
 use crate::cpu::{clear_bit, is_bit_set, set_bit};
 
-use crate::debugging::DebuggingFlagsWithoutFileHandles;
-use crate::interrupts::{Interrupt, InterruptFlagRegister};
 use crate::MemoryBus;
+use crate::interrupts::{Interrupt, InterruptFlagRegister};
 
 // Addresses of the GPU registers
 const LCDC_REGISTER_ADDRESS: usize = 0xFF40;
@@ -37,7 +34,7 @@ const LYC_INT_SELECT_BIT_POSITION: usize = 6;
 /// Represents the registers that control the GPU.
 ///
 /// This struct is empty and has no fields. Instead it is just used to group the GPU registers and make
-/// the interface nicer. The actual data of the registers is held in the [MemoryBus](crate::MemoryBus).
+/// the interface nicer. The actual data of the registers is held in the [MemoryBus](MemoryBus).
 ///
 /// TODO: Explain static function setup
 ///
@@ -53,12 +50,10 @@ const LYC_INT_SELECT_BIT_POSITION: usize = 6;
 /// - 0xFF49: OBP1 - Object Palette 1 Data Register
 /// - 0xFF4A: WY - Window Y Position Register
 /// - 0xFF4B: WX - Window X Position Register
-pub struct PPURegisters {
-    pub(super) debugging_flags: DebuggingFlagsWithoutFileHandles,
-}
+pub struct PPURegisters {}
 
 /// Represents the LCDC register of the GPU. This struct is empty and has no fields. Instead, it is
-/// just used to make the interface nicer and the actual register is held in the [MemoryBus](crate::MemoryBus).
+/// just used to make the interface nicer and the actual register is held in the [MemoryBus](MemoryBus).
 ///
 /// TODO: Explain static function setup
 ///
@@ -75,7 +70,7 @@ pub struct PPURegisters {
 pub struct LCDCRegister {}
 
 /// Represents the LCD status register of the GPU. This struct is empty and has no fields. Instead, it is
-/// just used to make the interface nicer and the actual register is held in the [MemoryBus](crate::MemoryBus).
+/// just used to make the interface nicer and the actual register is held in the [MemoryBus](MemoryBus).
 ///
 /// TODO: Explain static function setup
 ///
@@ -136,12 +131,6 @@ impl PPU {
 }
 
 impl PPURegisters {
-    /// Creates a new instance of the GPURegisters struct with all registers set to their default
-    /// startup values.
-    pub fn new(debugging_flags: DebuggingFlagsWithoutFileHandles) -> Self {
-        Self { debugging_flags }
-    }
-
     /// Set the LCD Control register to the provided value.
     ///
     /// Also sets flags in the provided [super::ChangesToPropagateToShader] struct, to keep track of which parts
@@ -457,7 +446,7 @@ impl LCDCRegister {
 }
 
 impl LCDStatusRegister {
-    /// Returns the GPU mode as a [super::RenderingMode] enum.
+    /// Returns the GPU mode as a [RenderingMode] enum.
     fn get_ppu_mode(memory_bus: &MemoryBus) -> RenderingMode {
         RenderingMode::from_u8(memory_bus.memory[LCD_STATUS_REGISTER_ADDRESS] & 0b0000_0011)
     }