Move more logic from frontend to base HostInterface

src/duckstation-sdl/d3d11_host_display.h

@@ -69,5 +69,5 @@ private:
   D3D11::StreamBuffer m_display_uniform_buffer;
 
   bool m_allow_tearing_supported = false;
-  bool m_vsync = false;
+  bool m_vsync = true;
 };

src/duckstation-sdl/main.cpp

@@ -15,28 +15,26 @@ static int Run(int argc, char* argv[])
   }
 
   // parameters
-  const char* filename = nullptr;
-  const char* exp1_filename = nullptr;
-  std::string state_filename;
+  std::optional<s32> state_index;
+  const char* boot_filename = nullptr;
   for (int i = 1; i < argc; i++)
   {
 #define CHECK_ARG(str) !std::strcmp(argv[i], str)
 #define CHECK_ARG_PARAM(str) (!std::strcmp(argv[i], str) && ((i + 1) < argc))
 
     if (CHECK_ARG_PARAM("-state"))
-      state_filename = SDLHostInterface::GetSaveStateFilename(std::strtoul(argv[++i], nullptr, 10));
-    else if (CHECK_ARG_PARAM("-exp1"))
-      exp1_filename = argv[++i];
+      state_index = std::atoi(argv[++i]);
+    if (CHECK_ARG_PARAM("-resume"))
+      state_index = -1;
     else
-      filename = argv[i];
+      boot_filename = argv[i];
 
 #undef CHECK_ARG
 #undef CHECK_ARG_PARAM
   }
 
   // create display and host interface
-  std::unique_ptr<SDLHostInterface> host_interface =
-    SDLHostInterface::Create(filename, exp1_filename, state_filename.empty() ? nullptr : state_filename.c_str());
+  std::unique_ptr<SDLHostInterface> host_interface = SDLHostInterface::Create();
   if (!host_interface)
   {
     Panic("Failed to create host interface");
@@ -44,6 +42,17 @@ static int Run(int argc, char* argv[])
     return -1;
   }
 
+  // boot/load state
+  if (boot_filename)
+  {
+    if (host_interface->BootSystemFromFile(boot_filename) && state_index.has_value())
+      host_interface->LoadState(false, state_index.value());
+  }
+  else if (state_index.has_value())
+  {
+    host_interface->LoadState(true, state_index.value());
+  }
+
   // run
   host_interface->Run();
 

src/duckstation-sdl/opengl_host_display.cpp

@@ -262,6 +262,8 @@ bool OpenGLHostDisplay::CreateGLContext(bool debug_device)
     glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
   }
 
+  // start with vsync on
+  SDL_GL_SetSwapInterval(1);
   return true;
 }
 

src/duckstation-sdl/sdl_host_interface.cpp

@@ -33,17 +33,20 @@ SDLHostInterface::SDLHostInterface()
   timeBeginPeriod(1);
 #endif
 
-  m_switch_gpu_renderer_event_id = SDL_RegisterEvents(1);
+  m_update_settings_event_id = SDL_RegisterEvents(1);
 }
 
 SDLHostInterface::~SDLHostInterface()
 {
   CloseGameControllers();
-  m_display.reset();
-  ImGui::DestroyContext();
+  if (m_display)
+  {
+    DestroyDisplay();
+    ImGui::DestroyContext();
+  }
 
   if (m_window)
-    SDL_DestroyWindow(m_window);
+    DestroySDLWindow();
 
 #ifdef WIN32
   timeEndPeriod(1);
@@ -87,30 +90,31 @@ void SDLHostInterface::DestroySDLWindow()
 bool SDLHostInterface::CreateDisplay()
 {
   const bool debug_device = m_settings.gpu_use_debug_device;
+  std::unique_ptr<HostDisplay> display;
 #ifdef WIN32
-  m_display = UseOpenGLRenderer() ? OpenGLHostDisplay::Create(m_window, debug_device) :
-                                    D3D11HostDisplay::Create(m_window, debug_device);
+  display = UseOpenGLRenderer() ? OpenGLHostDisplay::Create(m_window, debug_device) :
+                                           D3D11HostDisplay::Create(m_window, debug_device);
 #else
-  m_display = OpenGLHostDisplay::Create(m_window, debug_device);
+  display = OpenGLHostDisplay::Create(m_window, debug_device);
 #endif
 
-  if (!m_display)
+  if (!display)
     return false;
 
-  m_display->SetDisplayLinearFiltering(m_settings.display_linear_filtering);
-
   m_app_icon_texture =
-    m_display->CreateTexture(APP_ICON_WIDTH, APP_ICON_HEIGHT, APP_ICON_DATA, APP_ICON_WIDTH * sizeof(u32));
-  if (!m_app_icon_texture)
+    display->CreateTexture(APP_ICON_WIDTH, APP_ICON_HEIGHT, APP_ICON_DATA, APP_ICON_WIDTH * sizeof(u32));
+  if (!display)
     return false;
 
+  m_display = display.release();
   return true;
 }
 
 void SDLHostInterface::DestroyDisplay()
 {
   m_app_icon_texture.reset();
-  m_display.reset();
+  delete m_display;
+  m_display = nullptr;
 }
 
 void SDLHostInterface::CreateImGuiContext()
@@ -123,101 +127,93 @@ void SDLHostInterface::CreateImGuiContext()
   ImGui::AddRobotoRegularFont();
 }
 
