Merge pull request #4999 from stenzek/renderer-statics

VideoCommon: Eliminate static state in Renderer

1 files changed, 92 insertions, 106 deletions

diff --git a/Source/Core/VideoCommon/RenderBase.cpp b/Source/Core/VideoCommon/RenderBase.cpp
index f47288ea4e..7e598e2373 100644
--- a/Source/Core/VideoCommon/RenderBase.cpp
+++ b/Source/Core/VideoCommon/RenderBase.cpp
@@ -50,6 +50,7 @@
 #include "VideoCommon/FramebufferManagerBase.h"
 #include "VideoCommon/ImageWrite.h"
 #include "VideoCommon/OnScreenDisplay.h"
+#include "VideoCommon/PixelShaderManager.h"
 #include "VideoCommon/PostProcessing.h"
 #include "VideoCommon/Statistics.h"
 #include "VideoCommon/TextureCacheBase.h"
@@ -64,39 +65,6 @@ static int OSDTime;
 
 std::unique_ptr<Renderer> g_renderer;
 
-std::mutex Renderer::s_criticalScreenshot;
-std::string Renderer::s_sScreenshotName;
-
-Common::Event Renderer::s_screenshotCompleted;
-Common::Flag Renderer::s_screenshot;
-
-// The framebuffer size
-int Renderer::s_target_width;
-int Renderer::s_target_height;
-
-// TODO: Add functionality to reinit all the render targets when the window is resized.
-int Renderer::s_backbuffer_width;
-int Renderer::s_backbuffer_height;
-
-std::unique_ptr<PostProcessingShaderImplementation> Renderer::m_post_processor;
-
-// Final surface changing
-Common::Flag Renderer::s_surface_needs_change;
-Common::Event Renderer::s_surface_changed;
-void* Renderer::s_new_surface_handle;
-
-TargetRectangle Renderer::target_rc;
-
-int Renderer::s_last_efb_scale;
-
-bool Renderer::XFBWrited;
-
-PEControl::PixelFormat Renderer::prev_efb_format = PEControl::INVALID_FMT;
-unsigned int Renderer::efb_scale_numeratorX = 1;
-unsigned int Renderer::efb_scale_numeratorY = 1;
-unsigned int Renderer::efb_scale_denominatorX = 1;
-unsigned int Renderer::efb_scale_denominatorY = 1;
-
 // The maximum depth that is written to the depth buffer should never exceed this value.
 // This is necessary because we use a 2^24 divisor for all our depth values to prevent
 // floating-point round-trip errors. However the console GPU doesn't ever write a value
@@ -108,9 +76,16 @@ static float AspectToWidescreen(float aspect)
   return aspect * ((16.0f / 9.0f) / (4.0f / 3.0f));
 }
 
-Renderer::Renderer()
+Renderer::Renderer(int backbuffer_width, int backbuffer_height)
+    : m_backbuffer_width(backbuffer_width), m_backbuffer_height(backbuffer_height),
+      m_last_efb_scale(g_ActiveConfig.iEFBScale)
 {
+  FramebufferManagerBase::SetLastXfbWidth(MAX_XFB_WIDTH);
+  FramebufferManagerBase::SetLastXfbHeight(MAX_XFB_HEIGHT);
+
   UpdateActiveConfig();
+  CalculateTargetSize();
+  UpdateDrawRectangle();
 
   OSDChoice = 0;
   OSDTime = 0;
@@ -118,11 +93,6 @@ Renderer::Renderer()
 
 Renderer::~Renderer()
 {
-  // invalidate previous efb format
-  prev_efb_format = PEControl::INVALID_FMT;
-
-  efb_scale_numeratorX = efb_scale_numeratorY = efb_scale_denominatorX = efb_scale_denominatorY = 1;
-
   ShutdownFrameDumping();
   if (m_frame_dump_thread.joinable())
     m_frame_dump_thread.join();
@@ -136,7 +106,7 @@ void Renderer::RenderToXFB(u32 xfbAddr, const EFBRectangle& sourceRc, u32 fbStri
   if (!fbStride || !fbHeight)
     return;
 
-  XFBWrited = true;
+  m_xfb_written = true;
 
   if (g_ActiveConfig.bUseXFB)
   {
@@ -160,7 +130,7 @@ int Renderer::EFBToScaledX(int x)
     return FramebufferManagerBase::ScaleToVirtualXfbWidth(x);
 
   default:
-    return x * (int)efb_scale_numeratorX / (int)efb_scale_denominatorX;
+    return x * (int)m_efb_scale_numeratorX / (int)m_efb_scale_denominatorX;
   };
 }
 
@@ -172,7 +142,7 @@ int Renderer::EFBToScaledY(int y)
     return FramebufferManagerBase::ScaleToVirtualXfbHeight(y);
 
   default:
-    return y * (int)efb_scale_numeratorY / (int)efb_scale_denominatorY;
+    return y * (int)m_efb_scale_numeratorY / (int)m_efb_scale_denominatorY;
   };
 }
 
