Misc: Slightly reduce include pollution from settings.h

That way the GPU thread copy doesn't need fields it never touches.

data/resources/gamedb.yaml

@@ -106687,6 +106687,8 @@ SCES-02403:
   controllers:
     - AnalogController
     - DigitalController
+  traits:
+    - ForcePGXPCPUMode # Fixes gaps in geometry.
   metadata:
     publisher: "Midway"
     developer: "Magenta Software Ltd. / Traveller's Tales"
@@ -106706,6 +106708,8 @@ SCES-03090:
   controllers:
     - AnalogController
     - DigitalController
+  traits:
+    - ForcePGXPCPUMode # Fixes gaps in geometry.
   metadata:
     publisher: "Midway"
     developer: "Magenta Software Ltd. / Traveller's Tales"
@@ -106725,6 +106729,8 @@ SCES-03091:
   controllers:
     - AnalogController
     - DigitalController
+  traits:
+    - ForcePGXPCPUMode # Fixes gaps in geometry.
   metadata:
     publisher: "Midway"
     developer: "Magenta Software Ltd. / Traveller's Tales"
@@ -106744,6 +106750,8 @@ SCES-03092:
   controllers:
     - AnalogController
     - DigitalController
+  traits:
+    - ForcePGXPCPUMode # Fixes gaps in geometry.
   metadata:
     publisher: "Midway"
     developer: "Magenta Software Ltd. / Traveller's Tales"
@@ -106763,6 +106771,8 @@ SCES-03093:
   controllers:
     - AnalogController
     - DigitalController
+  traits:
+    - ForcePGXPCPUMode # Fixes gaps in geometry.
   metadata:
     publisher: "Midway"
     developer: "Magenta Software Ltd. / Traveller's Tales"
@@ -106782,6 +106792,8 @@ SLUS-01238:
   controllers:
     - AnalogController
     - DigitalController
+  traits:
+    - ForcePGXPCPUMode # Fixes gaps in geometry.
   metadata:
     publisher: "Midway"
     developer: "Magenta Software Ltd. / Traveller's Tales"

src/core/achievements.cpp

@@ -2185,12 +2185,7 @@ void Achievements::ConfirmHardcoreModeDisableAsync(const char* trigger, std::fun
 
 void Achievements::ClearUIState()
 {
-#ifndef __ANDROID__
-  if (FullscreenUI::IsAchievementsWindowOpen() || FullscreenUI::IsLeaderboardsWindowOpen())
-    FullscreenUI::ReturnToPreviousWindow();
-
   CloseLeaderboard();
-#endif
 
   s_state.achievement_badge_paths = {};
 
@@ -2470,11 +2465,15 @@ void Achievements::DrawAchievementsWindow()
   using ImGuiFullscreen::LayoutScale;
   using ImGuiFullscreen::UIStyle;
 
-  if (!s_state.achievement_list)
-    return;
-
   auto lock = Achievements::GetLock();
 
+  // achievements can get turned off via the main UI
+  if (!s_state.achievement_list)
+  {
+    FullscreenUI::ReturnToPreviousWindow();
+    return;
+  }
+
   static constexpr float alpha = 0.8f;
   static constexpr float heading_alpha = 0.95f;
   static constexpr float heading_height_unscaled = 110.0f;
@@ -2846,7 +2845,12 @@ void Achievements::DrawLeaderboardsWindow()
   static constexpr float heading_height_unscaled = 110.0f;
   static constexpr float tab_height_unscaled = 50.0f;
 
-  auto lock = Achievements::GetLock();
+  const auto lock = Achievements::GetLock();
+  if (!s_state.leaderboard_list)
+  {
+    FullscreenUI::ReturnToPreviousWindow();
+    return;
+  }
 
   const bool is_leaderboard_open = (s_state.open_leaderboard != nullptr);
   bool close_leaderboard_on_exit = false;
@@ -3437,7 +3441,6 @@ void Achievements::CloseLeaderboard()
   }
 
   s_state.open_leaderboard = nullptr;
-  ImGuiFullscreen::QueueResetFocus(ImGuiFullscreen::FocusResetType::Other);
 }
 
 #if defined(_WIN32)

src/core/analog_joystick.cpp

@@ -10,6 +10,7 @@
 
 #include "common/bitutils.h"
 #include "common/log.h"
+#include "common/settings_interface.h"
 #include "common/string_util.h"
 
 #include "IconsFontAwesome5.h"