-void SDLHostInterface::CreateAudioStream()
+bool SDLHostInterface::AcquireHostDisplay()
+{
+  // Handle renderer switch if required on Windows.
+#ifdef WIN32
+  const HostDisplay::RenderAPI render_api = m_display->GetRenderAPI();
+  const bool render_api_is_gl =
+    render_api == HostDisplay::RenderAPI::OpenGL || render_api == HostDisplay::RenderAPI::OpenGLES;
+  const bool render_api_wants_gl = UseOpenGLRenderer();
+  if (render_api_is_gl != render_api_wants_gl)
+  {
+    ImGui::EndFrame();
+    DestroyDisplay();
+    DestroySDLWindow();
+
+    if (!CreateSDLWindow())
+      Panic("Failed to recreate SDL window on GPU renderer switch");
+
+    if (!CreateDisplay())
+      Panic("Failed to recreate display on GPU renderer switch");
+
+    ImGui::NewFrame();
+  }
+#endif
+
+  return true;
+}
+
+void SDLHostInterface::ReleaseHostDisplay()
+{
+  // restore vsync, since we don't want to burn cycles at the menu
+  m_display->SetVSync(true);
+}
+
+std::unique_ptr<AudioStream> SDLHostInterface::CreateAudioStream(AudioBackend backend)
 {
   switch (m_settings.audio_backend)
   {
     case AudioBackend::Null:
-      m_audio_stream = AudioStream::CreateNullAudioStream();
-      break;
+      return AudioStream::CreateNullAudioStream();
 
     case AudioBackend::Cubeb:
-      m_audio_stream = AudioStream::CreateCubebAudioStream();
-      break;
+      return AudioStream::CreateCubebAudioStream();
 
     case AudioBackend::Default:
-    default:
-      m_audio_stream = std::make_unique<SDLAudioStream>();
-      break;
-  }
+      return std::make_unique<SDLAudioStream>();
 
-  if (!m_audio_stream->Reconfigure(AUDIO_SAMPLE_RATE, AUDIO_CHANNELS))
-  {
-    ReportError("Failed to recreate audio stream, falling back to null");
-    m_audio_stream.reset();
-    m_audio_stream = AudioStream::CreateNullAudioStream();
-    if (!m_audio_stream->Reconfigure(AUDIO_SAMPLE_RATE, AUDIO_CHANNELS))
-      Panic("Failed to reconfigure null audio stream");
+    default:
+      return nullptr;
   }
 }
 
+void SDLHostInterface::OnSystemCreated()
+{
+  HostInterface::OnSystemCreated();
+
+  UpdateKeyboardControllerMapping();
+  UpdateControllerControllerMapping();
+  ClearImGuiFocus();
+}
+
+void SDLHostInterface::OnSystemPaused(bool paused)
+{
+  HostInterface::OnSystemPaused(paused);
+
+  if (!paused)
+    ClearImGuiFocus();
+}
+
+void SDLHostInterface::OnSystemDestroyed()
+{
+  HostInterface::OnSystemDestroyed();
+}
+
 void SDLHostInterface::SaveSettings()
 {
   SDLSettingsInterface si(GetSettingsFileName().c_str());
   m_settings.Save(si);
 }
 