@@ -185,8 +155,8 @@ void Renderer::CalculateTargetScale(int x, int y, int* scaledX, int* scaledY)
   }
   else
   {
-    *scaledX = x * (int)efb_scale_numeratorX / (int)efb_scale_denominatorX;
-    *scaledY = y * (int)efb_scale_numeratorY / (int)efb_scale_denominatorY;
+    *scaledX = x * (int)m_efb_scale_numeratorX / (int)m_efb_scale_denominatorX;
+    *scaledY = y * (int)m_efb_scale_numeratorY / (int)m_efb_scale_denominatorY;
   }
 }
 
@@ -196,71 +166,74 @@ bool Renderer::CalculateTargetSize()
   int newEFBWidth, newEFBHeight;
   newEFBWidth = newEFBHeight = 0;
 
+  m_last_efb_scale = g_ActiveConfig.iEFBScale;
+
   // TODO: Ugly. Clean up
-  switch (s_last_efb_scale)
+  switch (m_last_efb_scale)
   {
   case SCALE_AUTO:
   case SCALE_AUTO_INTEGRAL:
     newEFBWidth = FramebufferManagerBase::ScaleToVirtualXfbWidth(EFB_WIDTH);
     newEFBHeight = FramebufferManagerBase::ScaleToVirtualXfbHeight(EFB_HEIGHT);
 
-    if (s_last_efb_scale == SCALE_AUTO_INTEGRAL)
+    if (m_last_efb_scale == SCALE_AUTO_INTEGRAL)
     {
-      efb_scale_numeratorX = efb_scale_numeratorY =
+      m_efb_scale_numeratorX = m_efb_scale_numeratorY =
           std::max((newEFBWidth - 1) / EFB_WIDTH + 1, (newEFBHeight - 1) / EFB_HEIGHT + 1);
-      efb_scale_denominatorX = efb_scale_denominatorY = 1;
+      m_efb_scale_denominatorX = m_efb_scale_denominatorY = 1;
       newEFBWidth = EFBToScaledX(EFB_WIDTH);
       newEFBHeight = EFBToScaledY(EFB_HEIGHT);
     }
     else
     {
-      efb_scale_numeratorX = newEFBWidth;
-      efb_scale_denominatorX = EFB_WIDTH;
-      efb_scale_numeratorY = newEFBHeight;
-      efb_scale_denominatorY = EFB_HEIGHT;
+      m_efb_scale_numeratorX = newEFBWidth;
+      m_efb_scale_denominatorX = EFB_WIDTH;
+      m_efb_scale_numeratorY = newEFBHeight;
+      m_efb_scale_denominatorY = EFB_HEIGHT;
     }
     break;
 
   case SCALE_1X:
-    efb_scale_numeratorX = efb_scale_numeratorY = 1;
-    efb_scale_denominatorX = efb_scale_denominatorY = 1;
+    m_efb_scale_numeratorX = m_efb_scale_numeratorY = 1;
+    m_efb_scale_denominatorX = m_efb_scale_denominatorY = 1;
     break;
 
   case SCALE_1_5X:
-    efb_scale_numeratorX = efb_scale_numeratorY = 3;
-    efb_scale_denominatorX = efb_scale_denominatorY = 2;
+    m_efb_scale_numeratorX = m_efb_scale_numeratorY = 3;
+    m_efb_scale_denominatorX = m_efb_scale_denominatorY = 2;
     break;
 
   case SCALE_2X:
-    efb_scale_numeratorX = efb_scale_numeratorY = 2;
-    efb_scale_denominatorX = efb_scale_denominatorY = 1;
+    m_efb_scale_numeratorX = m_efb_scale_numeratorY = 2;
+    m_efb_scale_denominatorX = m_efb_scale_denominatorY = 1;
     break;
 
   case SCALE_2_5X:
-    efb_scale_numeratorX = efb_scale_numeratorY = 5;
-    efb_scale_denominatorX = efb_scale_denominatorY = 2;
+    m_efb_scale_numeratorX = m_efb_scale_numeratorY = 5;
+    m_efb_scale_denominatorX = m_efb_scale_denominatorY = 2;
     break;
 
   default:
-    efb_scale_numeratorX = efb_scale_numeratorY = s_last_efb_scale - 3;
-    efb_scale_denominatorX = efb_scale_denominatorY = 1;
+    m_efb_scale_numeratorX = m_efb_scale_numeratorY = m_last_efb_scale - 3;
+    m_efb_scale_denominatorX = m_efb_scale_denominatorY = 1;
 
     const u32 max_size = GetMaxTextureSize();
-    if (max_size < EFB_WIDTH * efb_scale_numeratorX / efb_scale_denominatorX)
+    if (max_size < EFB_WIDTH * m_efb_scale_numeratorX / m_efb_scale_denominatorX)
     {
-      efb_scale_numeratorX = efb_scale_numeratorY = (max_size / EFB_WIDTH);
-      efb_scale_denominatorX = efb_scale_denominatorY = 1;
+      m_efb_scale_numeratorX = m_efb_scale_numeratorY = (max_size / EFB_WIDTH);
+      m_efb_scale_denominatorX = m_efb_scale_denominatorY = 1;
     }
 
     break;
   }