@@ -340,14 +341,14 @@ std::unique_ptr<AnalogJoystick> AnalogJoystick::Create(u32 index)
 
 static const Controller::ControllerBindingInfo s_binding_info[] = {
 #define BUTTON(name, display_name, icon_name, button, genb)                                                            \
-  {                                                                                                                    \
+  {name, display_name, icon_name, static_cast<u32>(button), InputBindingInfo::Type::Button, genb}
-    name, display_name, icon_name, static_cast<u32>(button), InputBindingInfo::Type::Button, genb                      \
-  }
 #define AXIS(name, display_name, icon_name, halfaxis, genb)                                                            \
-  {                                                                                                                    \
+  {name,                                                                                                               \
-    name, display_name, icon_name, static_cast<u32>(AnalogJoystick::Button::Count) + static_cast<u32>(halfaxis),       \
+   display_name,                                                                                                       \
-      InputBindingInfo::Type::HalfAxis, genb                                                                           \
+   icon_name,                                                                                                          \
-  }
+   static_cast<u32>(AnalogJoystick::Button::Count) + static_cast<u32>(halfaxis),                                       \
+   InputBindingInfo::Type::HalfAxis,                                                                                   \
+   genb}
 
   // clang-format off
   BUTTON("Up", TRANSLATE_NOOP("AnalogJoystick", "D-Pad Up"), ICON_PF_DPAD_UP, AnalogJoystick::Button::Up, GenericInputBinding::DPadUp),

src/core/bus.cpp

@@ -1875,7 +1875,7 @@ template<MemoryAccessSize size>
 u32 Bus::HWHandlers::GPURead(PhysicalMemoryAddress address)
 {
   const u32 offset = address & GPU_MASK;
-  u32 value = g_gpu->ReadRegister(FIXUP_WORD_OFFSET(size, offset));
+  u32 value = g_gpu.ReadRegister(FIXUP_WORD_OFFSET(size, offset));
   value = FIXUP_WORD_READ_VALUE(size, offset, value);
   BUS_CYCLES(2);
   return value;
@@ -1885,7 +1885,7 @@ template<MemoryAccessSize size>
 void Bus::HWHandlers::GPUWrite(PhysicalMemoryAddress address, u32 value)
 {
   const u32 offset = address & GPU_MASK;
-  g_gpu->WriteRegister(FIXUP_WORD_OFFSET(size, offset), FIXUP_WORD_WRITE_VALUE(size, offset, value));
+  g_gpu.WriteRegister(FIXUP_WORD_OFFSET(size, offset), FIXUP_WORD_WRITE_VALUE(size, offset, value));
 }
 
 template<MemoryAccessSize size>

src/core/cheats.cpp

@@ -17,6 +17,7 @@
 #include "common/file_system.h"
 #include "common/log.h"
 #include "common/path.h"
+#include "common/settings_interface.h"
 #include "common/small_string.h"
 #include "common/string_util.h"
 #include "common/zip_helpers.h"

src/core/cpu_recompiler_x64.cpp

@@ -12,6 +12,7 @@
 #include "common/align.h"
 #include "common/assert.h"
 #include "common/log.h"
+#include "common/small_string.h"
 #include "common/string_util.h"
 
 #include <limits>

src/core/dma.cpp

@@ -802,9 +802,9 @@ TickCount DMA::TransferMemoryToDevice(u32 address, u32 increment, u32 word_count
   {
     case Channel::GPU:
     {
-      if (g_gpu->BeginDMAWrite()) [[likely]]
+      if (g_gpu.BeginDMAWrite()) [[likely]]
       {
-        if (GPUDump::Recorder* dump = g_gpu->GetGPUDump()) [[unlikely]]
+        if (GPUDump::Recorder* dump = g_gpu.GetGPUDump()) [[unlikely]]
         {
           // No wraparound?
           dump->BeginGP0Packet(word_count);
@@ -831,10 +831,10 @@ TickCount DMA::TransferMemoryToDevice(u32 address, u32 increment, u32 word_count
         {
           u32 value;
           std::memcpy(&value, &ram_pointer[address], sizeof(u32));
-          g_gpu->DMAWrite(address, value);
+          g_gpu.DMAWrite(address, value);
           address = (address + increment) & mask;
         }
-        g_gpu->EndDMAWrite();
+        g_gpu.EndDMAWrite();
       }
     }
     break;
@@ -900,7 +900,7 @@ TickCount DMA::TransferDeviceToMemory(u32 address, u32 increment, u32 word_count
   switch (channel)
   {
     case Channel::GPU:
-      g_gpu->DMARead(dest_pointer, word_count);
+      g_gpu.DMARead(dest_pointer, word_count);
       break;
 
     case Channel::CDROM:

src/core/fullscreen_ui.cpp

@@ -632,27 +632,9 @@ bool FullscreenUI::AreAnyDialogsOpen()
           ImGuiFullscreen::IsFileSelectorOpen());
 }
 
-void FullscreenUI::CheckForConfigChanges(const Settings& old_settings)
+void FullscreenUI::CheckForConfigChanges(const GPUSettings& old_settings)
 {
-  // NOTE: Called on CPU thread.
+  // NOTE: Called on GPU thread.
-  if (!IsInitialized())
-    return;
-
-  // If achievements got disabled, we might have the menu open...
-  // That means we're going to be reading achievement state.
-  if (old_settings.achievements_enabled && !g_settings.achievements_enabled)
-  {
-    if (!IsInitialized())
-      return;
-
-    GPUThread::RunOnThread([]() {
-      if (s_state.current_main_window == MainWindowType::Achievements ||
-          s_state.current_main_window == MainWindowType::Leaderboards)
-      {
-        ReturnToPreviousWindow();
-      }
-    });
-  }
 }
 
 void FullscreenUI::UpdateRunIdleState()
@@ -7635,11 +7617,6 @@ void FullscreenUI::OpenAchievementsWindow()
   });
 }
 
-bool FullscreenUI::IsAchievementsWindowOpen()
-{
-  return (s_state.current_main_window == MainWindowType::Achievements);
-}
-
 void FullscreenUI::OpenLeaderboardsWindow()
 {
   if (!System::IsValid())
@@ -7674,11 +7651,6 @@ void FullscreenUI::OpenLeaderboardsWindow()
   });
 }
 
-bool FullscreenUI::IsLeaderboardsWindowOpen()
-{
-  return (s_state.current_main_window == MainWindowType::Leaderboards);
-}
-
 #endif // __ANDROID__
 
 LoadingScreenProgressCallback::LoadingScreenProgressCallback()

src/core/fullscreen_ui.h

@@ -13,13 +13,13 @@
 
 class SmallStringBase;
 
-struct Settings;
+struct GPUSettings;
 
 namespace FullscreenUI {
 bool Initialize();
 bool IsInitialized();
 bool HasActiveWindow();
-void CheckForConfigChanges(const Settings& old_settings);
+void CheckForConfigChanges(const GPUSettings& old_settings);
 void OnSystemStarted();
 void OnSystemResumed();
 void OnSystemDestroyed();
@@ -29,9 +29,7 @@ void OnRunningGameChanged();
 void OpenPauseMenu();
 void OpenCheatsMenu();
 void OpenAchievementsWindow();
-bool IsAchievementsWindowOpen();
 void OpenLeaderboardsWindow();
-bool IsLeaderboardsWindowOpen();
 void ReturnToMainWindow();
 void ReturnToPreviousWindow();
 void SetStandardSelectionFooterText(bool back_instead_of_cancel);

src/core/gpu.cpp

@@ -45,7 +45,7 @@
 
 LOG_CHANNEL(GPU);
 
-std::unique_ptr<GPU> g_gpu;
+ALIGN_TO_CACHE_LINE GPU g_gpu;
 
 // aligning VRAM to 4K is fine, since the ARM64 instructions compute 4K page aligned addresses
 // or it would be, except we want to import the memory for readbacks on metal..
@@ -60,13 +60,13 @@ u16 g_gpu_clut[GPU_CLUT_SIZE];
 const GPU::GP0CommandHandlerTable GPU::s_GP0_command_handler_table = GPU::GenerateGP0CommandHandlerTable();
 
 static TimingEvent s_crtc_tick_event(
-  "GPU CRTC Tick", 1, 1, [](void* param, TickCount ticks, TickCount ticks_late) { g_gpu->CRTCTickEvent(ticks); },
+  "GPU CRTC Tick", 1, 1, [](void* param, TickCount ticks, TickCount ticks_late) { g_gpu.CRTCTickEvent(ticks); },
   nullptr);
 static TimingEvent s_command_tick_event(
-  "GPU Command Tick", 1, 1, [](void* param, TickCount ticks, TickCount ticks_late) { g_gpu->CommandTickEvent(ticks); },
+  "GPU Command Tick", 1, 1, [](void* param, TickCount ticks, TickCount ticks_late) { g_gpu.CommandTickEvent(ticks); },
   nullptr);
 static TimingEvent s_frame_done_event(
-  "Frame Done", 1, 1, [](void* param, TickCount ticks, TickCount ticks_late) { g_gpu->FrameDoneEvent(ticks); },
+  "Frame Done", 1, 1, [](void* param, TickCount ticks, TickCount ticks_late) { g_gpu.FrameDoneEvent(ticks); },
   nullptr);
 
 // #define PSX_GPU_STATS
@@ -77,14 +77,7 @@ static u32 s_active_gpu_cycles_frames = 0;
 
 GPU::GPU() = default;
 
-GPU::~GPU()
+GPU::~GPU() = default;
-{
-  s_command_tick_event.Deactivate();
-  s_crtc_tick_event.Deactivate();
-  s_frame_done_event.Deactivate();
-
-  StopRecordingGPUDump();
-}
 
 void GPU::Initialize()
 {
@@ -104,6 +97,15 @@ void GPU::Initialize()
 #endif
 }
 
+void GPU::Shutdown()
+{
+  s_command_tick_event.Deactivate();
+  s_crtc_tick_event.Deactivate();
+  s_frame_done_event.Deactivate();
+
+  StopRecordingGPUDump();
+}
+
 void GPU::UpdateSettings(const Settings& old_settings)
 {
   m_force_progressive_scan = (g_settings.display_deinterlacing_mode == DisplayDeinterlacingMode::Progressive);

src/core/gpu.h

@@ -95,6 +95,7 @@ public:
   ~GPU();
 
   void Initialize();
+  void Shutdown();
   void Reset(bool clear_vram);
   bool DoState(StateWrapper& sw, bool update_display);
   void DoMemoryState(StateWrapper& sw, System::MemorySaveState& mss, bool update_display);
@@ -561,6 +562,6 @@ private:
   static const GP0CommandHandlerTable s_GP0_command_handler_table;
 };
 
-extern std::unique_ptr<GPU> g_gpu;
+extern GPU g_gpu;
 extern u16 g_vram[VRAM_SIZE / sizeof(u16)];
 extern u16 g_gpu_clut[GPU_CLUT_SIZE];

src/core/gpu_backend.cpp

@@ -103,7 +103,7 @@ bool GPUBackend::Initialize(bool clear_vram, Error* error)
   return true;
 }
 
-void GPUBackend::UpdateSettings(const Settings& old_settings)
+void GPUBackend::UpdateSettings(const GPUSettings& old_settings)
 {
   FlushRender();
 
@@ -774,8 +774,8 @@ GPUDevice::PresentResult GPUBackend::PresentDisplay()
   GSVector4i display_rect;
   GSVector4i draw_rect;
   CalculateDrawRect(g_gpu_device->GetMainSwapChain()->GetWidth(), g_gpu_device->GetMainSwapChain()->GetHeight(),
-                    !g_gpu_settings.debugging.show_vram, true, &display_rect, &draw_rect);
+                    !g_gpu_settings.gpu_show_vram, true, &display_rect, &draw_rect);
-  return RenderDisplay(nullptr, display_rect, draw_rect, !g_gpu_settings.debugging.show_vram);
+  return RenderDisplay(nullptr, display_rect, draw_rect, !g_gpu_settings.gpu_show_vram);
 }
 
 GPUDevice::PresentResult GPUBackend::RenderDisplay(GPUTexture* target, const GSVector4i display_rect,
@@ -943,7 +943,7 @@ GPUDevice::PresentResult GPUBackend::RenderDisplay(GPUTexture* target, const GSV
 
   if (really_postfx)
   {
-    DebugAssert(!g_gpu_settings.debugging.show_vram);
+    DebugAssert(!g_gpu_settings.gpu_show_vram);
 
     // "original size" in postfx includes padding.
     const float upscale_x =
@@ -978,7 +978,7 @@ void GPUBackend::SendDisplayToMediaCapture(MediaCapture* cap)
     (g_gpu_settings.display_screenshot_mode != DisplayScreenshotMode::UncorrectedInternalResolution);
   const bool postfx = (g_gpu_settings.display_screenshot_mode != DisplayScreenshotMode::InternalResolution);
   GSVector4i display_rect, draw_rect;
-  CalculateDrawRect(target->GetWidth(), target->GetHeight(), !g_gpu_settings.debugging.show_vram, apply_aspect_ratio,
+  CalculateDrawRect(target->GetWidth(), target->GetHeight(), !g_gpu_settings.gpu_show_vram, apply_aspect_ratio,
                     &display_rect, &draw_rect);
 
   // Not cleared by RenderDisplay().
@@ -1228,7 +1228,7 @@ void GPUBackend::CalculateDrawRect(s32 window_width, s32 window_height, bool app
 {
   const bool integer_scale = (g_gpu_settings.display_scaling == DisplayScalingMode::NearestInteger ||
                               g_gpu_settings.display_scaling == DisplayScalingMode::BilinearInteger);
-  const bool show_vram = g_gpu_settings.debugging.show_vram;
+  const bool show_vram = g_gpu_settings.gpu_show_vram;
   const u32 display_width = show_vram ? VRAM_WIDTH : m_display_width;
   const u32 display_height = show_vram ? VRAM_HEIGHT : m_display_height;
   const s32 display_origin_left = show_vram ? 0 : m_display_origin_left;
@@ -1421,15 +1421,14 @@ bool GPUBackend::RenderScreenshotToBuffer(u32 width, u32 height, const GSVector4
 void GPUBackend::CalculateScreenshotSize(DisplayScreenshotMode mode, u32* width, u32* height, GSVector4i* display_rect,
                                          GSVector4i* draw_rect) const
 {
-  const bool internal_resolution =
+  const bool internal_resolution = (mode != DisplayScreenshotMode::ScreenResolution || g_gpu_settings.gpu_show_vram);
-    (mode != DisplayScreenshotMode::ScreenResolution || g_gpu_settings.debugging.show_vram);
   if (internal_resolution && m_display_texture_view_width != 0 && m_display_texture_view_height != 0)
   {
     if (mode == DisplayScreenshotMode::InternalResolution)
     {
       float f_width = static_cast<float>(m_display_texture_view_width);
       float f_height = static_cast<float>(m_display_texture_view_height);
-      if (!g_gpu_settings.debugging.show_vram)
+      if (!g_gpu_settings.gpu_show_vram)
         GPU::ApplyPixelAspectRatioToSize(m_display_pixel_aspect_ratio, &f_width, &f_height);
 
       // DX11 won't go past 16K texture size.
@@ -1462,7 +1461,7 @@ void GPUBackend::CalculateScreenshotSize(DisplayScreenshotMode mode, u32* width,
   {
     *width = g_gpu_device->HasMainSwapChain() ? g_gpu_device->GetMainSwapChain()->GetWidth() : 1;
     *height = g_gpu_device->HasMainSwapChain() ? g_gpu_device->GetMainSwapChain()->GetHeight() : 1;
-    CalculateDrawRect(*width, *height, true, !g_settings.debugging.show_vram, display_rect, draw_rect);
+    CalculateDrawRect(*width, *height, true, !g_settings.gpu_show_vram, display_rect, draw_rect);
   }
 }
 

src/core/gpu_backend.h

@@ -22,7 +22,7 @@ class SmallStringBase;
 class GPUFramebuffer;
 class GPUPipeline;
 
-struct Settings;
+struct GPUSettings;
 class StateWrapper;
 
 namespace System {
@@ -77,7 +77,7 @@ public:
 
   virtual bool Initialize(bool upload_vram, Error* error);
 
-  virtual void UpdateSettings(const Settings& old_settings);
+  virtual void UpdateSettings(const GPUSettings& old_settings);
 
   /// Returns the current resolution scale.
   virtual u32 GetResolutionScale() const = 0;

src/core/gpu_commands.cpp

@@ -931,7 +931,7 @@ void GPU::FinishVRAMWrite()
 
   if (m_blit_remaining_words == 0)
   {
-    if (g_settings.debugging.dump_cpu_to_vram_copies)
+    if (g_settings.gpu_dump_cpu_to_vram_copies)
     {
       DumpVRAMToFile(TinyString::from_format("cpu_to_vram_copy_{}.png", s_cpu_to_vram_dump_id++), m_vram_transfer.width,
                      m_vram_transfer.height, sizeof(u16) * m_vram_transfer.width, m_blit_buffer.data(), true);
@@ -995,7 +995,7 @@ bool GPU::HandleCopyRectangleVRAMToCPUCommand()
   // ensure VRAM shadow is up to date
   ReadVRAM(m_vram_transfer.x, m_vram_transfer.y, m_vram_transfer.width, m_vram_transfer.height);
 
-  if (g_settings.debugging.dump_vram_to_cpu_copies)
+  if (g_settings.gpu_dump_vram_to_cpu_copies)
   {
     DumpVRAMToFile(TinyString::from_format("vram_to_cpu_copy_{}.png", s_vram_to_cpu_dump_id++), m_vram_transfer.width,
                    m_vram_transfer.height, sizeof(u16) * VRAM_WIDTH,

src/core/gpu_dump.cpp

@@ -76,7 +76,7 @@ std::unique_ptr<GPUDump::Recorder> GPUDump::Recorder::Create(std::string path, s
 
   ret = std::unique_ptr<Recorder>(new Recorder(std::move(fp), num_frames, std::move(path)));
   ret->WriteHeaders(serial);
-  g_gpu->WriteCurrentVideoModeToDump(ret.get());
+  g_gpu.WriteCurrentVideoModeToDump(ret.get());
   ret->WriteCurrentVRAM();
 
   // Write start of stream.
@@ -285,7 +285,7 @@ void GPUDump::Recorder::WriteHeaders(std::string_view serial)
 
   // Write textual video mode.
   BeginPacket(PacketType::TextualVideoFormat);
-  WriteString(g_gpu->IsInPALMode() ? "PAL" : "NTSC");
+  WriteString(g_gpu.IsInPALMode() ? "PAL" : "NTSC");
   EndPacket();
 
   // Write DuckStation version.
@@ -520,7 +520,7 @@ void GPUDump::Player::ProcessPacket(const PacketRef& pkt)
   if (pkt.type <= PacketType::VSyncEvent)
   {
     // gp0/gp1/vsync => direct to gpu
-    g_gpu->ProcessGPUDumpPacket(pkt.type, pkt.data);
+    g_gpu.ProcessGPUDumpPacket(pkt.type, pkt.data);
     return;
   }
 }

src/core/gpu_hw.cpp

@@ -439,7 +439,7 @@ void GPU_HW::RestoreDeviceContext()
   m_batch_ubo_dirty = true;
 }
 
-void GPU_HW::UpdateSettings(const Settings& old_settings)
+void GPU_HW::UpdateSettings(const GPUSettings& old_settings)
 {
   GPUBackend::UpdateSettings(old_settings);
 
@@ -3669,7 +3669,7 @@ void GPU_HW::UpdateDisplay(const GPUBackendUpdateDisplayCommand* cmd)
 
   GPUTextureCache::Compact();
 
-  if (g_gpu_settings.debugging.show_vram)
+  if (g_gpu_settings.gpu_show_vram)
   {
     if (IsUsingMultisampling())
     {

src/core/gpu_hw.h

@@ -72,7 +72,7 @@ public:
   void RestoreDeviceContext() override;
 
 protected:
-  void UpdateSettings(const Settings& old_settings) override;
+  void UpdateSettings(const GPUSettings& old_settings) override;
 
   void UpdateResolutionScale() override;
 

src/core/gpu_hw_texture_cache.cpp

@@ -590,7 +590,7 @@ bool GPUTextureCache::Initialize(GPU_HW* backend)
   return true;
 }
 
-void GPUTextureCache::UpdateSettings(bool use_texture_cache, const Settings& old_settings)
+void GPUTextureCache::UpdateSettings(bool use_texture_cache, const GPUSettings& old_settings)
 {
   if (use_texture_cache)
   {
@@ -3483,7 +3483,6 @@ void GPUTextureCache::ReloadTextureReplacements(bool show_info)
 
   PurgeUnreferencedTexturesFromCache();
 
-  DebugAssert(g_gpu);
   UpdateVRAMTrackingState();
   InvalidateSources();
 

src/core/gpu_hw_texture_cache.h

@@ -9,7 +9,7 @@ class Image;
 class GPUTexture;
 class StateWrapper;
 
-struct Settings;
+struct GPUSettings;
 class GPU_HW;
 
 //////////////////////////////////////////////////////////////////////////
@@ -104,7 +104,7 @@ struct Source
 };
 
 bool Initialize(GPU_HW* backend);
-void UpdateSettings(bool use_texture_cache, const Settings& old_settings);
+void UpdateSettings(bool use_texture_cache, const GPUSettings& old_settings);
 
 bool GetStateSize(StateWrapper& sw, u32* size);
 bool DoState(StateWrapper& sw, bool skip);

src/core/gpu_sw.cpp

@@ -356,7 +356,7 @@ bool GPU_SW::CopyOut(u32 src_x, u32 src_y, u32 skip_x, u32 width, u32 height, u3
 
 void GPU_SW::UpdateDisplay(const GPUBackendUpdateDisplayCommand* cmd)
 {
-  if (!g_settings.debugging.show_vram)
+  if (!g_settings.gpu_show_vram)
   {
     if (cmd->display_disabled)
     {

src/core/gpu_sw_rasterizer.inl

@@ -506,10 +506,11 @@ struct PixelVectors
 } // namespace
 
 template<bool texture_enable, bool raw_texture_enable, bool transparency_enable>
-ALWAYS_INLINE_RELEASE static void
+ALWAYS_INLINE_RELEASE static void ShadePixel(const PixelVectors<texture_enable>& RESTRICT pv,
-ShadePixel(const PixelVectors<texture_enable>& pv, GPUTextureMode texture_mode, GPUTransparencyMode transparency_mode,
+                                             GPUTextureMode texture_mode, GPUTransparencyMode transparency_mode,
-           u32 start_x, u32 y, GSVectorNi vertex_color_rg, GSVectorNi vertex_color_ba, GSVectorNi texcoord_x,
+                                             u32 start_x, u32 y, GSVectorNi vertex_color_rg, GSVectorNi vertex_color_ba,
-           GSVectorNi texcoord_y, GSVectorNi preserve_mask, GSVectorNi dither)
+                                             GSVectorNi texcoord_x, GSVectorNi texcoord_y, GSVectorNi preserve_mask,
+                                             GSVectorNi dither)
 {
   static constexpr GSVectorNi coord_mask_x = GSVectorNi::cxpr(VRAM_WIDTH_MASK);
   static constexpr GSVectorNi coord_mask_y = GSVectorNi::cxpr(VRAM_HEIGHT_MASK);
@@ -693,7 +694,7 @@ ShadePixel(const PixelVectors<texture_enable>& pv, GPUTextureMode texture_mode,
 }
 
 template<bool texture_enable, bool raw_texture_enable, bool transparency_enable>
-static void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
+static void DrawRectangle(const GPUBackendDrawRectangleCommand* RESTRICT cmd)
 {
   const s32 origin_x = cmd->x;
   const s32 origin_y = cmd->y;
@@ -765,8 +766,9 @@ static void DrawRectangle(const GPUBackendDrawRectangleCommand* cmd)
 
 // TODO: Vectorize line draw.
 template<bool shading_enable, bool transparency_enable>
-static void DrawLine(const GPUBackendDrawLineCommand* cmd, const GPUBackendDrawLineCommand::Vertex* p0,
+static void DrawLine(const GPUBackendDrawLineCommand* RESTRICT cmd,
-                     const GPUBackendDrawLineCommand::Vertex* p1)
+                     const GPUBackendDrawLineCommand::Vertex* RESTRICT p0,
+                     const GPUBackendDrawLineCommand::Vertex* RESTRICT p1)
 {
   static constexpr u32 XY_SHIFT = 32;
   static constexpr u32 RGB_SHIFT = 12;
@@ -971,8 +973,8 @@ struct TrianglePart
 #ifndef USE_VECTOR
 
 template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
-static void DrawSpan(const GPUBackendDrawCommand* cmd, s32 y, s32 x_start, s32 x_bound, UVStepper uv,
+static void DrawSpan(const GPUBackendDrawCommand* RESTRICT cmd, s32 y, s32 x_start, s32 x_bound, UVStepper uv,
-                     const UVSteps& uvstep, RGBStepper rgb, const RGBSteps& rgbstep)
+                     const UVSteps& RESTRICT uvstep, RGBStepper rgb, const RGBSteps& RESTRICT rgbstep)
 {
   s32 width = x_bound - x_start;
   s32 current_x = TruncateGPUVertexPosition(x_start);
@@ -1011,9 +1013,10 @@ static void DrawSpan(const GPUBackendDrawCommand* cmd, s32 y, s32 x_start, s32 x
 }
 
 template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
-ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawCommand* cmd, const TrianglePart& tp,
+ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawCommand* RESTRICT cmd,
-                                                   const UVStepper& uv, const UVSteps& uvstep, const RGBStepper& rgb,
+                                                   const TrianglePart& RESTRICT tp, const UVStepper& RESTRICT uv,
-                                                   const RGBSteps& rgbstep)
+                                                   const UVSteps& RESTRICT uvstep, const RGBStepper& RESTRICT rgb,
+                                                   const RGBSteps& RESTRICT rgbstep)
 {
   static constexpr auto unfp_xy = [](s64 xfp) -> s32 { return static_cast<s32>(static_cast<u64>(xfp) >> 32); };
 
@@ -1150,9 +1153,10 @@ struct TriangleVectors : PixelVectors<texture_enable>
 } // namespace
 
 template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
-ALWAYS_INLINE_RELEASE static void DrawSpan(const GPUBackendDrawCommand* cmd, s32 y, s32 x_start, s32 x_bound,
+ALWAYS_INLINE_RELEASE static void DrawSpan(const GPUBackendDrawCommand* RESTRICT cmd, s32 y, s32 x_start, s32 x_bound,
-                                           UVStepper uv, const UVSteps& uvstep, RGBStepper rgb, const RGBSteps& rgbstep,
+                                           UVStepper uv, const UVSteps& RESTRICT uvstep, RGBStepper rgb,
-                                           const TriangleVectors<shading_enable, texture_enable>& tv)
+                                           const RGBSteps& RESTRICT rgbstep,
+                                           const TriangleVectors<shading_enable, texture_enable>& RESTRICT tv)
 {
   s32 width = x_bound - x_start;
   s32 current_x = TruncateGPUVertexPosition(x_start);
@@ -1255,9 +1259,10 @@ ALWAYS_INLINE_RELEASE static void DrawSpan(const GPUBackendDrawCommand* cmd, s32
 }
 
 template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
-ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawCommand* cmd, const TrianglePart& tp,
+ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawCommand* RESTRICT cmd,
-                                                   const UVStepper& uv, const UVSteps& uvstep, const RGBStepper& rgb,
+                                                   const TrianglePart& RESTRICT tp, const UVStepper& RESTRICT uv,
-                                                   const RGBSteps& rgbstep)
+                                                   const UVSteps& RESTRICT uvstep, const RGBStepper& RESTRICT rgb,
+                                                   const RGBSteps& RESTRICT rgbstep)
 {
   static constexpr auto unfp_xy = [](s64 xfp) -> s32 { return static_cast<s32>(static_cast<u64>(xfp) >> 32); };
 
@@ -1356,13 +1361,15 @@ ALWAYS_INLINE_RELEASE static void DrawTrianglePart(const GPUBackendDrawCommand*
 #endif // USE_VECTOR
 
 template<bool shading_enable, bool texture_enable, bool raw_texture_enable, bool transparency_enable>
-static void DrawTriangle(const GPUBackendDrawCommand* cmd, const GPUBackendDrawPolygonCommand::Vertex* v0,
+static void DrawTriangle(const GPUBackendDrawCommand* RESTRICT cmd,
-                         const GPUBackendDrawPolygonCommand::Vertex* v1, const GPUBackendDrawPolygonCommand::Vertex* v2)
+                         const GPUBackendDrawPolygonCommand::Vertex* RESTRICT v0,
+                         const GPUBackendDrawPolygonCommand::Vertex* RESTRICT v1,
+                         const GPUBackendDrawPolygonCommand::Vertex* RESTRICT v2)
 {
 #ifdef CHECK_VECTOR
-  const GPUBackendDrawPolygonCommand::Vertex* orig_v0 = v0;
+  const GPUBackendDrawPolygonCommand::Vertex* RESTRICT orig_v0 = v0;
-  const GPUBackendDrawPolygonCommand::Vertex* orig_v1 = v1;
+  const GPUBackendDrawPolygonCommand::Vertex* RESTRICT orig_v1 = v1;
-  const GPUBackendDrawPolygonCommand::Vertex* orig_v2 = v2;
+  const GPUBackendDrawPolygonCommand::Vertex* RESTRICT orig_v2 = v2;
 #endif
 
   // Sort vertices so that v0 is the top vertex, v1 is the bottom vertex, and v2 is the side vertex.
@@ -1417,8 +1424,8 @@ static void DrawTriangle(const GPUBackendDrawCommand* cmd, const GPUBackendDrawP
   const u32 ofi = BoolToUInt32(!right_facing);
 
   TrianglePart triparts[2];
-  TrianglePart& tpo = triparts[vo];
+  TrianglePart& RESTRICT tpo = triparts[vo];
-  TrianglePart& tpp = triparts[vo ^ 1];
+  TrianglePart& RESTRICT tpp = triparts[vo ^ 1];
   tpo.start_y = vertices[0 ^ vo]->y;
   tpo.end_y = vertices[1 ^ vo]->y;
   tpp.start_y = vertices[1 ^ vp]->y;
@@ -1469,7 +1476,7 @@ static void DrawTriangle(const GPUBackendDrawCommand* cmd, const GPUBackendDrawP
   // Undo the start of the vertex, so that when we add the offset for each line, it starts at the beginning value.
   UVStepper uv;
   RGBStepper rgb;
-  const GPUBackendDrawPolygonCommand::Vertex* top_left_vertex = vertices[tl];
+  const GPUBackendDrawPolygonCommand::Vertex* RESTRICT top_left_vertex = vertices[tl];
   if constexpr (texture_enable)
   {
     uv.Init(top_left_vertex->u, top_left_vertex->v);
@@ -1542,7 +1549,7 @@ static void FillVRAMImpl(u32 x, u32 y, u32 width, u32 height, u32 color, bool in
     {
       const u32 row = (y + yoffs) % VRAM_HEIGHT;
 
-      u16* row_ptr = &g_vram[row * VRAM_WIDTH + x];
+      u16* RESTRICT row_ptr = &g_vram[row * VRAM_WIDTH + x];
       u32 xoffs = 0;
       for (; xoffs < aligned_width; xoffs += vector_width, row_ptr += vector_width)
         GSVector4i::store<false>(row_ptr, fill);
@@ -1563,7 +1570,7 @@ static void FillVRAMImpl(u32 x, u32 y, u32 width, u32 height, u32 color, bool in
         if ((row & u32(1)) == active_field)
           continue;
 
-        u16* row_ptr = &g_vram[row * VRAM_WIDTH + x];
+        u16* RESTRICT row_ptr = &g_vram[row * VRAM_WIDTH + x];
         u32 xoffs = 0;
         for (; xoffs < aligned_width; xoffs += vector_width, row_ptr += vector_width)
           GSVector4i::store<false>(row_ptr, fill);
@@ -1579,7 +1586,7 @@ static void FillVRAMImpl(u32 x, u32 y, u32 width, u32 height, u32 color, bool in
         if ((row & u32(1)) == active_field)
           continue;
 
-        u16* row_ptr = &g_vram[row * VRAM_WIDTH];
+        u16* RESTRICT row_ptr = &g_vram[row * VRAM_WIDTH];
         for (u32 xoffs = 0; xoffs < width; xoffs++)
         {
           const u32 col = (x + xoffs) % VRAM_WIDTH;
@@ -1593,7 +1600,7 @@ static void FillVRAMImpl(u32 x, u32 y, u32 width, u32 height, u32 color, bool in
     for (u32 yoffs = 0; yoffs < height; yoffs++)
     {
       const u32 row = (y + yoffs) % VRAM_HEIGHT;
-      u16* row_ptr = &g_vram[row * VRAM_WIDTH];
+      u16* RESTRICT row_ptr = &g_vram[row * VRAM_WIDTH];
       for (u32 xoffs = 0; xoffs < width; xoffs++)
       {
         const u32 col = (x + xoffs) % VRAM_WIDTH;
@@ -1622,7 +1629,7 @@ static void FillVRAMImpl(u32 x, u32 y, u32 width, u32 height, u32 color, bool in
       if ((row & u32(1)) == active_field)
         continue;
 
-      u16* row_ptr = &g_vram[row * VRAM_WIDTH];
+      u16* RESTRICT row_ptr = &g_vram[row * VRAM_WIDTH];
       for (u32 xoffs = 0; xoffs < width; xoffs++)
       {
         const u32 col = (x + xoffs) % VRAM_WIDTH;
@@ -1635,7 +1642,7 @@ static void FillVRAMImpl(u32 x, u32 y, u32 width, u32 height, u32 color, bool in
     for (u32 yoffs = 0; yoffs < height; yoffs++)
     {
       const u32 row = (y + yoffs) % VRAM_HEIGHT;
-      u16* row_ptr = &g_vram[row * VRAM_WIDTH];
+      u16* RESTRICT row_ptr = &g_vram[row * VRAM_WIDTH];
       for (u32 xoffs = 0; xoffs < width; xoffs++)
       {
         const u32 col = (x + xoffs) % VRAM_WIDTH;
@@ -1646,12 +1653,13 @@ static void FillVRAMImpl(u32 x, u32 y, u32 width, u32 height, u32 color, bool in
 #endif
 }
 
-static void WriteVRAMImpl(u32 x, u32 y, u32 width, u32 height, const void* data, bool set_mask, bool check_mask)
+static void WriteVRAMImpl(u32 x, u32 y, u32 width, u32 height, const void* RESTRICT data, bool set_mask,
+                          bool check_mask)
 {
   // Fast path when the copy is not oversized.
   if ((x + width) <= VRAM_WIDTH && (y + height) <= VRAM_HEIGHT && !set_mask && !check_mask)
   {
-    const u16* src_ptr = static_cast<const u16*>(data);
+    const u16* RESTRICT src_ptr = static_cast<const u16*>(data);
     u16* dst_ptr = &g_vram[y * VRAM_WIDTH + x];
     for (u32 yoffs = 0; yoffs < height; yoffs++)
     {
@@ -1664,7 +1672,7 @@ static void WriteVRAMImpl(u32 x, u32 y, u32 width, u32 height, const void* data,
   {
     // Slow path when we need to handle wrap-around.
     // During transfer/render operations, if ((dst_pixel & mask_and) == 0) { pixel = src_pixel | mask_or }
-    const u16* src_ptr = static_cast<const u16*>(data);
+    const u16* RESTRICT src_ptr = static_cast<const u16*>(data);
     const u16 mask_and = check_mask ? 0x8000u : 0x0000u;
     const u16 mask_or = set_mask ? 0x8000u : 0x0000u;
 
@@ -1713,7 +1721,7 @@ static void WriteVRAMImpl(u32 x, u32 y, u32 width, u32 height, const void* data,
       for (; col < width;)
       {
         // TODO: Handle unaligned reads...
-        u16* pixel_ptr = &dst_row_ptr[(x + col++) % VRAM_WIDTH];
+        u16* RESTRICT pixel_ptr = &dst_row_ptr[(x + col++) % VRAM_WIDTH];
         if (((*pixel_ptr) & mask_and) == 0)
           *pixel_ptr = *(src_ptr++) | mask_or;
       }

src/core/gpu_thread.cpp

@@ -36,9 +36,6 @@
 
 LOG_CHANNEL(GPUThread);
 
-// TODO: Smaller settings struct.
-// TODO: Remove g_gpu pointer.
-
 namespace GPUThread {
 enum : u32
 {
@@ -83,7 +80,7 @@ static void ReconfigureOnThread(GPUThreadReconfigureCommand* cmd);
 static bool CreateGPUBackendOnThread(GPURenderer renderer, bool upload_vram, Error* error);
 static void DestroyGPUBackendOnThread();
 
-static void UpdateSettingsOnThread(const Settings& old_settings);
+static void UpdateSettingsOnThread(const GPUSettings& old_settings);
 
 static void UpdateRunIdle();
 
@@ -932,7 +929,7 @@ void GPUThread::DestroyGPUBackendOnThread()
   s_state.gpu_backend.reset();
 }
 
-void GPUThread::UpdateSettingsOnThread(const Settings& old_settings)
+void GPUThread::UpdateSettingsOnThread(const GPUSettings& old_settings)
 {
   if (g_gpu_device)
   {
@@ -1008,7 +1005,7 @@ void GPUThread::UpdateSettings(bool gpu_settings_changed, bool device_settings_c
     RunOnThread([settings = g_settings]() {
       VERBOSE_LOG("Updating GPU settings on thread...");
 
-      Settings old_settings = std::move(g_gpu_settings);
+      GPUSettings old_settings = std::move(g_gpu_settings);
       g_gpu_settings = std::move(settings);
 
       UpdateSettingsOnThread(old_settings);

src/core/guncon.cpp

@@ -207,12 +207,12 @@ void GunCon::UpdatePosition()
   float display_x, display_y;
   const auto& [window_x, window_y] = (m_has_relative_binds) ? GetAbsolutePositionFromRelativeAxes() :
                                                               InputManager::GetPointerAbsolutePosition(m_cursor_index);
-  g_gpu->ConvertScreenCoordinatesToDisplayCoordinates(window_x, window_y, &display_x, &display_y);
+  g_gpu.ConvertScreenCoordinatesToDisplayCoordinates(window_x, window_y, &display_x, &display_y);
 
   // are we within the active display area?
   u32 tick, line;
   if (display_x < 0 || display_y < 0 ||
-      !g_gpu->ConvertDisplayCoordinatesToBeamTicksAndLines(display_x, display_y, m_x_scale, &tick, &line) ||
+      !g_gpu.ConvertDisplayCoordinatesToBeamTicksAndLines(display_x, display_y, m_x_scale, &tick, &line) ||
       m_shoot_offscreen)
   {
     DEBUG_LOG("Lightgun out of range for window coordinates {:.0f},{:.0f}", window_x, window_y);
@@ -222,7 +222,7 @@ void GunCon::UpdatePosition()
   }
 
   // 8MHz units for X = 44100*768*11/7 = 53222400 / 8000000 = 6.6528
-  const double divider = static_cast<double>(g_gpu->GetCRTCFrequency()) / 8000000.0;
+  const double divider = static_cast<double>(g_gpu.GetCRTCFrequency()) / 8000000.0;
   m_position_x = static_cast<u16>(static_cast<float>(tick) / static_cast<float>(divider));
   m_position_y = static_cast<u16>(line);
   DEBUG_LOG("Lightgun window coordinates {:.0f},{:.0f} -> tick {} line {} 8mhz ticks {}", display_x, display_y, tick,

src/core/imgui_overlays.cpp

@@ -85,7 +85,7 @@ static constexpr const char* DEBUG_WINDOW_CONFIG_SECTION = "DebugWindows";
 static constexpr const std::array<DebugWindowInfo, NUM_DEBUG_WINDOWS> s_debug_window_info = {{
   {"SPU", "SPU State", ":icons/applications-system.png", &SPU::DrawDebugStateWindow, 800, 915},
   {"CDROM", "CD-ROM State", ":icons/applications-system.png", &CDROM::DrawDebugWindow, 800, 540},
-  {"GPU", "GPU State", ":icons/applications-system.png", [](float sc) { g_gpu->DrawDebugStateWindow(sc); }, 450, 550},
+  {"GPU", "GPU State", ":icons/applications-system.png", [](float sc) { g_gpu.DrawDebugStateWindow(sc); }, 450, 550},
   {"DMA", "DMA State", ":icons/applications-system.png", &DMA::DrawDebugStateWindow, 860, 180},
   {"MDEC", "MDEC State", ":icons/applications-system.png", &MDEC::DrawDebugStateWindow, 300, 350},
   {"Timers", "Timers State", ":icons/applications-system.png", &Timers::DrawDebugStateWindow, 800, 95},
@@ -323,9 +323,9 @@ void ImGuiManager::DrawPerformanceOverlay(const GPUBackend* gpu, float& position
     if (g_gpu_settings.display_show_resolution)
     {
       const u32 resolution_scale = gpu->GetResolutionScale();
-      const auto [display_width, display_height] = g_gpu->GetFullDisplayResolution(); // NOTE: Racey read.
+      const auto [display_width, display_height] = g_gpu.GetFullDisplayResolution(); // NOTE: Racey read.
-      const bool interlaced = g_gpu->IsInterlacedDisplayEnabled();
+      const bool interlaced = g_gpu.IsInterlacedDisplayEnabled();
-      const bool pal = g_gpu->IsInPALMode();
+      const bool pal = g_gpu.IsInPALMode();
       text.format("{}x{} {} {} [{}x]", display_width * resolution_scale, display_height * resolution_scale,
                   pal ? "PAL" : "NTSC", interlaced ? "Interlaced" : "Progressive", resolution_scale);
       DRAW_LINE(fixed_font, text, IM_COL32(255, 255, 255, 255));
@@ -453,29 +453,29 @@ void ImGuiManager::DrawEnhancementsOverlay(const GPUBackend* gpu)
     text.append_format(" CDR={}x", g_settings.cdrom_read_speedup);
   if (g_settings.cdrom_seek_speedup != 1)
     text.append_format(" CDS={}x", g_settings.cdrom_seek_speedup);
-  if (g_settings.gpu_resolution_scale != 1)
+  if (g_gpu_settings.gpu_resolution_scale != 1)
-    text.append_format(" IR={}x", g_settings.gpu_resolution_scale);
+    text.append_format(" IR={}x", g_gpu_settings.gpu_resolution_scale);
-  if (g_settings.gpu_multisamples != 1)
+  if (g_gpu_settings.gpu_multisamples != 1)
   {
-    text.append_format(" {}x{}", g_settings.gpu_multisamples, g_settings.gpu_per_sample_shading ? "SSAA" : "MSAA");
+    text.append_format(" {}x{}", g_gpu_settings.gpu_multisamples, g_gpu_settings.gpu_per_sample_shading ? "SSAA" : "MSAA");
   }
-  if (g_settings.gpu_true_color)
+  if (g_gpu_settings.gpu_true_color)
     text.append(" TrueCol");
-  text.append_format(" DI={}", Settings::GetDisplayDeinterlacingModeName(g_settings.display_deinterlacing_mode));
+  text.append_format(" DI={}", Settings::GetDisplayDeinterlacingModeName(g_gpu_settings.display_deinterlacing_mode));
   if (g_settings.gpu_force_video_timing == ForceVideoTimingMode::NTSC && System::GetRegion() == ConsoleRegion::PAL)
     text.append(" PAL60");
   if (g_settings.gpu_force_video_timing == ForceVideoTimingMode::PAL && System::GetRegion() != ConsoleRegion::PAL)
     text.append(" NTSC50");
-  if (g_settings.gpu_texture_filter != GPUTextureFilter::Nearest)
+  if (g_gpu_settings.gpu_texture_filter != GPUTextureFilter::Nearest)
   {
-    if (g_settings.gpu_sprite_texture_filter != g_settings.gpu_texture_filter)
+    if (g_gpu_settings.gpu_sprite_texture_filter != g_gpu_settings.gpu_texture_filter)
     {
-      text.append_format(" {}/{}", Settings::GetTextureFilterName(g_settings.gpu_texture_filter),
+      text.append_format(" {}/{}", Settings::GetTextureFilterName(g_gpu_settings.gpu_texture_filter),
-                         Settings::GetTextureFilterName(g_settings.gpu_sprite_texture_filter));
+                         Settings::GetTextureFilterName(g_gpu_settings.gpu_sprite_texture_filter));
     }
     else
     {
-      text.append_format(" {}", Settings::GetTextureFilterName(g_settings.gpu_texture_filter));
+      text.append_format(" {}", Settings::GetTextureFilterName(g_gpu_settings.gpu_texture_filter));
     }
   }
   if (g_settings.gpu_widescreen_hack && g_settings.display_aspect_ratio != DisplayAspectRatio::Auto &&
@@ -483,8 +483,8 @@ void ImGuiManager::DrawEnhancementsOverlay(const GPUBackend* gpu)
   {
     text.append(" WSHack");
   }
-  if (g_settings.gpu_line_detect_mode != GPULineDetectMode::Disabled)
+  if (g_gpu_settings.gpu_line_detect_mode != GPULineDetectMode::Disabled)
-    text.append_format(" LD={}", Settings::GetLineDetectModeName(g_settings.gpu_line_detect_mode));
+    text.append_format(" LD={}", Settings::GetLineDetectModeName(g_gpu_settings.gpu_line_detect_mode));
   if (g_settings.gpu_pgxp_enable)
   {
     text.append(" PGXP");

src/core/justifier.cpp

@@ -215,12 +215,12 @@ void Justifier::UpdatePosition()
   float display_x, display_y;
   const auto [window_x, window_y] = (m_has_relative_binds) ? GetAbsolutePositionFromRelativeAxes() :
                                                              InputManager::GetPointerAbsolutePosition(m_cursor_index);
-  g_gpu->ConvertScreenCoordinatesToDisplayCoordinates(window_x, window_y, &display_x, &display_y);
+  g_gpu.ConvertScreenCoordinatesToDisplayCoordinates(window_x, window_y, &display_x, &display_y);
 
   // are we within the active display area?
   u32 tick, line;
   if (display_x < 0 || display_y < 0 ||
-      !g_gpu->ConvertDisplayCoordinatesToBeamTicksAndLines(display_x, display_y, m_x_scale, &tick, &line) ||
+      !g_gpu.ConvertDisplayCoordinatesToBeamTicksAndLines(display_x, display_y, m_x_scale, &tick, &line) ||
       m_shoot_offscreen)
   {
     DEV_LOG("Lightgun out of range for window coordinates {:.0f},{:.0f}", window_x, window_y);
@@ -234,11 +234,11 @@ void Justifier::UpdatePosition()
   m_irq_tick = static_cast<u16>(static_cast<TickCount>(tick) +
                                 System::ScaleTicksToOverclock(static_cast<TickCount>(m_tick_offset)));
   m_irq_first_line = static_cast<u16>(std::clamp<s32>(static_cast<s32>(line) + m_first_line_offset,
-                                                      static_cast<s32>(g_gpu->GetCRTCActiveStartLine()),
+                                                      static_cast<s32>(g_gpu.GetCRTCActiveStartLine()),
-                                                      static_cast<s32>(g_gpu->GetCRTCActiveEndLine())));
+                                                      static_cast<s32>(g_gpu.GetCRTCActiveEndLine())));
   m_irq_last_line = static_cast<u16>(std::clamp<s32>(static_cast<s32>(line) + m_last_line_offset,
-                                                     static_cast<s32>(g_gpu->GetCRTCActiveStartLine()),
+                                                     static_cast<s32>(g_gpu.GetCRTCActiveStartLine()),
-                                                     static_cast<s32>(g_gpu->GetCRTCActiveEndLine())));
+                                                     static_cast<s32>(g_gpu.GetCRTCActiveEndLine())));
 
   DEV_LOG("Lightgun window coordinates {},{} -> dpy {},{} -> tick {} line {} [{}-{}]", window_x, window_y, display_x,
           display_y, tick, line, m_irq_first_line, m_irq_last_line);
@@ -255,7 +255,7 @@ void Justifier::UpdateIRQEvent()
     return;
 
   u32 current_tick, current_line;
-  g_gpu->GetBeamPosition(&current_tick, &current_line);
+  g_gpu.GetBeamPosition(&current_tick, &current_line);
 
   u32 target_line;
   if (current_line < m_irq_first_line || current_line >= m_irq_last_line)
@@ -263,7 +263,7 @@ void Justifier::UpdateIRQEvent()
   else
     target_line = current_line + 1;
 
-  const TickCount ticks_until_pos = g_gpu->GetSystemTicksUntilTicksAndLine(m_irq_tick, target_line);
+  const TickCount ticks_until_pos = g_gpu.GetSystemTicksUntilTicksAndLine(m_irq_tick, target_line);
   DEBUG_LOG("Triggering IRQ in {} ticks @ tick {} line {}", ticks_until_pos, m_irq_tick, target_line);
   m_irq_event.Schedule(ticks_until_pos);
 }

src/core/negcon.cpp

@@ -10,6 +10,7 @@
 #include "common/assert.h"
 #include "common/bitutils.h"
 #include "common/log.h"
+#include "common/settings_interface.h"
 
 #include "IconsPromptFont.h"
 
@@ -261,14 +262,14 @@ std::unique_ptr<NeGcon> NeGcon::Create(u32 index)
 
 static const Controller::ControllerBindingInfo s_binding_info[] = {
 #define BUTTON(name, display_name, icon_name, button, genb)                                                            \
-  {                                                                                                                    \
+  {name, display_name, icon_name, static_cast<u32>(button), InputBindingInfo::Type::Button, genb}
-    name, display_name, icon_name, static_cast<u32>(button), InputBindingInfo::Type::Button, genb                      \
-  }
 #define AXIS(name, display_name, icon_name, halfaxis, genb)                                                            \
-  {                                                                                                                    \
+  {name,                                                                                                               \
-    name, display_name, icon_name, static_cast<u32>(NeGcon::Button::Count) + static_cast<u32>(halfaxis),               \
+   display_name,                                                                                                       \
-      InputBindingInfo::Type::HalfAxis, genb                                                                           \
+   icon_name,                                                                                                          \
-  }
+   static_cast<u32>(NeGcon::Button::Count) + static_cast<u32>(halfaxis),                                               \
+   InputBindingInfo::Type::HalfAxis,                                                                                   \
+   genb}
 
   // clang-format off
   BUTTON("Up", TRANSLATE_NOOP("NeGcon", "D-Pad Up"), ICON_PF_DPAD_UP, NeGcon::Button::Up, GenericInputBinding::DPadUp),

src/core/playstation_mouse.cpp

@@ -10,6 +10,7 @@
 
 #include "common/assert.h"
 #include "common/log.h"
+#include "common/settings_interface.h"
 
 #include "IconsPromptFont.h"
 

src/core/settings.cpp

@@ -30,7 +30,7 @@
 LOG_CHANNEL(Settings);
 
 ALIGN_TO_CACHE_LINE Settings g_settings;
-ALIGN_TO_CACHE_LINE Settings g_gpu_settings;
+ALIGN_TO_CACHE_LINE GPUSettings g_gpu_settings;
 
 const char* SettingInfo::StringDefaultValue() const
 {
@@ -88,6 +88,8 @@ float SettingInfo::FloatStepValue() const
   return step_value ? StringUtil::FromChars<float>(step_value).value_or(fallback_value) : fallback_value;
 }
 
+GPUSettings::GPUSettings() = default;
+
 #ifdef DYNAMIC_HOST_PAGE_SIZE
 // See note in settings.h - 16K ends up faster with LUT because of nearby code/data.
 const CPUFastmemMode Settings::DEFAULT_CPU_FASTMEM_MODE =
@@ -253,6 +255,9 @@ void Settings::Load(const SettingsInterface& si, const SettingsInterface& contro
   gpu_pgxp_depth_buffer = si.GetBoolValue("GPU", "PGXPDepthBuffer", false);
   gpu_pgxp_disable_2d = si.GetBoolValue("GPU", "PGXPDisableOn2DPolygons", false);
   SetPGXPDepthClearThreshold(si.GetFloatValue("GPU", "PGXPDepthClearThreshold", DEFAULT_GPU_PGXP_DEPTH_THRESHOLD));
+  gpu_show_vram = si.GetBoolValue("Debug", "ShowVRAM");
+  gpu_dump_cpu_to_vram_copies = si.GetBoolValue("Debug", "DumpCPUToVRAMCopies");
+  gpu_dump_vram_to_cpu_copies = si.GetBoolValue("Debug", "DumpVRAMToCPUCopies");
   gpu_dump_fast_replay_mode = si.GetBoolValue("GPU", "DumpFastReplayMode", false);
 
   display_deinterlacing_mode =
@@ -424,13 +429,9 @@ void Settings::Load(const SettingsInterface& si, const SettingsInterface& contro
   achievements_leaderboard_duration =
     si.GetIntValue("Cheevos", "LeaderboardsDuration", DEFAULT_LEADERBOARD_NOTIFICATION_TIME);
 
-  debugging.show_vram = si.GetBoolValue("Debug", "ShowVRAM");
-  debugging.dump_cpu_to_vram_copies = si.GetBoolValue("Debug", "DumpCPUToVRAMCopies");
-  debugging.dump_vram_to_cpu_copies = si.GetBoolValue("Debug", "DumpVRAMToCPUCopies");
-
 #ifndef __ANDROID__
-  debugging.enable_gdb_server = si.GetBoolValue("Debug", "EnableGDBServer");
+  enable_gdb_server = si.GetBoolValue("Debug", "EnableGDBServer");
-  debugging.gdb_server_port = static_cast<u16>(si.GetUIntValue("Debug", "GDBServerPort", DEFAULT_GDB_SERVER_PORT));
+  gdb_server_port = static_cast<u16>(si.GetUIntValue("Debug", "GDBServerPort", DEFAULT_GDB_SERVER_PORT));
 #endif
 
   texture_replacements.enable_texture_replacements =
@@ -585,6 +586,9 @@ void Settings::Save(SettingsInterface& si, bool ignore_base) const
   si.SetBoolValue("GPU", "PGXPDepthBuffer", gpu_pgxp_depth_buffer);
   si.SetBoolValue("GPU", "PGXPDisableOn2DPolygons", gpu_pgxp_disable_2d);
   si.SetFloatValue("GPU", "PGXPDepthClearThreshold", GetPGXPDepthClearThreshold());
+  si.SetBoolValue("Debug", "ShowVRAM", gpu_show_vram);
+  si.SetBoolValue("Debug", "DumpCPUToVRAMCopies", gpu_dump_cpu_to_vram_copies);
+  si.SetBoolValue("Debug", "DumpVRAMToCPUCopies", gpu_dump_vram_to_cpu_copies);
   si.SetBoolValue("GPU", "DumpFastReplayMode", gpu_dump_fast_replay_mode);
 
   si.SetStringValue("GPU", "DeinterlacingMode", GetDisplayDeinterlacingModeName(display_deinterlacing_mode));
@@ -701,17 +705,10 @@ void Settings::Save(SettingsInterface& si, bool ignore_base) const
   si.SetIntValue("Cheevos", "NotificationsDuration", achievements_notification_duration);
   si.SetIntValue("Cheevos", "LeaderboardsDuration", achievements_leaderboard_duration);
 
-  if (!ignore_base)
-  {
-    si.SetBoolValue("Debug", "ShowVRAM", debugging.show_vram);
-    si.SetBoolValue("Debug", "DumpCPUToVRAMCopies", debugging.dump_cpu_to_vram_copies);
-    si.SetBoolValue("Debug", "DumpVRAMToCPUCopies", debugging.dump_vram_to_cpu_copies);
-
 #ifndef __ANDROID__
-    si.SetBoolValue("Debug", "EnableGDBServer", debugging.enable_gdb_server);
+  si.SetBoolValue("Debug", "EnableGDBServer", enable_gdb_server);
-    si.SetUIntValue("Debug", "GDBServerPort", debugging.gdb_server_port);
+  si.SetUIntValue("Debug", "GDBServerPort", gdb_server_port);
 #endif
-  }
 
   si.SetBoolValue("TextureReplacements", "EnableTextureReplacements", texture_replacements.enable_texture_replacements);
   si.SetBoolValue("TextureReplacements", "EnableVRAMWriteReplacements",
@@ -1083,12 +1080,12 @@ void Settings::FixIncompatibleSettings(const SettingsInterface& si, bool display
     }
 
 #ifndef __ANDROID__
-    g_settings.debugging.enable_gdb_server = false;
+    g_settings.enable_gdb_server = false;
 #endif
 
-    g_settings.debugging.show_vram = false;
+    g_settings.gpu_show_vram = false;
-    g_settings.debugging.dump_cpu_to_vram_copies = false;
+    g_settings.gpu_dump_cpu_to_vram_copies = false;
-    g_settings.debugging.dump_vram_to_cpu_copies = false;
+    g_settings.gpu_dump_vram_to_cpu_copies = false;
   }
 }
 
@@ -1783,7 +1780,7 @@ const char* Settings::GetDisplayAspectRatioDisplayName(DisplayAspectRatio ar)
                                   "DisplayAspectRatio");
 }
 
-float Settings::GetDisplayAspectRatioValue() const
+float GPUSettings::GetDisplayAspectRatioValue() const
 {
   return s_display_aspect_ratio_values[static_cast<size_t>(display_aspect_ratio)];
 }

src/core/settings.h

@@ -8,8 +8,6 @@
 #include "util/audio_stream.h"
 
 #include "common/log.h"
-#include "common/settings_interface.h"
-#include "common/small_string.h"
 
 #include <array>
 #include <optional>
@@ -18,6 +16,8 @@
 #include <string_view>
 #include <vector>
 
+class SettingsInterface;
+
 enum class RenderAPI : u8;
 enum class MediaCaptureBackend : u8;
 
@@ -57,48 +57,17 @@ struct SettingInfo
   float FloatStepValue() const;
 };
 
-struct Settings
+struct GPUSettings
 {
-  Settings();
+  GPUSettings();
 
-  ConsoleRegion region = DEFAULT_CONSOLE_REGION;
+  std::string gpu_adapter;
-
-  CPUExecutionMode cpu_execution_mode = DEFAULT_CPU_EXECUTION_MODE;
-  CPUFastmemMode cpu_fastmem_mode = DEFAULT_CPU_FASTMEM_MODE;
-  bool cpu_overclock_enable : 1 = false;
-  bool cpu_overclock_active : 1 = false;
-  bool cpu_recompiler_memory_exceptions : 1 = false;
-  bool cpu_recompiler_block_linking : 1 = true;
-  bool cpu_recompiler_icache : 1 = false;
-  u32 cpu_overclock_numerator = 1;
-  u32 cpu_overclock_denominator = 1;
-
-  float emulation_speed = 1.0f;
-  float fast_forward_speed = 0.0f;
-  float turbo_speed = 0.0f;
-  bool sync_to_host_refresh_rate : 1 = false;
-  bool inhibit_screensaver : 1 = true;
-  bool pause_on_focus_loss : 1 = false;
-  bool pause_on_controller_disconnection : 1 = false;
-  bool save_state_on_exit : 1 = true;
-  bool create_save_state_backups : 1 = DEFAULT_SAVE_STATE_BACKUPS;
-  bool confim_power_off : 1 = true;
-  bool load_devices_from_save_states : 1 = false;
-  bool apply_compatibility_settings : 1 = true;
-  bool apply_game_settings : 1 = true;
-  bool disable_all_enhancements : 1 = false;
-  bool enable_discord_presence : 1 = false;
-
-  bool rewind_enable : 1 = false;
-  float rewind_save_frequency = 10.0f;
-  u16 rewind_save_slots = 10;
-  u8 runahead_frames = 0;
 
   GPURenderer gpu_renderer = DEFAULT_GPU_RENDERER;
-  std::string gpu_adapter;
   u8 gpu_resolution_scale = 1;
   u8 gpu_multisamples = 1;
   u8 gpu_max_queued_frames = DEFAULT_GPU_MAX_QUEUED_FRAMES;
+
   bool gpu_use_thread : 1 = true;
   bool gpu_use_software_renderer_for_readbacks : 1 = false;
   bool gpu_use_debug_device : 1 = false;
@@ -118,6 +87,11 @@ struct Settings
   bool gpu_accurate_blending : 1 = false;
   bool gpu_widescreen_hack : 1 = false;
   bool gpu_texture_cache : 1 = false;
+  bool gpu_show_vram : 1 = false;
+  bool gpu_dump_cpu_to_vram_copies : 1 = false;
+  bool gpu_dump_vram_to_cpu_copies : 1 = false;
+  bool gpu_dump_fast_replay_mode : 1 = false;
+
   bool gpu_pgxp_enable : 1 = false;
   bool gpu_pgxp_culling : 1 = true;
   bool gpu_pgxp_texture_correction : 1 = true;
@@ -127,6 +101,7 @@ struct Settings
   bool gpu_pgxp_preserve_proj_fp : 1 = false;
   bool gpu_pgxp_depth_buffer : 1 = false;
   bool gpu_pgxp_disable_2d : 1 = false;
+
   ForceVideoTimingMode gpu_force_video_timing = DEFAULT_FORCE_VIDEO_TIMING_MODE;
   GPUTextureFilter gpu_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
   GPUTextureFilter gpu_sprite_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
@@ -176,62 +151,6 @@ struct Settings
   float gpu_pgxp_tolerance = -1.0f;
   float gpu_pgxp_depth_clear_threshold = DEFAULT_GPU_PGXP_DEPTH_THRESHOLD / GPU_PGXP_DEPTH_THRESHOLD_SCALE;
 
-  SaveStateCompressionMode save_state_compression = DEFAULT_SAVE_STATE_COMPRESSION_MODE;
-
-  u8 cdrom_readahead_sectors = DEFAULT_CDROM_READAHEAD_SECTORS;
-  CDROMMechaconVersion cdrom_mechacon_version = DEFAULT_CDROM_MECHACON_VERSION;
-  bool cdrom_region_check : 1 = false;
-  bool cdrom_subq_skew : 1 = false;
-  bool cdrom_load_image_to_ram : 1 = false;
-  bool cdrom_load_image_patches : 1 = false;
-  bool cdrom_mute_cd_audio : 1 = false;
-  u32 cdrom_read_speedup = 1;
-  u32 cdrom_seek_speedup = 1;
-
-  std::string audio_driver;
-  std::string audio_output_device;
-  u32 audio_output_volume = 100;
-  u32 audio_fast_forward_volume = 100;
-  AudioStreamParameters audio_stream_parameters;
-  AudioBackend audio_backend = AudioStream::DEFAULT_BACKEND;
-  bool audio_output_muted : 1 = false;
-
-  bool use_old_mdec_routines : 1 = false;
-  bool pcdrv_enable : 1 = false;
-  bool export_shared_memory : 1 = false;
-
-  // timing hacks section
-  TickCount dma_max_slice_ticks = DEFAULT_DMA_MAX_SLICE_TICKS;
-  TickCount dma_halt_ticks = DEFAULT_DMA_HALT_TICKS;
-  u32 gpu_fifo_size = DEFAULT_GPU_FIFO_SIZE;
-  TickCount gpu_max_run_ahead = DEFAULT_GPU_MAX_RUN_AHEAD;
-
-  // achievements
-  bool achievements_enabled : 1 = false;
-  bool achievements_hardcore_mode : 1 = false;
-  bool achievements_notifications : 1 = true;
-  bool achievements_leaderboard_notifications : 1 = true;
-  bool achievements_sound_effects : 1 = true;
-  bool achievements_overlays : 1 = true;
-  bool achievements_encore_mode : 1 = false;
-  bool achievements_spectator_mode : 1 = false;
-  bool achievements_unofficial_test_mode : 1 = false;
-  bool achievements_use_raintegration : 1 = false;
-  s32 achievements_notification_duration = DEFAULT_ACHIEVEMENT_NOTIFICATION_TIME;
-  s32 achievements_leaderboard_duration = DEFAULT_LEADERBOARD_NOTIFICATION_TIME;
-
-  struct DebugSettings
-  {
-#ifndef __ANDROID__
-    u16 gdb_server_port = DEFAULT_GDB_SERVER_PORT;
-    bool enable_gdb_server : 1 = false;
-#endif
-
-    bool show_vram : 1 = false;
-    bool dump_cpu_to_vram_copies : 1 = false;
-    bool dump_vram_to_cpu_copies : 1 = false;
-  } debugging;
-
   // texture replacements
   struct TextureReplacementSettings
   {
@@ -285,11 +204,143 @@ struct Settings
     bool operator!=(const TextureReplacementSettings& rhs) const;
   } texture_replacements;
 
+  float GetDisplayAspectRatioValue() const;
+
+  ALWAYS_INLINE bool IsUsingSoftwareRenderer() const { return (gpu_renderer == GPURenderer::Software); }
+  ALWAYS_INLINE bool IsUsingAccurateBlending() const { return (gpu_accurate_blending && !gpu_true_color); }
+
+  ALWAYS_INLINE bool UsingPGXPCPUMode() const { return gpu_pgxp_enable && gpu_pgxp_cpu; }
+  ALWAYS_INLINE bool UsingPGXPDepthBuffer() const { return gpu_pgxp_enable && gpu_pgxp_depth_buffer; }
+  ALWAYS_INLINE float GetPGXPDepthClearThreshold() const
+  {
+    return gpu_pgxp_depth_clear_threshold * GPU_PGXP_DEPTH_THRESHOLD_SCALE;
+  }
+  ALWAYS_INLINE void SetPGXPDepthClearThreshold(float value)
+  {
+    gpu_pgxp_depth_clear_threshold = value / GPU_PGXP_DEPTH_THRESHOLD_SCALE;
+  }
+
+  static constexpr GPURenderer DEFAULT_GPU_RENDERER = GPURenderer::Automatic;
+  static constexpr GPUTextureFilter DEFAULT_GPU_TEXTURE_FILTER = GPUTextureFilter::Nearest;
+  static constexpr GPULineDetectMode DEFAULT_GPU_LINE_DETECT_MODE = GPULineDetectMode::Disabled;
+  static constexpr GPUDownsampleMode DEFAULT_GPU_DOWNSAMPLE_MODE = GPUDownsampleMode::Disabled;
+  static constexpr GPUWireframeMode DEFAULT_GPU_WIREFRAME_MODE = GPUWireframeMode::Disabled;
+  static constexpr GPUDumpCompressionMode DEFAULT_GPU_DUMP_COMPRESSION_MODE = GPUDumpCompressionMode::ZstDefault;
+  static constexpr float DEFAULT_GPU_PGXP_DEPTH_THRESHOLD = 300.0f;
+  static constexpr float GPU_PGXP_DEPTH_THRESHOLD_SCALE = 4096.0f;
+
+  static constexpr DisplayDeinterlacingMode DEFAULT_DISPLAY_DEINTERLACING_MODE = DisplayDeinterlacingMode::Progressive;
+  static constexpr DisplayCropMode DEFAULT_DISPLAY_CROP_MODE = DisplayCropMode::Overscan;
+  static constexpr DisplayAspectRatio DEFAULT_DISPLAY_ASPECT_RATIO = DisplayAspectRatio::Auto;
+  static constexpr DisplayAlignment DEFAULT_DISPLAY_ALIGNMENT = DisplayAlignment::Center;
+  static constexpr DisplayRotation DEFAULT_DISPLAY_ROTATION = DisplayRotation::Normal;
+  static constexpr DisplayScalingMode DEFAULT_DISPLAY_SCALING = DisplayScalingMode::BilinearSmooth;
+  static constexpr ForceVideoTimingMode DEFAULT_FORCE_VIDEO_TIMING_MODE = ForceVideoTimingMode::Disabled;
+  static constexpr DisplayExclusiveFullscreenControl DEFAULT_DISPLAY_EXCLUSIVE_FULLSCREEN_CONTROL =
+    DisplayExclusiveFullscreenControl::Automatic;
+  static constexpr DisplayScreenshotMode DEFAULT_DISPLAY_SCREENSHOT_MODE = DisplayScreenshotMode::ScreenResolution;
+  static constexpr DisplayScreenshotFormat DEFAULT_DISPLAY_SCREENSHOT_FORMAT = DisplayScreenshotFormat::PNG;
+  static constexpr u8 DEFAULT_DISPLAY_SCREENSHOT_QUALITY = 85;
+  static constexpr float DEFAULT_DISPLAY_PRE_FRAME_SLEEP_BUFFER = 2.0f;
+  static constexpr float DEFAULT_OSD_SCALE = 100.0f;
+
+#ifndef __ANDROID__
+  static constexpr u8 DEFAULT_GPU_MAX_QUEUED_FRAMES = 2;
+#else
+  static constexpr u8 DEFAULT_GPU_MAX_QUEUED_FRAMES = 3;
+#endif
+};
+
+struct Settings : public GPUSettings
+{
+  Settings();
+
+  ConsoleRegion region = DEFAULT_CONSOLE_REGION;
+
+  CPUExecutionMode cpu_execution_mode = DEFAULT_CPU_EXECUTION_MODE;
+  CPUFastmemMode cpu_fastmem_mode = DEFAULT_CPU_FASTMEM_MODE;
+  bool cpu_overclock_enable : 1 = false;
+  bool cpu_overclock_active : 1 = false;
+  bool cpu_recompiler_memory_exceptions : 1 = false;
+  bool cpu_recompiler_block_linking : 1 = true;
+  bool cpu_recompiler_icache : 1 = false;
+  u32 cpu_overclock_numerator = 1;
+  u32 cpu_overclock_denominator = 1;
+
+  float emulation_speed = 1.0f;
+  float fast_forward_speed = 0.0f;
+  float turbo_speed = 0.0f;
+  bool sync_to_host_refresh_rate : 1 = false;
+  bool inhibit_screensaver : 1 = true;
+  bool pause_on_focus_loss : 1 = false;
+  bool pause_on_controller_disconnection : 1 = false;
+  bool save_state_on_exit : 1 = true;
+  bool create_save_state_backups : 1 = DEFAULT_SAVE_STATE_BACKUPS;
+  bool confim_power_off : 1 = true;
+  bool load_devices_from_save_states : 1 = false;
+  bool apply_compatibility_settings : 1 = true;
+  bool apply_game_settings : 1 = true;
+  bool disable_all_enhancements : 1 = false;
+  bool enable_discord_presence : 1 = false;
+
+  bool rewind_enable : 1 = false;
+  float rewind_save_frequency = 10.0f;
+  u16 rewind_save_slots = 10;
+  u8 runahead_frames = 0;
+
+  SaveStateCompressionMode save_state_compression = DEFAULT_SAVE_STATE_COMPRESSION_MODE;
+
+  u8 cdrom_readahead_sectors = DEFAULT_CDROM_READAHEAD_SECTORS;
+  CDROMMechaconVersion cdrom_mechacon_version = DEFAULT_CDROM_MECHACON_VERSION;
+  bool cdrom_region_check : 1 = false;
+  bool cdrom_subq_skew : 1 = false;
+  bool cdrom_load_image_to_ram : 1 = false;
+  bool cdrom_load_image_patches : 1 = false;
+  bool cdrom_mute_cd_audio : 1 = false;
+  u32 cdrom_read_speedup = 1;
+  u32 cdrom_seek_speedup = 1;
+
+  std::string audio_driver;
+  std::string audio_output_device;
+  u32 audio_output_volume = 100;
+  u32 audio_fast_forward_volume = 100;
+  AudioStreamParameters audio_stream_parameters;
+  AudioBackend audio_backend = AudioStream::DEFAULT_BACKEND;
+  bool audio_output_muted : 1 = false;
+
+  bool use_old_mdec_routines : 1 = false;
+  bool pcdrv_enable : 1 = false;
+  bool export_shared_memory : 1 = false;
+
+  // timing hacks section
+  TickCount dma_max_slice_ticks = DEFAULT_DMA_MAX_SLICE_TICKS;
+  TickCount dma_halt_ticks = DEFAULT_DMA_HALT_TICKS;
+  u32 gpu_fifo_size = DEFAULT_GPU_FIFO_SIZE;
+  TickCount gpu_max_run_ahead = DEFAULT_GPU_MAX_RUN_AHEAD;
+
+  // achievements
+  bool achievements_enabled : 1 = false;
+  bool achievements_hardcore_mode : 1 = false;
+  bool achievements_notifications : 1 = true;
+  bool achievements_leaderboard_notifications : 1 = true;
+  bool achievements_sound_effects : 1 = true;
+  bool achievements_overlays : 1 = true;
+  bool achievements_encore_mode : 1 = false;
+  bool achievements_spectator_mode : 1 = false;
+  bool achievements_unofficial_test_mode : 1 = false;
+  bool achievements_use_raintegration : 1 = false;
+  s32 achievements_notification_duration = DEFAULT_ACHIEVEMENT_NOTIFICATION_TIME;
+  s32 achievements_leaderboard_duration = DEFAULT_LEADERBOARD_NOTIFICATION_TIME;
+
+#ifndef __ANDROID__
+  u16 gdb_server_port = DEFAULT_GDB_SERVER_PORT;
+  bool enable_gdb_server : 1 = false;
+#endif
+
   bool bios_tty_logging : 1 = false;
   bool bios_patch_fast_boot : 1 = DEFAULT_FAST_BOOT_VALUE;
   bool bios_fast_forward_boot : 1 = false;
   bool enable_8mb_ram : 1 = false;
-  bool gpu_dump_fast_replay_mode : 1 = false;
 
   std::array<ControllerType, NUM_CONTROLLER_AND_CARD_PORTS> controller_types{};
   std::array<MemoryCardType, NUM_CONTROLLER_AND_CARD_PORTS> memory_card_types{};
@@ -306,33 +357,14 @@ struct Settings
   std::string pcdrv_root;
   bool pcdrv_enable_writes = false;
 
-  ALWAYS_INLINE bool IsUsingSoftwareRenderer() const { return (gpu_renderer == GPURenderer::Software); }
-  ALWAYS_INLINE bool IsUsingAccurateBlending() const { return (gpu_accurate_blending && !gpu_true_color); }
   ALWAYS_INLINE bool IsRunaheadEnabled() const { return (runahead_frames > 0); }
 
-  ALWAYS_INLINE PGXPMode GetPGXPMode()
-  {
-    return gpu_pgxp_enable ? (gpu_pgxp_cpu ? PGXPMode::CPU : PGXPMode::Memory) : PGXPMode::Disabled;
-  }
-
-  ALWAYS_INLINE bool UsingPGXPDepthBuffer() const { return gpu_pgxp_enable && gpu_pgxp_depth_buffer; }
-  ALWAYS_INLINE bool UsingPGXPCPUMode() const { return gpu_pgxp_enable && gpu_pgxp_cpu; }
-  ALWAYS_INLINE float GetPGXPDepthClearThreshold() const
-  {
-    return gpu_pgxp_depth_clear_threshold * GPU_PGXP_DEPTH_THRESHOLD_SCALE;
-  }
-  ALWAYS_INLINE void SetPGXPDepthClearThreshold(float value)
-  {
-    gpu_pgxp_depth_clear_threshold = value / GPU_PGXP_DEPTH_THRESHOLD_SCALE;
-  }
 
   ALWAYS_INLINE s32 GetAudioOutputVolume(bool fast_forwarding) const
   {
     return audio_output_muted ? 0 : (fast_forwarding ? audio_fast_forward_volume : audio_output_volume);
   }
 
-  float GetDisplayAspectRatioValue() const;
-
   ALWAYS_INLINE bool IsPort1MultitapEnabled() const
   {
     return (multitap_mode == MultitapMode::Port1Only || multitap_mode == MultitapMode::BothPorts);
@@ -498,15 +530,7 @@ struct Settings
   static const char* GetPIODeviceTypeModeName(PIODeviceType type);
   static const char* GetPIODeviceTypeModeDisplayName(PIODeviceType type);
 
-  static constexpr GPURenderer DEFAULT_GPU_RENDERER = GPURenderer::Automatic;
-  static constexpr GPUTextureFilter DEFAULT_GPU_TEXTURE_FILTER = GPUTextureFilter::Nearest;
-  static constexpr GPULineDetectMode DEFAULT_GPU_LINE_DETECT_MODE = GPULineDetectMode::Disabled;
-  static constexpr GPUDownsampleMode DEFAULT_GPU_DOWNSAMPLE_MODE = GPUDownsampleMode::Disabled;
-  static constexpr GPUWireframeMode DEFAULT_GPU_WIREFRAME_MODE = GPUWireframeMode::Disabled;
-  static constexpr GPUDumpCompressionMode DEFAULT_GPU_DUMP_COMPRESSION_MODE = GPUDumpCompressionMode::ZstDefault;
   static constexpr ConsoleRegion DEFAULT_CONSOLE_REGION = ConsoleRegion::Auto;
-  static constexpr float DEFAULT_GPU_PGXP_DEPTH_THRESHOLD = 300.0f;
-  static constexpr float GPU_PGXP_DEPTH_THRESHOLD_SCALE = 4096.0f;
 
   // Prefer recompiler when supported.
 #ifdef ENABLE_RECOMPILER
@@ -524,21 +548,6 @@ struct Settings
   static constexpr CPUFastmemMode DEFAULT_CPU_FASTMEM_MODE = CPUFastmemMode::LUT;
 #endif
 
-  static constexpr DisplayDeinterlacingMode DEFAULT_DISPLAY_DEINTERLACING_MODE = DisplayDeinterlacingMode::Progressive;
-  static constexpr DisplayCropMode DEFAULT_DISPLAY_CROP_MODE = DisplayCropMode::Overscan;
-  static constexpr DisplayAspectRatio DEFAULT_DISPLAY_ASPECT_RATIO = DisplayAspectRatio::Auto;
-  static constexpr DisplayAlignment DEFAULT_DISPLAY_ALIGNMENT = DisplayAlignment::Center;
-  static constexpr DisplayRotation DEFAULT_DISPLAY_ROTATION = DisplayRotation::Normal;
-  static constexpr DisplayScalingMode DEFAULT_DISPLAY_SCALING = DisplayScalingMode::BilinearSmooth;
-  static constexpr ForceVideoTimingMode DEFAULT_FORCE_VIDEO_TIMING_MODE = ForceVideoTimingMode::Disabled;
-  static constexpr DisplayExclusiveFullscreenControl DEFAULT_DISPLAY_EXCLUSIVE_FULLSCREEN_CONTROL =
-    DisplayExclusiveFullscreenControl::Automatic;
-  static constexpr DisplayScreenshotMode DEFAULT_DISPLAY_SCREENSHOT_MODE = DisplayScreenshotMode::ScreenResolution;
-  static constexpr DisplayScreenshotFormat DEFAULT_DISPLAY_SCREENSHOT_FORMAT = DisplayScreenshotFormat::PNG;
-  static constexpr u8 DEFAULT_DISPLAY_SCREENSHOT_QUALITY = 85;
-  static constexpr float DEFAULT_DISPLAY_PRE_FRAME_SLEEP_BUFFER = 2.0f;
-  static constexpr float DEFAULT_OSD_SCALE = 100.0f;
-
   static constexpr u8 DEFAULT_CDROM_READAHEAD_SECTORS = 8;
   static constexpr CDROMMechaconVersion DEFAULT_CDROM_MECHACON_VERSION = CDROMMechaconVersion::VC1A;
 
@@ -568,19 +577,14 @@ struct Settings
   static constexpr bool DEFAULT_SAVE_STATE_BACKUPS = true;
   static constexpr bool DEFAULT_FAST_BOOT_VALUE = false;
   static constexpr u16 DEFAULT_GDB_SERVER_PORT = 2345;
-
-  // TODO: Maybe lower? But that means fast CPU threads would always stall, could be a problem for power management.
-  static constexpr u8 DEFAULT_GPU_MAX_QUEUED_FRAMES = 2;
 #else
   static constexpr bool DEFAULT_SAVE_STATE_BACKUPS = false;
   static constexpr bool DEFAULT_FAST_BOOT_VALUE = true;
-  static constexpr u8 DEFAULT_GPU_MAX_QUEUED_FRAMES = 3;
 #endif
 };
 
-// TODO: Use smaller copy for GPU thread copy.
+ALIGN_TO_CACHE_LINE extern Settings g_settings;        // CPU thread copy.
-ALIGN_TO_CACHE_LINE extern Settings g_settings;     // CPU thread copy.
+ALIGN_TO_CACHE_LINE extern GPUSettings g_gpu_settings; // GPU thread copy.
-ALIGN_TO_CACHE_LINE extern Settings g_gpu_settings; // GPU thread copy.
 
 namespace EmuFolders {
 extern std::string AppRoot;

src/core/system.cpp

@@ -713,7 +713,7 @@ void System::UpdateOverclock()
   s_state.max_slice_ticks = ScaleTicksToOverclock(MASTER_CLOCK / 10);
   SPU::CPUClockChanged();
   CDROM::CPUClockChanged();
-  g_gpu->CPUClockChanged();
+  g_gpu.CPUClockChanged();
   Timers::CPUClocksChanged();
   UpdateThrottlePeriod();
 }
@@ -1827,8 +1827,8 @@ bool System::BootSystem(SystemBootParameters parameters, Error* error)
     PlatformMisc::SuspendScreensaver();
 
 #ifdef ENABLE_GDB_SERVER
-  if (g_settings.debugging.enable_gdb_server)
+  if (g_settings.enable_gdb_server)
-    GDBServer::Initialize(g_settings.debugging.gdb_server_port);
+    GDBServer::Initialize(g_settings.gdb_server_port);
 #endif
 
   Host::OnSystemStarted();
@@ -1882,9 +1882,8 @@ bool System::Initialize(std::unique_ptr<CDImage> disc, DiscRegion disc_region, b
       !CDROM::InsertMedia(std::move(disc), disc_region, s_state.running_game_serial, s_state.running_game_title, error))
     return false;
 
-  // TODO: Drop pointer
+  // TODO: Drop class
-  g_gpu = std::make_unique<GPU>();
+  g_gpu.Initialize();
-  g_gpu->Initialize();
 
   // This can fail due to the application being closed during startup.
   if (!GPUThread::CreateGPUBackend(s_state.running_game_serial,
@@ -1965,7 +1964,7 @@ void System::DestroySystem()
   Timers::Shutdown();
   Pad::Shutdown();
   CDROM::Shutdown();
-  g_gpu.reset();
+  g_gpu.Shutdown();
   DMA::Shutdown();
   PIO::Shutdown();
   CPU::CodeCache::Shutdown();
@@ -2100,7 +2099,7 @@ void System::FrameDone()
     }
 
     // Late submission of frame. This is needed because the input poll can determine whether we need to rewind.
-    g_gpu->QueuePresentCurrentFrame();
+    g_gpu.QueuePresentCurrentFrame();
 
     SaveMemoryState(AllocateMemoryState());
   }
@@ -2386,7 +2385,7 @@ bool System::DoState(StateWrapper& sw, bool update_display)
   if (!sw.DoMarker("InterruptController") || !InterruptController::DoState(sw))
     return false;
 
-  if (!sw.DoMarker("GPU") || !g_gpu->DoState(sw, update_display))
+  if (!sw.DoMarker("GPU") || !g_gpu.DoState(sw, update_display))
     return false;
 
   if (!sw.DoMarker("CDROM") || !CDROM::DoState(sw))
@@ -2682,7 +2681,7 @@ void System::DoMemoryState(StateWrapper& sw, MemorySaveState& mss, bool update_d
   SAVE_COMPONENT("DMA", DMA::DoState(sw));
   SAVE_COMPONENT("InterruptController", InterruptController::DoState(sw));
 
-  g_gpu->DoMemoryState(sw, mss, update_display);
+  g_gpu.DoMemoryState(sw, mss, update_display);
 
   SAVE_COMPONENT("CDROM", CDROM::DoState(sw));
   SAVE_COMPONENT("Pad", Pad::DoState(sw, true));
@@ -2731,7 +2730,7 @@ void System::InternalReset()
   PIO::Reset();
   DMA::Reset();
   InterruptController::Reset();
-  g_gpu->Reset(true);
+  g_gpu.Reset(true);
   CDROM::Reset();
   Pad::Reset();
   Timers::Reset();
@@ -3957,7 +3956,7 @@ bool System::DumpVRAM(const char* filename)
   if (!IsValid())
     return false;
 
-  return g_gpu->DumpVRAMToFile(filename);
+  return g_gpu.DumpVRAMToFile(filename);
 }
 
 bool System::DumpSPURAM(const char* filename)
@@ -4414,7 +4413,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
              g_settings.display_active_end_offset != old_settings.display_active_end_offset ||
              g_settings.display_line_start_offset != old_settings.display_line_start_offset ||
              g_settings.display_line_end_offset != old_settings.display_line_end_offset ||
-             g_settings.debugging.show_vram != old_settings.debugging.show_vram ||
+             g_settings.gpu_show_vram != old_settings.gpu_show_vram ||
              g_settings.rewind_enable != old_settings.rewind_enable ||
              g_settings.runahead_frames != old_settings.runahead_frames ||
              g_settings.texture_replacements.enable_texture_replacements !=
@@ -4433,7 +4432,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
         GPUThread::PresentCurrentFrame();
     }
     else if (const bool device_settings_changed = g_settings.AreGPUDeviceSettingsChanged(old_settings);
-      device_settings_changed || g_settings.display_show_fps != old_settings.display_show_fps ||
+             device_settings_changed || g_settings.display_show_fps != old_settings.display_show_fps ||
              g_settings.display_show_speed != old_settings.display_show_speed ||
              g_settings.display_show_gpu_stats != old_settings.display_show_gpu_stats ||
              g_settings.display_show_resolution != old_settings.display_show_resolution ||
@@ -4551,12 +4550,12 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
     }
 
 #ifdef ENABLE_GDB_SERVER
-    if (g_settings.debugging.enable_gdb_server != old_settings.debugging.enable_gdb_server ||
+    if (g_settings.enable_gdb_server != old_settings.enable_gdb_server ||
-        g_settings.debugging.gdb_server_port != old_settings.debugging.gdb_server_port)
+        g_settings.gdb_server_port != old_settings.gdb_server_port)
     {
       GDBServer::Shutdown();
-      if (g_settings.debugging.enable_gdb_server)
+      if (g_settings.enable_gdb_server)
-        GDBServer::Initialize(g_settings.debugging.gdb_server_port);
+        GDBServer::Initialize(g_settings.gdb_server_port);
     }
 #endif
   }
@@ -5198,7 +5197,7 @@ bool System::StartRecordingGPUDump(const char* path /*= nullptr*/, u32 num_frame
   if (!path)
     path = (auto_path = GetScreenshotPath("psxgpu")).c_str();
 
-  return g_gpu->StartRecordingGPUDump(path, num_frames);
+  return g_gpu.StartRecordingGPUDump(path, num_frames);
 }
 
 void System::StopRecordingGPUDump()
@@ -5206,7 +5205,7 @@ void System::StopRecordingGPUDump()
   if (!IsValid())
     return;
 
-  g_gpu->StopRecordingGPUDump();
+  g_gpu.StopRecordingGPUDump();
 }
 
 static std::string_view GetCaptureTypeForMessage(bool capture_video, bool capture_audio)
@@ -5679,16 +5678,16 @@ void System::RequestDisplaySize(float scale /*= 0.0f*/)
     scale = GPUBackend::IsUsingHardwareBackend() ? static_cast<float>(g_settings.gpu_resolution_scale) : 1.0f;
 
   float requested_width, requested_height;
-  if (g_settings.debugging.show_vram)
+  if (g_settings.gpu_show_vram)
   {
     requested_width = static_cast<float>(VRAM_WIDTH) * scale;
     requested_height = static_cast<float>(VRAM_HEIGHT) * scale;
   }
   else
   {
-    requested_width = static_cast<float>(g_gpu->GetCRTCDisplayWidth()) * scale;
+    requested_width = static_cast<float>(g_gpu.GetCRTCDisplayWidth()) * scale;
-    requested_height = static_cast<float>(g_gpu->GetCRTCDisplayHeight()) * scale;
+    requested_height = static_cast<float>(g_gpu.GetCRTCDisplayHeight()) * scale;
-    g_gpu->ApplyPixelAspectRatioToSize(g_gpu->ComputePixelAspectRatio(), &requested_width, &requested_height);
+    g_gpu.ApplyPixelAspectRatioToSize(g_gpu.ComputePixelAspectRatio(), &requested_width, &requested_height);
   }
 
   if (g_settings.display_rotation == DisplayRotation::Rotate90 ||
@@ -5734,7 +5733,7 @@ void System::UpdateGTEAspectRatio()
     {
       // Pre-apply the native aspect ratio correction to the window size.
       // MatchWindow does not correct the display aspect ratio, so we need to apply it here.
-      const float correction = g_gpu->ComputeAspectRatioCorrection();
+      const float correction = g_gpu.ComputeAspectRatioCorrection();
       custom_num =
         static_cast<u32>(std::max(std::round(static_cast<float>(main_window_info.surface_width) / correction), 1.0f));
       custom_denom = std::max<u32>(main_window_info.surface_height, 1u);

src/core/timers.cpp

@@ -315,8 +315,8 @@ u32 Timers::ReadRegister(u32 offset)
       if (timer_index < 2 && cs.external_counting_enabled)
       {
         // timers 0/1 depend on the GPU
-        if (timer_index == 0 || g_gpu->IsCRTCScanlinePending())
+        if (timer_index == 0 || g_gpu.IsCRTCScanlinePending())
-          g_gpu->SynchronizeCRTC();
+          g_gpu.SynchronizeCRTC();
       }
 
       s_state.sysclk_event.InvokeEarly();
@@ -329,8 +329,8 @@ u32 Timers::ReadRegister(u32 offset)
       if (timer_index < 2 && cs.external_counting_enabled)
       {
         // timers 0/1 depend on the GPU
-        if (timer_index == 0 || g_gpu->IsCRTCScanlinePending())
+        if (timer_index == 0 || g_gpu.IsCRTCScanlinePending())
-          g_gpu->SynchronizeCRTC();
+          g_gpu.SynchronizeCRTC();
       }
 
       s_state.sysclk_event.InvokeEarly();
@@ -365,8 +365,8 @@ void Timers::WriteRegister(u32 offset, u32 value)
   if (timer_index < 2 && cs.external_counting_enabled)
   {
     // timers 0/1 depend on the GPU
-    if (timer_index == 0 || g_gpu->IsCRTCScanlinePending())
+    if (timer_index == 0 || g_gpu.IsCRTCScanlinePending())
-      g_gpu->SynchronizeCRTC();
+      g_gpu.SynchronizeCRTC();
   }
 
   s_state.sysclk_event.InvokeEarly();

src/core/timing_event.cpp

@@ -10,6 +10,7 @@
 
 #include "common/assert.h"
 #include "common/log.h"
+#include "common/small_string.h"
 #include "common/thirdparty/SmallVector.h"
 
 LOG_CHANNEL(TimingEvents);

src/duckstation-qt/qthost.cpp

@@ -2081,7 +2081,7 @@ void EmuThread::updatePerformanceCounters(const GPUBackend* gpu_backend)
   if (gpu_backend)
   {
     const u32 render_scale = gpu_backend->GetResolutionScale();
-    std::tie(render_width, render_height) = g_gpu->GetFullDisplayResolution();
+    std::tie(render_width, render_height) = g_gpu.GetFullDisplayResolution();
     render_width *= render_scale;
     render_height *= render_scale;
   }