-void SDLHostInterface::QueueSwitchGPURenderer()
+void SDLHostInterface::QueueUpdateSettings()
 {
   SDL_Event ev = {};
   ev.type = SDL_USEREVENT;
-  ev.user.code = m_switch_gpu_renderer_event_id;
+  ev.user.code = m_update_settings_event_id;
   SDL_PushEvent(&ev);
 }
 
-void SDLHostInterface::SwitchGPURenderer()
-{
-  // Due to the GPU class owning textures, we have to shut the system down.
-  std::unique_ptr<ByteStream> stream;
-  if (m_system)
-  {
-    stream = ByteStream_CreateGrowableMemoryStream(nullptr, 8 * 1024);
-    if (!m_system->SaveState(stream.get()) || !stream->SeekAbsolute(0))
-      ReportError("Failed to save state before GPU renderer switch");
-
-    DestroySystem();
-  }
-
-  ImGui::EndFrame();
-  DestroyDisplay();
-  DestroySDLWindow();
-
-  if (!CreateSDLWindow())
-    Panic("Failed to recreate SDL window on GPU renderer switch");
-
-  if (!CreateDisplay())
-    Panic("Failed to recreate display on GPU renderer switch");
-
-  ImGui::NewFrame();
-
-  if (stream)
-  {
-    CreateSystem();
-    if (!BootSystem(nullptr, nullptr) || !m_system->LoadState(stream.get()))
-    {
-      ReportError("Failed to load state after GPU renderer switch, resetting");
-      m_system->Reset();
-    }
-  }
-
-  UpdateFullscreen();
-  if (m_system)
-    m_system->ResetPerformanceCounters();
-  ClearImGuiFocus();
-}
-
-void SDLHostInterface::SwitchAudioBackend()
-{
-  m_audio_stream.reset();
-  CreateAudioStream();
-
-  if (m_system)
-  {
-    m_audio_stream->PauseOutput(false);
-    UpdateSpeedLimiterState();
-  }
-}
-
 void SDLHostInterface::UpdateFullscreen()
 {
   SDL_SetWindowFullscreen(m_window, m_settings.display_fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
@@ -227,15 +223,7 @@ void SDLHostInterface::UpdateFullscreen()
     m_settings.display_fullscreen ? 0 : static_cast<int>(20.0f * ImGui::GetIO().DisplayFramebufferScale.x));
 }
 
-void SDLHostInterface::UpdateControllerMapping()
-{
-  UpdateKeyboardControllerMapping();
-  UpdateControllerControllerMapping();
-}
-
-std::unique_ptr<SDLHostInterface> SDLHostInterface::Create(const char* filename /* = nullptr */,
-                                                           const char* exp1_filename /* = nullptr */,
-                                                           const char* save_state_filename /* = nullptr */)
+std::unique_ptr<SDLHostInterface> SDLHostInterface::Create()
 {
   std::unique_ptr<SDLHostInterface> intf = std::make_unique<SDLHostInterface>();
 
@@ -256,34 +244,13 @@ std::unique_ptr<SDLHostInterface> SDLHostInterface::Create(const char* filename
     return nullptr;
   }
 
-  intf->CreateAudioStream();
-
   ImGui::NewFrame();
 
-  intf->UpdateSpeedLimiterState();
-
-  const bool boot = (filename != nullptr || exp1_filename != nullptr || save_state_filename != nullptr);
-  if (boot)
-  {
-    if (!intf->CreateSystem() || !intf->BootSystem(filename, exp1_filename))
-      return nullptr;
-
-    if (save_state_filename)
-      intf->LoadState(save_state_filename);
-
-    intf->UpdateControllerMapping();
-  }
-
   intf->UpdateFullscreen();
 
   return intf;
 }
 
-std::string SDLHostInterface::GetSaveStateFilename(u32 index)
-{
-  return StringUtil::StdStringFromFormat("savestate_%u.bin", index);
-}
-
 void SDLHostInterface::ReportError(const char* message)
 {
   SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "DuckStation Error", message, m_window);
@@ -291,7 +258,7 @@ void SDLHostInterface::ReportError(const char* message)
 
 void SDLHostInterface::ReportMessage(const char* message)
 {
-  SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "DuckStation Information", message, m_window);
+  AddOSDMessage(message, 2.0f);
 }
 
 void SDLHostInterface::HandleSDLEvent(const SDL_Event* event)