-  if (s_last_efb_scale > SCALE_AUTO_INTEGRAL)
+  if (m_last_efb_scale > SCALE_AUTO_INTEGRAL)
     CalculateTargetScale(EFB_WIDTH, EFB_HEIGHT, &newEFBWidth, &newEFBHeight);
 
-  if (newEFBWidth != s_target_width || newEFBHeight != s_target_height)
+  if (newEFBWidth != m_target_width || newEFBHeight != m_target_height)
   {
-    s_target_width = newEFBWidth;
-    s_target_height = newEFBHeight;
+    m_target_width = newEFBWidth;
+    m_target_height = newEFBHeight;
+    PixelShaderManager::SetEfbScaleChanged(EFBToScaledXf(1), EFBToScaledYf(1));
     return true;
   }
   return false;
@@ -289,25 +262,34 @@ void Renderer::ConvertStereoRectangle(const TargetRectangle& rc, TargetRectangle
   leftRc = drawRc, rightRc = drawRc;
   if (g_ActiveConfig.iStereoMode == STEREO_TAB)
   {
-    leftRc.top -= s_backbuffer_height / 4;
-    leftRc.bottom -= s_backbuffer_height / 4;
-    rightRc.top += s_backbuffer_height / 4;
-    rightRc.bottom += s_backbuffer_height / 4;
+    leftRc.top -= m_backbuffer_height / 4;
+    leftRc.bottom -= m_backbuffer_height / 4;
+    rightRc.top += m_backbuffer_height / 4;
+    rightRc.bottom += m_backbuffer_height / 4;
   }
   else
   {
-    leftRc.left -= s_backbuffer_width / 4;
-    leftRc.right -= s_backbuffer_width / 4;
-    rightRc.left += s_backbuffer_width / 4;
-    rightRc.right += s_backbuffer_width / 4;
+    leftRc.left -= m_backbuffer_width / 4;
+    leftRc.right -= m_backbuffer_width / 4;
+    rightRc.left += m_backbuffer_width / 4;
+    rightRc.right += m_backbuffer_width / 4;
   }
 }
 
-void Renderer::SetScreenshot(const std::string& filename)
+void Renderer::SaveScreenshot(const std::string& filename, bool wait_for_completion)
 {
-  std::lock_guard<std::mutex> lk(s_criticalScreenshot);
-  s_sScreenshotName = filename;
-  s_screenshot.Set();
+  // We must not hold the lock while waiting for the screenshot to complete.
+  {
+    std::lock_guard<std::mutex> lk(m_screenshot_lock);
+    m_screenshot_name = filename;
+    m_screenshot_request.Set();
+  }
+
+  if (wait_for_completion)
+  {
+    // This is currently only used by Android, and it was using a wait time of 2 seconds.
+    m_screenshot_completed.WaitFor(std::chrono::seconds(2));
+  }
 }
 
 // Create On-Screen-Messages
@@ -460,7 +442,7 @@ float Renderer::CalculateDrawAspectRatio(int target_width, int target_height)
   {
     // If stretch is enabled, we prefer the aspect ratio of the window.
     return (static_cast<float>(target_width) / static_cast<float>(target_height)) /
-           (static_cast<float>(s_backbuffer_width) / static_cast<float>(s_backbuffer_height));
+           (static_cast<float>(m_backbuffer_width) / static_cast<float>(m_backbuffer_height));
   }
 
   // The rendering window aspect ratio as a proportion of the 4:3 or 16:9 ratio
@@ -505,8 +487,8 @@ TargetRectangle Renderer::CalculateFrameDumpDrawRectangle()
   if (!g_ActiveConfig.bInternalResolutionFrameDumps || g_ActiveConfig.RealXFBEnabled())
   {
     // But still remove the borders, since the caller expects this.
-    rc.right = target_rc.GetWidth();
-    rc.bottom = target_rc.GetHeight();
+    rc.right = m_target_rectangle.GetWidth();
+    rc.bottom = m_target_rectangle.GetHeight();
     return rc;
   }
 
