From 70e0b5868d8ab473503594bb68d2a68dd1ac42bd Mon Sep 17 00:00:00 2001 From: Rekai Musuka Date: Tue, 30 Nov 2021 03:45:54 -0400 Subject: [PATCH] chore: code cleanup --- src/apu.rs | 6 ++-- src/high_ram.rs | 8 ++--- src/main.rs | 46 ++++++++++++++-------------- src/ppu.rs | 8 ++--- src/scheduler.rs | 79 ------------------------------------------------ src/work_ram.rs | 16 +++++----- 6 files changed, 42 insertions(+), 121 deletions(-) delete mode 100644 src/scheduler.rs diff --git a/src/apu.rs b/src/apu.rs index c7c977f..58394c0 100644 --- a/src/apu.rs +++ b/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(); diff --git a/src/high_ram.rs b/src/high_ram.rs index 7d1b84b..b5fb733 100644 --- a/src/high_ram.rs +++ b/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; + } } diff --git a/src/main.rs b/src/main.rs index 1497d38..4b5b238 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,9 +2,9 @@ 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 gb::{emu, gui}; use gilrs::Gilrs; +use gui::GuiState; use rodio::{OutputStream, Sink}; use tracing_subscriber::EnvFilter; use winit::event::{Event, WindowEvent}; @@ -45,20 +45,20 @@ fn main() { .with_env_filter(EnvFilter::from_default_env()) .init(); - // --Here lies a lot of Winit + WGPU Boilerplate-- + // --Here lies a lot of winit + wgpu Boilerplate-- let event_loop: EventLoop> = EventLoop::with_user_event(); - let window = gb::gui::build_window(&event_loop).expect("build window"); + let window = 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 (instance, surface) = gui::create_surface(&window); + let adapter = gui::request_adapter(&instance, &surface).expect("request adaptor"); + let (device, queue) = 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); + let mut config = gui::surface_config(&window, format); surface.configure(&device, &config); - let mut platform = gb::gui::platform_desc(&window); + let mut platform = gui::platform_desc(&window); let mut render_pass = RenderPass::new(&device, format, 1); // We interrupt your boiler plate to initialize the emulator so that @@ -74,11 +74,11 @@ 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); + // Set up the wgpu (and then EGUI) texture we'll be working with. + let texture_size = gui::texture_size(); + let texture = gui::create_texture(&device, texture_size); + gui::write_to_texture(&queue, &texture, emu::pixel_buf(&cpu), texture_size); + let texture_id = gui::expose_texture_to_egui(&mut render_pass, &device, &texture); // Load ROM if filepath was provided if let Some(path) = m.value_of("rom") { @@ -115,7 +115,7 @@ 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 mut last_key = gui::unused_key(); // used for egui animations let start_time = Instant::now(); @@ -129,15 +129,15 @@ fn main() { emu::save_and_exit(&cpu, control_flow); } - gb::emu::run_frame(&mut cpu, &mut gamepad, last_key); + emu::run_frame(&mut cpu, &mut gamepad, last_key); window.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 data = emu::pixel_buf(&cpu); + gui::write_to_texture(&queue, &texture, data, texture_size); let output_frame = match surface.get_current_texture() { Ok(frame) => frame, @@ -146,17 +146,17 @@ fn main() { return; } }; - let output_view = gb::gui::create_view(&output_frame); + let output_view = gui::create_view(&output_frame); // Begin to draw Egui components platform.begin_frame(); - gb::gui::draw_egui(&mut app, &platform.context(), texture_id); + 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); + let mut encoder = gui::create_command_encoder(&device); + let screen_descriptor = gui::create_screen_descriptor(&window, &config); // Upload all resources for the GPU. render_pass.update_texture(&device, &queue, &platform.context().texture()); @@ -164,7 +164,7 @@ fn main() { render_pass.update_buffers(&device, &queue, &paint_jobs, &screen_descriptor); // Record all render passes. - gb::gui::execute_render_pass( + gui::execute_render_pass( &mut render_pass, &mut encoder, &output_view, diff --git a/src/ppu.rs b/src/ppu.rs index 39d81e0..e4d450e 100644 --- a/src/ppu.rs +++ b/src/ppu.rs @@ -265,7 +265,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 +276,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); @@ -441,7 +441,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; @@ -683,7 +683,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? diff --git a/src/scheduler.rs b/src/scheduler.rs deleted file mode 100644 index e7bd37e..0000000 --- a/src/scheduler.rs +++ /dev/null @@ -1,79 +0,0 @@ -use crate::Cycle; -use std::collections::BinaryHeap; - -#[derive(Debug)] -pub(crate) struct Scheduler { - timestamp: Cycle, - queue: BinaryHeap, -} - -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 { - 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, -} diff --git a/src/work_ram.rs b/src/work_ram.rs index f553a63..efb2937 100644 --- a/src/work_ram.rs +++ b/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; + } }