@@ -352,8 +319,13 @@ void SDLHostInterface::HandleSDLEvent(const SDL_Event* event)
 
     case SDL_USEREVENT:
     {
-      if (static_cast<u32>(event->user.code) == m_switch_gpu_renderer_event_id)
-        SwitchGPURenderer();
+      if (static_cast<u32>(event->user.code) == m_update_settings_event_id)
+      {
+        UpdateSettings([this]() {
+          SDLSettingsInterface si(GetSettingsFileName().c_str());
+          m_settings.Load(si);
+        });
+      }
     }
     break;
   }
@@ -381,9 +353,9 @@ void SDLHostInterface::HandleSDLKeyEvent(const SDL_Event* event)
       {
         const u32 index = event->key.keysym.scancode - SDL_SCANCODE_F1 + 1;
         if (event->key.keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT))
-          DoSaveState(index);
+          SaveState(true, index);
         else
-          DoLoadState(index);
+          LoadState(true, index);
       }
     }
     break;
@@ -408,7 +380,7 @@ void SDLHostInterface::HandleSDLKeyEvent(const SDL_Event* event)
     case SDL_SCANCODE_PAUSE:
     {
       if (pressed)
-        DoTogglePause();
+        PauseSystem(!m_paused);
     }
     break;
 
@@ -792,51 +764,78 @@ void SDLHostInterface::DrawMainMenuBar()
   if (ImGui::BeginMenu("System"))
   {
     if (ImGui::MenuItem("Start Disc", nullptr, false, !system_enabled))
+    {
       DoStartDisc();
+      ClearImGuiFocus();
+    }
     if (ImGui::MenuItem("Start BIOS", nullptr, false, !system_enabled))
-      DoStartBIOS();
+    {
+      BootSystemFromBIOS();
+      ClearImGuiFocus();
+    }
 
     ImGui::Separator();
 
     if (ImGui::MenuItem("Power Off", nullptr, false, system_enabled))
-      DoPowerOff();
+    {
+      DestroySystem();
+      ClearImGuiFocus();
+    }
 
     if (ImGui::MenuItem("Reset", nullptr, false, system_enabled))
+    {
       ResetSystem();
+      ClearImGuiFocus();
+    }
 
     if (ImGui::MenuItem("Pause", nullptr, m_paused, system_enabled))
-      DoTogglePause();
+    {
+      PauseSystem(!m_paused);
+      ClearImGuiFocus();
+    }
 
     ImGui::Separator();
 
     if (ImGui::MenuItem("Change Disc", nullptr, false, system_enabled))
+    {
       DoChangeDisc();
+      ClearImGuiFocus();
+    }
 
     if (ImGui::MenuItem("Frame Step", nullptr, false, system_enabled))
+    {
       DoFrameStep();
+      ClearImGuiFocus();
+    }
 
     ImGui::Separator();
 
     if (ImGui::BeginMenu("Load State"))
     {
-      for (u32 i = 1; i <= NUM_QUICK_SAVE_STATES; i++)
+      for (u32 i = 1; i <= GLOBAL_SAVE_STATE_SLOTS; i++)
       {
         char buf[16];
         std::snprintf(buf, sizeof(buf), "State %u", i);
         if (ImGui::MenuItem(buf))
-          DoLoadState(i);
+        {
+          LoadState(true, i);
+          ClearImGuiFocus();
+        }
       }
       ImGui::EndMenu();
     }
 
     if (ImGui::BeginMenu("Save State", system_enabled))
     {
-      for (u32 i = 1; i <= NUM_QUICK_SAVE_STATES; i++)
+      for (u32 i = 1; i <= GLOBAL_SAVE_STATE_SLOTS; i++)
       {
         char buf[16];
         std::snprintf(buf, sizeof(buf), "State %u", i);
         if (ImGui::MenuItem(buf))
-          DoSaveState(i);
+        {
+          SaveState(true, i);
+          ClearImGuiFocus();
+        }
       }
       ImGui::EndMenu();
     }
@@ -916,12 +915,7 @@ void SDLHostInterface::DrawMainMenuBar()
 void SDLHostInterface::DrawQuickSettingsMenu()
 {
   bool settings_changed = false;
-  bool gpu_settings_changed = false;
-  if (ImGui::MenuItem("Enable Speed Limiter", nullptr, &m_settings.speed_limiter_enabled))
-  {
-    settings_changed = true;
-    UpdateSpeedLimiterState();
-  }
+  settings_changed |= ImGui::MenuItem("Enable Speed Limiter", nullptr, &m_settings.speed_limiter_enabled);
 
   ImGui::Separator();
 
@@ -935,8 +929,6 @@ void SDLHostInterface::DrawQuickSettingsMenu()
       {
         m_settings.cpu_execution_mode = static_cast<CPUExecutionMode>(i);
         settings_changed = true;
-        if (m_system)
-          m_system->SetCPUExecutionMode(m_settings.cpu_execution_mode);
       }
     }
 
@@ -955,7 +947,6 @@ void SDLHostInterface::DrawQuickSettingsMenu()
       {
         m_settings.gpu_renderer = static_cast<GPURenderer>(i);
         settings_changed = true;
-        QueueSwitchGPURenderer();
       }
     }
 
