Initial impl for the SDL frontend

Author: alloncm

common/src/menu.rs

@@ -8,12 +8,14 @@ pub struct MenuOption<T, S:AsRef<str>>{
 #[derive(Debug, Clone, Copy)]
 pub enum EmulatorMenuOption{
     Resume,
+    Turbo,
     Restart,
     Shutdown
 }
 
-pub const GAME_MENU_OPTIONS:[MenuOption<EmulatorMenuOption, &str>;3] = [
+pub const GAME_MENU_OPTIONS:[MenuOption<EmulatorMenuOption, &str>; 4] = [
     MenuOption{prompt:"Resume", value:EmulatorMenuOption::Resume},
+    MenuOption{prompt:"Turbo", value:EmulatorMenuOption::Turbo},
     MenuOption{prompt:"Restart", value:EmulatorMenuOption::Restart}, 
     MenuOption{prompt:"Shutdown", value:EmulatorMenuOption::Shutdown}
 ];
@@ -25,15 +27,22 @@ cfg_if::cfg_if!{ if #[cfg(feature = "std")]{
 
     pub struct MagenBoyState{
         // Use atomic bool, normal bool doesnt works on arm (probably cause of the memory model)
-        pub running:AtomicBool,
-        pub pause:AtomicBool,
-        pub exit:AtomicBool,
-        pub state_mutex:Mutex<()>
+        pub running: AtomicBool,
+        pub turbo: AtomicBool,
+        pub pause: AtomicBool,
+        pub exit: AtomicBool,
+        pub state_mutex: Mutex<()>
     }
 
     impl MagenBoyState{
         pub const fn new() -> Self {
-            Self { running: AtomicBool::new(true), pause: AtomicBool::new(false), exit: AtomicBool::new(false), state_mutex: Mutex::new(()) }
+            Self { 
+                running: AtomicBool::new(true), 
+                turbo: AtomicBool::new(false),
+                pause: AtomicBool::new(false), 
+                exit: AtomicBool::new(false), 
+                state_mutex: Mutex::new(()) 
+            }
         }
     }
 
@@ -47,9 +56,19 @@ cfg_if::cfg_if!{ if #[cfg(feature = "std")]{
             Self { provider, header }
         }
 
-        pub fn pop_game_menu<GFX:GfxDevice>(&mut self, state:&MagenBoyState, gfx_device:&mut GFX, receiver:crossbeam_channel::Receiver<usize>){
+        pub fn pop_game_menu<GFX: GfxDevice>(
+            &mut self,
+            state: &MagenBoyState,
+            gfx_device: &mut GFX, 
+            receiver: crossbeam_channel::Receiver<usize>
+        ) {
             match self.get_game_menu_selection(state, gfx_device, receiver){
                 EmulatorMenuOption::Resume => {},
+                EmulatorMenuOption::Turbo => {
+                    let new_turbo_state = !state.turbo.load(std::sync::atomic::Ordering::Relaxed);
+                    state.turbo.store(new_turbo_state, std::sync::atomic::Ordering::Relaxed);
+                    log::info!("Turbo mode is: {new_turbo_state}");
+                },
                 EmulatorMenuOption::Restart => state.running.store(false, std::sync::atomic::Ordering::Relaxed),
                 EmulatorMenuOption::Shutdown => {
                     state.running.store(false, std::sync::atomic::Ordering::Relaxed);
@@ -58,7 +77,12 @@ cfg_if::cfg_if!{ if #[cfg(feature = "std")]{
             }
         }
 
-        fn get_game_menu_selection<GFX:GfxDevice>(&mut self, state:&MagenBoyState,gfx_device:&mut GFX, emulation_framebuffer_channel:crossbeam_channel::Receiver<usize>)->&EmulatorMenuOption{
+        fn get_game_menu_selection<GFX: GfxDevice>(
+            &mut self,
+            state: &MagenBoyState,
+            gfx_device: &mut GFX,
+            emulation_framebuffer_channel: crossbeam_channel::Receiver<usize>
+        ) -> &EmulatorMenuOption {
             let menu_renderer = joypad_gfx_menu::GfxDeviceMenuRenderer::new(gfx_device);
 
             let mut menu = JoypadMenu::new(&GAME_MENU_OPTIONS, &self.header, menu_renderer);  
@@ -67,10 +91,14 @@ cfg_if::cfg_if!{ if #[cfg(feature = "std")]{
             state.pause.store(true, std::sync::atomic::Ordering::SeqCst);
             loop{
                 if let Ok(_lock) = state.state_mutex.try_lock(){
+                    // Turn off turbo to have a regular speed menu
+                    let last_turbo = state.turbo.swap(false, core::sync::atomic::Ordering::Relaxed);
                     let selection = menu.get_menu_selection(&mut self.provider);
+                    // restore turbo state
+                    state.turbo.store(last_turbo, core::sync::atomic::Ordering::Relaxed);
                     state.pause.store(false, std::sync::atomic::Ordering::SeqCst);
                     return selection;
-                }else{
+                } else {
                     // try recv in order to clear frames from the channel 
                     // in order to not block the emualtion thread and allow it to finish the frame
                     let _ = emulation_framebuffer_channel.try_recv();
@@ -80,7 +108,11 @@ cfg_if::cfg_if!{ if #[cfg(feature = "std")]{
 
     }
 
-    pub fn get_rom_selection<MR:MenuRenderer<PathBuf, String>, JP:MenuJoypadProvider + JoypadProvider>(roms_path:&str, menu_renderer:MR, jp:&mut JP)->String{
+    pub fn get_rom_selection<MR:MenuRenderer<PathBuf, String>, JP:MenuJoypadProvider + JoypadProvider>(
+        roms_path: &str,
+        menu_renderer: MR,
+        jp:&mut JP
+    ) -> String {
         let mut menu_options = Vec::new();
         let dir_entries = std::fs::read_dir(roms_path).expect(std::format!("Error openning the roms directory: {}",roms_path).as_str());
         for entry in dir_entries{

sdl/src/main.rs

@@ -13,7 +13,7 @@ use sdl2::sys::*;
 
 use crate::{sdl_gfx_device::SdlGfxDevice, audio::*, SdlAudioDevice};
 
-const TURBO_MUL:u8 = 1;
+const TURBO_FACTOR:u8 = 4;
 
 const SCREEN_SCALE:usize = 4;
 use sdl2::sys::SDL_Scancode;
@@ -38,8 +38,13 @@ fn main() {
     }
 
     // Initialize the gfx first cause it initialize both the screen and the sdl context for the joypad
-    let mut gfx_device: SdlGfxDevice = SdlGfxDevice::new(header.as_str(), SCREEN_SCALE, TURBO_MUL,
-    check_for_terminal_feature_flag(&args, "--no-vsync"), check_for_terminal_feature_flag(&args, "--full-screen"));
+    let mut gfx_device: SdlGfxDevice = SdlGfxDevice::new(
+        header.as_str(), 
+        SCREEN_SCALE, 
+        TURBO_FACTOR,
+        check_for_terminal_feature_flag(&args, "--no-vsync"),
+        check_for_terminal_feature_flag(&args, "--full-screen")
+    );
 
     while !(EMULATOR_STATE.exit.load(std::sync::atomic::Ordering::Relaxed)){
         let mut provider = sdl_joypad_provider::SdlJoypadProvider::new(KEYBOARD_MAPPING, true);
@@ -112,7 +117,7 @@ fn main() {
 // Receiving usize and not raw ptr cause in rust you cant pass a raw ptr to another thread
 fn emulation_thread_main(args: Vec<String>, program_name: String, spsc_gfx_device: MpmcGfxDevice, #[cfg(feature = "dbg")] debugger_sender: crossbeam_channel::Sender<terminal_debugger::PpuLayerResult>) {
     let mut devices: Vec::<Box::<dyn AudioDevice>> = Vec::new();
-    let audio_device = SdlAudioDevice::<ManualAudioResampler>::new(44100, TURBO_MUL);
+    let audio_device = SdlAudioDevice::<ManualAudioResampler>::new(44100, TURBO_FACTOR);
     devices.push(Box::new(audio_device));
 
     if check_for_terminal_feature_flag(&args, "--file-audio"){

sdl/src/sdl_gfx_device.rs

@@ -1,6 +1,10 @@
 use std::ffi::{CString, c_void};
+
 use sdl2::sys::*;
+
+use magenboy_common::EMULATOR_STATE;
 use magenboy_core::{ppu::gb_ppu::{SCREEN_HEIGHT, SCREEN_WIDTH}, utils::vec2::Vec2, GfxDevice, Pixel};
+
 use super::utils::get_sdl_error_message;
 
 // The bit order is high bits -> low bits as opposed to RGB555 in the gbdev docs which is low -> high.
@@ -75,23 +79,32 @@ impl Drop for SdlWindow{
 
 pub struct SdlGfxDevice{
     sdl_window:SdlWindow,
-    discard:u8,
-    turbo_mul:u8,
+    turbo_counter:u8,
+    turbo_factor:u8,
 }
 
 impl SdlGfxDevice{
-    pub fn new(window_name:&str, screen_scale: usize, turbo_mul:u8, disable_vsync:bool, full_screen:bool)->Self{
+    pub fn new(window_name: &str, screen_scale: usize, turbo_factor:u8, disable_vsync:bool, full_screen:bool)->Self{
 
-        let window_flags = if full_screen{                
+        let window_flags = if full_screen {                
             // Hide cursor
             unsafe{SDL_ShowCursor(0);}
             SDL_WindowFlags::SDL_WINDOW_FULLSCREEN_DESKTOP as u32
-        }
-        else{
+        } else {
             SDL_WindowFlags::SDL_WINDOW_RESIZABLE as u32
         };
 
-        return Self{discard:0, turbo_mul, sdl_window: SdlWindow::new(window_name, Vec2{x:SCREEN_WIDTH, y:SCREEN_HEIGHT}, screen_scale, disable_vsync, window_flags)};
+        return Self{
+            turbo_counter: 0, 
+            turbo_factor, 
+            sdl_window: SdlWindow::new(
+                window_name, 
+                Vec2{x: SCREEN_WIDTH, y: SCREEN_HEIGHT}, 
+                screen_scale, 
+                disable_vsync, 
+                window_flags
+            )
+        };
     }
 
     pub fn poll_event(&self)->Option<SDL_Event>{
@@ -109,10 +122,13 @@ impl SdlGfxDevice{
 
 impl GfxDevice for SdlGfxDevice{
     fn swap_buffer(&mut self, buffer:&[Pixel; SCREEN_HEIGHT * SCREEN_WIDTH]) {
-        self.discard = (self.discard + 1) % self.turbo_mul;
-        if self.discard != 0{
-            return;
+        if EMULATOR_STATE.turbo.load(std::sync::atomic::Ordering::Relaxed) {
+            self.turbo_counter = (self.turbo_counter + 1) % self.turbo_factor;
+            if self.turbo_counter != 0{
+                return;
+            }
         }
+        
         self.sdl_window.render(buffer);
     }
 }