GPUThread: Update core thread window size on core thread

Avoid the barrier when reading it.

Author: stenzek

src/core/gpu_thread.cpp

@@ -74,7 +74,7 @@ static bool SleepGPUThread(bool allow_sleep);
 
 static bool CreateDeviceOnThread(RenderAPI api, bool fullscreen, bool preserve_fsui_state, Error* error);
 static void DestroyDeviceOnThread(bool preserve_fsui_state);
-static void ResizeDisplayWindowOnThread(u32 width, u32 height, float scale);
+static void ResizeDisplayWindowOnThread(u32 width, u32 height, float scale, float refresh_rate);
 static void UpdateDisplayWindowOnThread(bool fullscreen, bool allow_exclusive_fullscreen);
 static void DisplayWindowResizedOnThread();
 static bool CheckExclusiveFullscreenOnThread();
@@ -411,7 +411,6 @@ bool GPUThread::SleepGPUThread(bool allow_sleep)
 void GPUThread::Internal::GPUThreadEntryPoint()
 {
   s_state.gpu_thread = Threading::ThreadHandle::GetForCallingThread();
-  std::atomic_thread_fence(std::memory_order_release);
 
   // Take a local copy of the FIFO, that way it's not ping-ponging between the threads.
   u8* const command_fifo_data = s_state.command_fifo_data.get();
@@ -725,6 +724,8 @@ bool GPUThread::CreateDeviceOnThread(RenderAPI api, bool fullscreen, bool preser
     s_state.render_window_info = swap_chain->GetWindowInfo();
   else
     s_state.render_window_info = WindowInfo();
+  s_state.render_window_info.surface_width = std::max<u16>(s_state.render_window_info.surface_width, 1);
+  s_state.render_window_info.surface_height = std::max<u16>(s_state.render_window_info.surface_height, 1);
 
   std::atomic_thread_fence(std::memory_order_release);
   UpdateRunIdle();
@@ -1263,28 +1264,40 @@ bool GPUThread::IsUsingThread()
   return s_state.use_gpu_thread;
 }
 
-void GPUThread::ResizeDisplayWindow(s32 width, s32 height, float scale)
+void GPUThread::ResizeDisplayWindow(s32 width, s32 height, float scale, float refresh_rate)
 {
-  RunOnThread([width, height, scale]() { ResizeDisplayWindowOnThread(width, height, scale); });
+  s_state.render_window_info.surface_width =
+    static_cast<u16>(std::clamp<s32>(width, 1, std::numeric_limits<u16>::max()));
+  s_state.render_window_info.surface_height =
+    static_cast<u16>(std::clamp<s32>(height, 1, std::numeric_limits<u16>::max()));
+  s_state.render_window_info.surface_scale = scale;
+  s_state.render_window_info.surface_refresh_rate = refresh_rate;
+  RunOnThread(
+    [width, height, scale, refresh_rate]() { ResizeDisplayWindowOnThread(width, height, scale, refresh_rate); });
+  System::DisplayWindowResized();
 }
 
-void GPUThread::ResizeDisplayWindowOnThread(u32 width, u32 height, float scale)
+void GPUThread::ResizeDisplayWindowOnThread(u32 width, u32 height, float scale, float refresh_rate)
 {
   // We should _not_ be getting this without a device, since we should have shut down.
   if (!g_gpu_device || !g_gpu_device->HasMainSwapChain())
     return;
 
-  DEV_LOG("Display window resized to {}x{}", width, height);
+  DEV_LOG("Display window resized to {}x{} @ {}x/{}hz", width, height, scale, refresh_rate);
 
   Error error;
-  if (!g_gpu_device->GetMainSwapChain()->ResizeBuffers(width, height, scale, &error))
+  GPUSwapChain* const swap_chain = g_gpu_device->GetMainSwapChain();
+  if (!swap_chain->ResizeBuffers(width, height, &error))
   {
     // ick, CPU thread read, but this is unlikely to happen in the first place
     ERROR_LOG("Failed to resize main swap chain: {}", error.GetDescription());
     UpdateDisplayWindowOnThread(s_state.requested_fullscreen, true);
     return;
   }
 
+  swap_chain->SetScale(scale);
+  swap_chain->SetRefreshRate(refresh_rate);
+
   DisplayWindowResizedOnThread();
 }
 
@@ -1394,14 +1407,8 @@ bool GPUThread::CheckExclusiveFullscreenOnThread()
 
 void GPUThread::DisplayWindowResizedOnThread()
 {
-  const GPUSwapChain* swap_chain = g_gpu_device->GetMainSwapChain();
-  if (swap_chain)
-    s_state.render_window_info = swap_chain->GetWindowInfo();
-  else
-    s_state.render_window_info = WindowInfo();
-  std::atomic_thread_fence(std::memory_order_release);
-
   // surfaceless is usually temporary, so just ignore it
+  const GPUSwapChain* const swap_chain = g_gpu_device->GetMainSwapChain();
   if (!swap_chain)
     return;
 
@@ -1411,25 +1418,18 @@ void GPUThread::DisplayWindowResizedOnThread()
   ImGuiManager::WindowResized(swap_chain->GetFormat(), f_width, f_height);
   InputManager::SetDisplayWindowSize(f_width, f_height);
 
-  if (s_state.gpu_backend)
+  // If we're paused, re-present the current frame at the new window size.
+  if (s_state.gpu_backend && IsSystemPaused())
   {
-    Host::RunOnCoreThread(&System::DisplayWindowResized);
-
-    // If we're paused, re-present the current frame at the new window size.
-    if (IsSystemPaused())
-    {
-      // Hackity hack, on some systems, presenting a single frame isn't enough to actually get it
-      // displayed. Two seems to be good enough. Maybe something to do with direct scanout.
-      Internal::PresentFrameAndRestoreContext();
-      Internal::PresentFrameAndRestoreContext();
-    }
+    // Hackity hack, on some systems, presenting a single frame isn't enough to actually get it
+    // displayed. Two seems to be good enough. Maybe something to do with direct scanout.
+    Internal::PresentFrameAndRestoreContext();
+    Internal::PresentFrameAndRestoreContext();
   }
 }
 
 const WindowInfo& GPUThread::GetRenderWindowInfo()
 {
-  // This is infrequently used, so we can get away with a full barrier.
-  std::atomic_thread_fence(std::memory_order_acquire);
   return s_state.render_window_info;
 }
 

src/core/gpu_thread.h

@@ -66,7 +66,7 @@ void SetFullscreen(bool fullscreen);
 void SetFullscreenWithCompletionHandler(bool fullscreen, AsyncCallType completion_handler);
 
 /// Called when the window is resized.
-void ResizeDisplayWindow(s32 width, s32 height, float scale);
+void ResizeDisplayWindow(s32 width, s32 height, float scale, float refresh_rate);
 
 /// Access to main window size from CPU thread.
 const WindowInfo& GetRenderWindowInfo();

src/duckstation-mini/mini_host.cpp

@@ -113,6 +113,7 @@ struct SDLHostState
 
   SDL_Window* sdl_window = nullptr;
   float sdl_window_scale = 0.0f;
+  float sdl_window_refresh_rate = 0.0f;
   WindowInfo::PreRotation force_prerotation = WindowInfo::PreRotation::Identity;
 
   Threading::Thread core_thread;
@@ -496,6 +497,11 @@ std::optional<WindowInfo> MiniHost::TranslateSDLWindowInfo(SDL_Window* win, Erro
   {
     INFO_LOG("Display mode refresh rate: {} hz", dispmode->refresh_rate);
     wi.surface_refresh_rate = dispmode->refresh_rate;
+    s_state.sdl_window_refresh_rate = dispmode->refresh_rate;
+  }
+  else
+  {
+    s_state.sdl_window_refresh_rate = 0.0f;
   }
 
   // SDL's opengl window flag tends to make a mess of pixel formats...
@@ -748,10 +754,11 @@ void MiniHost::ProcessSDLEvent(const SDL_Event* ev)
   {
     case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
     {
-      Host::RunOnCoreThread(
-        [window_width = ev->window.data1, window_height = ev->window.data2, window_scale = s_state.sdl_window_scale]() {
-          GPUThread::ResizeDisplayWindow(window_width, window_height, window_scale);
-        });
+      Host::RunOnCoreThread([window_width = ev->window.data1, window_height = ev->window.data2,
+                             window_scale = s_state.sdl_window_scale,
+                             window_refresh_rate = s_state.sdl_window_refresh_rate]() {
+        GPUThread::ResizeDisplayWindow(window_width, window_height, window_scale, window_refresh_rate);
+      });
     }
     break;
 
@@ -765,8 +772,9 @@ void MiniHost::ProcessSDLEvent(const SDL_Event* ev)
 
         int window_width = 1, window_height = 1;
         SDL_GetWindowSizeInPixels(s_state.sdl_window, &window_width, &window_height);
-        Host::RunOnCoreThread([window_width, window_height, window_scale = s_state.sdl_window_scale]() {
-          GPUThread::ResizeDisplayWindow(window_width, window_height, window_scale);
+        Host::RunOnCoreThread([window_width, window_height, window_scale = s_state.sdl_window_scale,
+                               window_refresh_rate = s_state.sdl_window_refresh_rate]() {
+          GPUThread::ResizeDisplayWindow(window_width, window_height, window_scale, window_refresh_rate);
         });
       }
     }

src/duckstation-qt/displaywidget.cpp

@@ -71,6 +71,7 @@ void DisplayWidget::checkForSizeChange()
   if (!m_window_info.has_value())
     return;
 
+  // TODO: Handle refresh rate changes
   // avoid spamming resize events for paint events (sent on move on windows)
   const u16 prev_width = m_window_info->surface_width;
   const u16 prev_height = m_window_info->surface_height;
@@ -81,7 +82,8 @@ void DisplayWidget::checkForSizeChange()
   {
     DEV_LOG("Display widget resized to {}x{} (Qt {}x{}) DPR={}", m_window_info->surface_width,
             m_window_info->surface_height, width(), height(), m_window_info->surface_scale);
-    emit windowResizedEvent(m_window_info->surface_width, m_window_info->surface_height, m_window_info->surface_scale);
+    emit windowResizedEvent(m_window_info->surface_width, m_window_info->surface_height, m_window_info->surface_scale,
+                            m_window_info->surface_refresh_rate);
   }
 
   updateCenterPos();

src/duckstation-qt/displaywidget.h

@@ -42,7 +42,7 @@ class DisplayWidget final : public QWidget
   void destroy();
 
 Q_SIGNALS:
-  void windowResizedEvent(int width, int height, float scale);
+  void windowResizedEvent(int width, int height, float scale, float refresh_rate);
   void windowRestoredEvent();
   void windowKeyEvent(int key_code, bool pressed);
   void windowTextEntered(const QString& text);

src/duckstation-qt/qthost.cpp

@@ -963,9 +963,9 @@ void CoreThread::onDisplayWindowMouseWheelEvent(float dx, float dy)
     InputManager::UpdatePointerRelativeDelta(0, InputPointerAxis::WheelY, dy);
 }
 
-void CoreThread::onDisplayWindowResized(int width, int height, float scale)
+void CoreThread::onDisplayWindowResized(int width, int height, float scale, float refresh_rate)
 {
-  GPUThread::ResizeDisplayWindow(width, height, scale);
+  GPUThread::ResizeDisplayWindow(width, height, scale, refresh_rate);
 }
 
 void CoreThread::redrawDisplayWindow()

src/duckstation-qt/qthost.h

@@ -192,7 +192,7 @@ class CoreThread : public QThread
   void stopInThread();
   void onDisplayWindowMouseButtonEvent(int button, bool pressed);
   void onDisplayWindowMouseWheelEvent(float dx, float dy);
-  void onDisplayWindowResized(int width, int height, float scale);
+  void onDisplayWindowResized(int width, int height, float scale, float refresh_rate);
   void onDisplayWindowKeyEvent(int key, bool pressed);
   void onDisplayWindowTextEntered(const QString& text);
   void doBackgroundControllerPoll();

src/util/d3d11_device.cpp

@@ -413,9 +413,8 @@ bool D3D11SwapChain::CreateRTV(Error* error)
   return true;
 }
 
-bool D3D11SwapChain::ResizeBuffers(u32 new_width, u32 new_height, float new_scale, Error* error)
+bool D3D11SwapChain::ResizeBuffers(u32 new_width, u32 new_height, Error* error)
 {
-  m_window_info.surface_scale = new_scale;
   if (m_window_info.surface_width == new_width && m_window_info.surface_height == new_height)
     return true;
 

src/util/d3d11_device.h

@@ -232,7 +232,7 @@ class D3D11SwapChain : public GPUSwapChain
   ALWAYS_INLINE ID3D11RenderTargetView* const* GetRTVArray() const { return m_swap_chain_rtv.GetAddressOf(); }
   ALWAYS_INLINE bool IsUsingAllowTearing() const { return m_using_allow_tearing; }
 
-  bool ResizeBuffers(u32 new_width, u32 new_height, float new_scale, Error* error) override;
+  bool ResizeBuffers(u32 new_width, u32 new_height, Error* error) override;
   bool SetVSyncMode(GPUVSyncMode mode, bool allow_present_throttle, Error* error) override;
   bool IsExclusiveFullscreen() const override;
 

src/util/d3d12_device.cpp

@@ -1077,9 +1077,8 @@ bool D3D12SwapChain::IsExclusiveFullscreen() const
   return m_fullscreen_mode.has_value();
 }
 
-bool D3D12SwapChain::ResizeBuffers(u32 new_width, u32 new_height, float new_scale, Error* error)
+bool D3D12SwapChain::ResizeBuffers(u32 new_width, u32 new_height, Error* error)
 {
-  m_window_info.surface_scale = new_scale;
   if (m_window_info.surface_width == new_width && m_window_info.surface_height == new_height)
     return true;