@@ -968,11 +959,7 @@ void SDLHostInterface::DrawQuickSettingsMenu()
     UpdateFullscreen();
   }
 
-  if (ImGui::MenuItem("VSync", nullptr, &m_settings.video_sync_enabled))
-  {
-    settings_changed = true;
-    UpdateSpeedLimiterState();
-  }
+  settings_changed |= ImGui::MenuItem("VSync", nullptr, &m_settings.video_sync_enabled);
 
   ImGui::Separator();
 
@@ -987,26 +974,22 @@ void SDLHostInterface::DrawQuickSettingsMenu()
       if (ImGui::MenuItem(buf, nullptr, current_internal_resolution == scale))
       {
         m_settings.gpu_resolution_scale = scale;
-        gpu_settings_changed = true;
+        settings_changed = true;
       }
     }
 
     ImGui::EndMenu();
   }
 
-  gpu_settings_changed |= ImGui::MenuItem("True (24-Bit) Color", nullptr, &m_settings.gpu_true_color);
-  gpu_settings_changed |= ImGui::MenuItem("Texture Filtering", nullptr, &m_settings.gpu_texture_filtering);
-  if (ImGui::MenuItem("Display Linear Filtering", nullptr, &m_settings.display_linear_filtering))
+  settings_changed |= ImGui::MenuItem("True (24-Bit) Color", nullptr, &m_settings.gpu_true_color);
+  settings_changed |= ImGui::MenuItem("Texture Filtering", nullptr, &m_settings.gpu_texture_filtering);
+  settings_changed |= ImGui::MenuItem("Display Linear Filtering", nullptr, &m_settings.display_linear_filtering);
+
+  if (settings_changed)
   {
-    m_display->SetDisplayLinearFiltering(m_settings.display_linear_filtering);
-    settings_changed = true;
-  }
-
-  if (settings_changed || gpu_settings_changed)
     SaveSettings();
-
-  if (gpu_settings_changed && m_system)
-    m_system->GetGPU()->UpdateSettings();
+    QueueUpdateSettings();
+  }
 }
 
 void SDLHostInterface::DrawDebugMenu()
@@ -1068,18 +1051,23 @@ void SDLHostInterface::DrawPoweredOffWindow()
   ImGui::PushStyleColor(ImGuiCol_ButtonHovered, 0xFF575757);
 
   ImGui::SetCursorPosX(button_left);
-  if (ImGui::Button("Resume", button_size))
-    DoResume();
+  ImGui::Button("Resume", button_size);
   ImGui::NewLine();
 
   ImGui::SetCursorPosX(button_left);
   if (ImGui::Button("Start Disc", button_size))
+  {
     DoStartDisc();
+    ClearImGuiFocus();
+  }
   ImGui::NewLine();
 
   ImGui::SetCursorPosX(button_left);
   if (ImGui::Button("Start BIOS", button_size))
-    DoStartBIOS();
+  {
+    BootSystemFromFile(nullptr);
+    ClearImGuiFocus();
+  }
   ImGui::NewLine();
 
   ImGui::SetCursorPosX(button_left);
@@ -1087,12 +1075,15 @@ void SDLHostInterface::DrawPoweredOffWindow()
     ImGui::OpenPopup("PowerOffWindow_LoadStateMenu");
   if (ImGui::BeginPopup("PowerOffWindow_LoadStateMenu"))
   {
-    for (u32 i = 1; i <= NUM_QUICK_SAVE_STATES; i++)
+    for (u32 i = 1; i <= GLOBAL_SAVE_STATE_SLOTS; i++)
     {
       char buf[16];
       std::snprintf(buf, sizeof(buf), "State %u", i);
       if (ImGui::MenuItem(buf))
-        DoLoadState(i);
+      {
+        LoadState(true, i);
+        ClearImGuiFocus();
+      }
     }
     ImGui::EndPopup();
   }