@@ -524,8 +506,8 @@ TargetRectangle Renderer::CalculateFrameDumpDrawRectangle()
 
 void Renderer::UpdateDrawRectangle()
 {
-  float FloatGLWidth = static_cast<float>(s_backbuffer_width);
-  float FloatGLHeight = static_cast<float>(s_backbuffer_height);
+  float FloatGLWidth = static_cast<float>(m_backbuffer_width);
+  float FloatGLHeight = static_cast<float>(m_backbuffer_height);
   float FloatXOffset = 0;
   float FloatYOffset = 0;
 
@@ -584,7 +566,7 @@ void Renderer::UpdateDrawRectangle()
   // Check for force-settings and override.
 
   // The rendering window aspect ratio as a proportion of the 4:3 or 16:9 ratio
-  float Ratio = CalculateDrawAspectRatio(s_backbuffer_width, s_backbuffer_height);
+  float Ratio = CalculateDrawAspectRatio(m_backbuffer_width, m_backbuffer_height);
   if (g_ActiveConfig.iAspectRatio != ASPECT_STRETCH)
   {
     if (Ratio >= 0.995f && Ratio <= 1.005f)
@@ -638,18 +620,16 @@ void Renderer::UpdateDrawRectangle()
       iWhidth % 4;  // ensure divisibility by 4 to make it compatible with all the video encoders
   iHeight -= iHeight % 4;
 
-  target_rc.left = XOffset;
-  target_rc.top = YOffset;
-  target_rc.right = XOffset + iWhidth;
-  target_rc.bottom = YOffset + iHeight;
+  m_target_rectangle.left = XOffset;
+  m_target_rectangle.top = YOffset;
+  m_target_rectangle.right = XOffset + iWhidth;
+  m_target_rectangle.bottom = YOffset + iHeight;
 }
 
 void Renderer::SetWindowSize(int width, int height)
 {
-  if (width < 1)
-    width = 1;
-  if (height < 1)
-    height = 1;
+  width = std::max(width, 1);
+  height = std::max(height, 1);
 
   // Scale the window size by the EFB scale.
   CalculateTargetScale(width, height, &width, &height);
@@ -686,7 +666,13 @@ void Renderer::SetWindowSize(int width, int height)
   width -= width % 4;
   height -= height % 4;
 
-  Host_RequestRenderWindowSize(width, height);
+  // Track the last values of width/height to avoid sending a window resize event every frame.
+  if (width != m_last_window_request_width || height != m_last_window_request_height)
+  {
+    m_last_window_request_width = width;
+    m_last_window_request_height = height;
+    Host_RequestRenderWindowSize(width, height);
+  }
 }
 
 void Renderer::CheckFifoRecording()
@@ -728,7 +714,7 @@ void Renderer::Swap(u32 xfbAddr, u32 fbWidth, u32 fbStride, u32 fbHeight, const
   // TODO: merge more generic parts into VideoCommon
   g_renderer->SwapImpl(xfbAddr, fbWidth, fbStride, fbHeight, rc, ticks, Gamma);
 
-  if (XFBWrited)
+  if (m_xfb_written)
     g_renderer->m_fps_counter.Update();
 
   frameCount++;
@@ -739,14 +725,14 @@ void Renderer::Swap(u32 xfbAddr, u32 fbWidth, u32 fbStride, u32 fbHeight, const
   // New frame
   stats.ResetFrame();
 
-  Core::Callback_VideoCopiedToXFB(XFBWrited ||
+  Core::Callback_VideoCopiedToXFB(m_xfb_written ||
                                   (g_ActiveConfig.bUseXFB && g_ActiveConfig.bUseRealXFB));
-  XFBWrited = false;
+  m_xfb_written = false;
 }
 
 bool Renderer::IsFrameDumping()
 {
-  if (s_screenshot.IsSet())
+  if (m_screenshot_request.IsSet())
     return true;
 
 #if defined(HAVE_LIBAV) || defined(_WIN32)
@@ -827,17 +813,17 @@ void Renderer::RunFrameDumps()
     }
 
     // Save screenshot
-    if (s_screenshot.TestAndClear())
+    if (m_screenshot_request.TestAndClear())
     {
-      std::lock_guard<std::mutex> lk(s_criticalScreenshot);
+      std::lock_guard<std::mutex> lk(m_screenshot_lock);
 
-      if (TextureToPng(config.data, config.stride, s_sScreenshotName, config.width, config.height,
+      if (TextureToPng(config.data, config.stride, m_screenshot_name, config.width, config.height,
                        false))
-        OSD::AddMessage("Screenshot saved to " + s_sScreenshotName);
+        OSD::AddMessage("Screenshot saved to " + m_screenshot_name);
 
       // Reset settings
-      s_sScreenshotName.clear();
-      s_screenshotCompleted.Set();
+      m_screenshot_name.clear();
+      m_screenshot_completed.Set();
     }
 
     if (SConfig::GetInstance().m_DumpFrames)