@@ -1133,7 +1124,6 @@ void SDLHostInterface::DrawSettingsWindow()
   }
 
   bool settings_changed = false;
-  bool gpu_settings_changed = false;
 
   if (ImGui::BeginTabBar("SettingsTabBar", 0))
   {
@@ -1173,19 +1163,8 @@ void SDLHostInterface::DrawSettingsWindow()
         ImGui::Text("Emulation Speed:");
         ImGui::SameLine(indent);
 
-        if (ImGui::SliderFloat("##speed", &m_settings.emulation_speed, 0.25f, 5.0f))
-        {
-          settings_changed = true;
-          if (m_system)
-            m_system->UpdateThrottlePeriod();
-        }
-
-        if (ImGui::Checkbox("Enable Speed Limiter", &m_settings.speed_limiter_enabled))
-        {
-          settings_changed = true;
-          UpdateSpeedLimiterState();
-        }
-
+        settings_changed |= ImGui::SliderFloat("##speed", &m_settings.emulation_speed, 0.25f, 5.0f);
+        settings_changed |= ImGui::Checkbox("Enable Speed Limiter", &m_settings.speed_limiter_enabled);
         settings_changed |= ImGui::Checkbox("Pause On Start", &m_settings.start_paused);
       }
 
@@ -1206,14 +1185,9 @@ void SDLHostInterface::DrawSettingsWindow()
         {
           m_settings.audio_backend = static_cast<AudioBackend>(backend);
           settings_changed = true;
-          SwitchAudioBackend();
         }
 
-        if (ImGui::Checkbox("Output Sync", &m_settings.audio_sync_enabled))
-        {
-          settings_changed = true;
-          UpdateSpeedLimiterState();
-        }
+        settings_changed |= ImGui::Checkbox("Output Sync", &m_settings.audio_sync_enabled);
       }
 
       ImGui::EndTabItem();
@@ -1242,11 +1216,6 @@ void SDLHostInterface::DrawSettingsWindow()
           {
             m_settings.controller_types[i] = static_cast<ControllerType>(controller_type);
             settings_changed = true;
-            if (m_system)
-            {
-              m_system->UpdateControllers();
-              UpdateControllerControllerMapping();
-            }
           }
         }
 
@@ -1255,19 +1224,12 @@ void SDLHostInterface::DrawSettingsWindow()
 
         std::string* path_ptr = &m_settings.memory_card_paths[i];
         std::snprintf(buf, sizeof(buf), "##memcard_%c_path", 'a' + i);
-        if (DrawFileChooser(buf, path_ptr))
-        {
-          settings_changed = true;
-          if (m_system)
-            m_system->UpdateMemoryCards();
-        }
+        settings_changed |= DrawFileChooser(buf, path_ptr);
 
         if (ImGui::Button("Eject Memory Card"))
         {
           path_ptr->clear();
           settings_changed = true;
-          if (m_system)
-            m_system->UpdateMemoryCards();
         }
 
         ImGui::NewLine();
@@ -1292,8 +1254,6 @@ void SDLHostInterface::DrawSettingsWindow()
       {
         m_settings.cpu_execution_mode = static_cast<CPUExecutionMode>(execution_mode);
         settings_changed = true;
-        if (m_system)
-          m_system->SetCPUExecutionMode(m_settings.cpu_execution_mode);
       }
 
       ImGui::EndTabItem();
@@ -1317,7 +1277,6 @@ void SDLHostInterface::DrawSettingsWindow()
         {
           m_settings.gpu_renderer = static_cast<GPURenderer>(gpu_renderer);
           settings_changed = true;
-          QueueSwitchGPURenderer();
         }
       }
 
@@ -1331,17 +1290,8 @@ void SDLHostInterface::DrawSettingsWindow()
           settings_changed = true;
         }
 
-        if (ImGui::Checkbox("Linear Filtering", &m_settings.display_linear_filtering))
-        {
-          m_display->SetDisplayLinearFiltering(m_settings.display_linear_filtering);
-          settings_changed = true;
-        }
-
-        if (ImGui::Checkbox("VSync", &m_settings.video_sync_enabled))
-        {
-          settings_changed = true;
-          UpdateSpeedLimiterState();
-        }
+        settings_changed |= ImGui::Checkbox("Linear Filtering", &m_settings.display_linear_filtering);
+        settings_changed |= ImGui::Checkbox("VSync", &m_settings.video_sync_enabled);
       }
 
       ImGui::NewLine();
@@ -1375,12 +1325,12 @@ void SDLHostInterface::DrawSettingsWindow()
                          static_cast<int>(resolutions.size())))
         {
           m_settings.gpu_resolution_scale = static_cast<u32>(current_resolution_index + 1);
-          gpu_settings_changed = true;
+          settings_changed = true;
         }
 
-        gpu_settings_changed |= ImGui::Checkbox("True 24-bit Color (disables dithering)", &m_settings.gpu_true_color);
-        gpu_settings_changed |= ImGui::Checkbox("Texture Filtering", &m_settings.gpu_texture_filtering);
-        gpu_settings_changed |= ImGui::Checkbox("Force Progressive Scan", &m_settings.gpu_force_progressive_scan);
+        settings_changed |= ImGui::Checkbox("True 24-bit Color (disables dithering)", &m_settings.gpu_true_color);
+        settings_changed |= ImGui::Checkbox("Texture Filtering", &m_settings.gpu_texture_filtering);
+        settings_changed |= ImGui::Checkbox("Force Progressive Scan", &m_settings.gpu_force_progressive_scan);
       }
 
       ImGui::EndTabItem();
@@ -1397,11 +1347,11 @@ void SDLHostInterface::DrawSettingsWindow()
 
   ImGui::End();
 
-  if (settings_changed || gpu_settings_changed)
+  if (settings_changed)
+  {
     SaveSettings();
-
-  if (gpu_settings_changed && m_system)
-    m_system->GetGPU()->UpdateSettings();
+    QueueUpdateSettings();
+  }
 }
 
 void SDLHostInterface::DrawAboutWindow()
@@ -1454,26 +1404,9 @@ bool SDLHostInterface::DrawFileChooser(const char* label, std::string* path, con
   return result;
 }
 
-void SDLHostInterface::DoPowerOff()
+void SDLHostInterface::ClearImGuiFocus()
 {
-  Assert(m_system);
-  DestroySystem();
-  AddOSDMessage("System powered off.");
-}
-
-void SDLHostInterface::DoResume()
-{
-  Assert(!m_system);
-  if (!CreateSystem() || !BootSystem(nullptr, RESUME_SAVESTATE_FILENAME))
-  {
-    DestroySystem();
-    return;
-  }
-
-  UpdateControllerMapping();
-  if (m_system)
-    m_system->ResetPerformanceCounters();
-  ClearImGuiFocus();
+  ImGui::SetWindowFocus(nullptr);
 }
 
 void SDLHostInterface::DoStartDisc()
@@ -1485,33 +1418,7 @@ void SDLHostInterface::DoStartDisc()
     return;
 
   AddFormattedOSDMessage(2.0f, "Starting disc from '%s'...", path);
-  if (!CreateSystem() || !BootSystem(path, nullptr))
-  {
-    DestroySystem();
-    return;
-  }
-
-  UpdateControllerMapping();
-  if (m_system)
-    m_system->ResetPerformanceCounters();
-  ClearImGuiFocus();
-}
-
-void SDLHostInterface::DoStartBIOS()
-{
-  Assert(!m_system);
-
-  AddOSDMessage("Starting BIOS...");
-  if (!CreateSystem() || !BootSystem(nullptr, nullptr))
-  {
-    DestroySystem();
-    return;
-  }
-
-  UpdateControllerMapping();
-  if (m_system)
-    m_system->ResetPerformanceCounters();
-  ClearImGuiFocus();
+  BootSystemFromFile(path);
 }
 
 void SDLHostInterface::DoChangeDisc()
@@ -1527,47 +1434,7 @@ void SDLHostInterface::DoChangeDisc()
   else
     AddOSDMessage("Failed to switch CD. The log may contain further information.");
 
-  if (m_system)
-    m_system->ResetPerformanceCounters();
-  ClearImGuiFocus();
-}
-
-void SDLHostInterface::DoLoadState(u32 index)
-{
-  if (HasSystem())
-  {
-    LoadState(GetSaveStateFilename(index).c_str());
-  }
-  else
-  {
-    if (!CreateSystem() || !BootSystem(nullptr, GetSaveStateFilename(index).c_str()))
-    {
-      DestroySystem();
-      return;
-    }
-  }
-
-  UpdateControllerMapping();
-  if (m_system)
-    m_system->ResetPerformanceCounters();
-  ClearImGuiFocus();
-}
-
-void SDLHostInterface::DoSaveState(u32 index)
-{
-  Assert(m_system);
-  SaveState(GetSaveStateFilename(index).c_str());
-  ClearImGuiFocus();
-}
-
-void SDLHostInterface::DoTogglePause()
-{
-  if (!m_system)
-    return;
-
-  m_paused = !m_paused;
-  if (!m_paused)
-    m_system->ResetPerformanceCounters();
+  m_system->ResetPerformanceCounters();
 }
 
 void SDLHostInterface::DoFrameStep()
@@ -1587,8 +1454,6 @@ void SDLHostInterface::DoToggleFullscreen()
 
 void SDLHostInterface::Run()
 {
-  m_audio_stream->PauseOutput(false);
-
   while (!m_quit_request)
   {
     for (;;)
@@ -1636,10 +1501,5 @@ void SDLHostInterface::Run()
 
   // Save state on exit so it can be resumed
   if (m_system)
-  {
-    if (!SaveState(RESUME_SAVESTATE_FILENAME))
-      ReportError("Saving state failed, you will not be able to resume this session.");
-
     DestroySystem();
-  }
 }

src/duckstation-sdl/sdl_host_interface.h

@@ -22,16 +22,22 @@ public:
   SDLHostInterface();
   ~SDLHostInterface();
 
-  static std::unique_ptr<SDLHostInterface> Create(const char* filename = nullptr, const char* exp1_filename = nullptr,
-                                                  const char* save_state_filename = nullptr);
-
-  static std::string GetSaveStateFilename(u32 index);
+  static std::unique_ptr<SDLHostInterface> Create();
 
   void ReportError(const char* message) override;
   void ReportMessage(const char* message) override;
 
   void Run();
 
+protected:
+  bool AcquireHostDisplay() override;
+  void ReleaseHostDisplay() override;
+  std::unique_ptr<AudioStream> CreateAudioStream(AudioBackend backend) override;
+
+  void OnSystemCreated() override;
+  void OnSystemPaused(bool paused) override;
+  void OnSystemDestroyed();
+
 private:
   enum class KeyboardControllerAction
   {
@@ -62,9 +68,6 @@ private:
     float last_rumble_strength;
   };
 
-  static constexpr u32 NUM_QUICK_SAVE_STATES = 10;
-  static constexpr char RESUME_SAVESTATE_FILENAME[] = "savestate_resume.bin";
-
   bool HasSystem() const { return static_cast<bool>(m_system); }
 
 #ifdef WIN32
@@ -78,26 +81,16 @@ private:
   bool CreateDisplay();
   void DestroyDisplay();
   void CreateImGuiContext();
-  void CreateAudioStream();
 
   void SaveSettings();
+  void QueueUpdateSettings();
 
-  void QueueSwitchGPURenderer();
-  void SwitchGPURenderer();
-  void SwitchAudioBackend();
   void UpdateFullscreen();
-  void UpdateControllerMapping();
 
   // We only pass mouse input through if it's grabbed
   void DrawImGui();
-  void DoPowerOff();
-  void DoResume();
   void DoStartDisc();
-  void DoStartBIOS();
   void DoChangeDisc();
-  void DoLoadState(u32 index);
-  void DoSaveState(u32 index);
-  void DoTogglePause();
   void DoFrameStep();
   void DoToggleFullscreen();
 
@@ -122,6 +115,7 @@ private:
   void DrawSettingsWindow();
   void DrawAboutWindow();
   bool DrawFileChooser(const char* label, std::string* path, const char* filter = nullptr);
+  void ClearImGuiFocus();
 
   SDL_Window* m_window = nullptr;
   std::unique_ptr<HostDisplayTexture> m_app_icon_texture;
@@ -132,7 +126,7 @@ private:
   std::array<s32, SDL_CONTROLLER_AXIS_MAX> m_controller_axis_mapping{};
   std::array<s32, SDL_CONTROLLER_BUTTON_MAX> m_controller_button_mapping{};
 
-  u32 m_switch_gpu_renderer_event_id = 0;
+  u32 m_update_settings_event_id = 0;
 
   bool m_quit_request = false;
   bool m_frame_step_request = false;