VideoCommon: Eliminate static state in Renderer

Source/Core/Core/Core.cpp

@@ -738,7 +738,7 @@ void SaveScreenShot()
 
   SetState(State::Paused);
 
-  Renderer::SetScreenshot(GenerateScreenshotName());
+  g_renderer->SetScreenshot(GenerateScreenshotName());
 
   if (!bPaused)
     SetState(State::Running);
@@ -752,7 +752,7 @@ void SaveScreenShot(const std::string& name)
 
   std::string filePath = GenerateScreenshotFolderPath() + name + ".png";
 
-  Renderer::SetScreenshot(filePath);
+  g_renderer->SetScreenshot(filePath);
 
   if (!bPaused)
     SetState(State::Running);

Source/Core/VideoBackends/D3D/FramebufferManager.cpp

@@ -100,8 +100,8 @@ D3DTexture2D*& FramebufferManager::GetResolvedEFBDepthTexture()
 
 FramebufferManager::FramebufferManager()
 {
-  m_target_width = Renderer::GetTargetWidth();
-  m_target_height = Renderer::GetTargetHeight();
+  m_target_width = g_renderer->GetTargetWidth();
+  m_target_height = g_renderer->GetTargetHeight();
   if (m_target_height < 1)
   {
     m_target_height = 1;
@@ -318,8 +318,8 @@ void XFBSource::CopyEFB(float Gamma)
   D3D::SetPointCopySampler();
 
   D3D::drawShadedTexQuad(
-      FramebufferManager::GetEFBColorTexture()->GetSRV(), &rect, Renderer::GetTargetWidth(),
-      Renderer::GetTargetHeight(), PixelShaderCache::GetColorCopyProgram(true),
+      FramebufferManager::GetEFBColorTexture()->GetSRV(), &rect, g_renderer->GetTargetWidth(),
+      g_renderer->GetTargetHeight(), PixelShaderCache::GetColorCopyProgram(true),
       VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout(),
       GeometryShaderCache::GetCopyGeometryShader(), Gamma);
 

Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp

@@ -137,7 +137,7 @@ void PSTextureEncoder::Encode(u8* dst, u32 format, u32 native_width, u32 bytes_p
       D3D::SetPointCopySampler();
 
     D3D::drawShadedTexQuad(
-        pEFB, targetRect.AsRECT(), Renderer::GetTargetWidth(), Renderer::GetTargetHeight(),
+        pEFB, targetRect.AsRECT(), g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(),
         SetStaticShader(format, is_depth_copy, isIntensity, scaleByHalf),
         VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout());
 

Source/Core/VideoBackends/D3D/Render.cpp

@@ -324,8 +324,7 @@ bool Renderer::CheckForResize()
   int client_height = rcWindow.bottom - rcWindow.top;
 
   // Sanity check
-  if ((client_width != Renderer::GetBackbufferWidth() ||
-       client_height != Renderer::GetBackbufferHeight()) &&
+  if ((client_width != GetBackbufferWidth() || client_height != GetBackbufferHeight()) &&
       client_width >= 4 && client_height >= 4)
   {
     return true;

Source/Core/VideoBackends/D3D/Render.h

@@ -60,7 +60,7 @@ public:
 
   void ReinterpretPixelData(unsigned int convtype) override;
 
-  static bool CheckForResize();
+  bool CheckForResize();
 
   u32 GetMaxTextureSize() override;
 

Source/Core/VideoBackends/D3D/TextureCache.cpp

@@ -240,7 +240,7 @@ void TextureCache::TCacheEntry::FromRenderTarget(bool is_depth_copy, const EFBRe
 
   // Create texture copy
   D3D::drawShadedTexQuad(
-      efbTexSRV, &sourcerect, Renderer::GetTargetWidth(), Renderer::GetTargetHeight(),
+      efbTexSRV, &sourcerect, g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(),
       is_depth_copy ? PixelShaderCache::GetDepthMatrixProgram(multisampled) :
                       PixelShaderCache::GetColorMatrixProgram(multisampled),
       VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout(),

Source/Core/VideoBackends/D3D12/FramebufferManager.cpp

@@ -86,8 +86,8 @@ D3DTexture2D*& FramebufferManager::GetResolvedEFBDepthTexture()
 
 FramebufferManager::FramebufferManager()
 {
-  m_target_width = std::max(Renderer::GetTargetWidth(), 1);
-  m_target_height = std::max(Renderer::GetTargetHeight(), 1);
+  m_target_width = std::max(g_renderer->GetTargetWidth(), 1);
+  m_target_height = std::max(g_renderer->GetTargetHeight(), 1);
 
   DXGI_SAMPLE_DESC sample_desc;
   sample_desc.Count = g_ActiveConfig.iMultisamples;
@@ -525,7 +525,7 @@ void XFBSource::CopyEFB(float gamma)
   D3D::SetPointCopySampler();
 
   D3D::DrawShadedTexQuad(FramebufferManager::GetEFBColorTexture(), &rect,
-                         Renderer::GetTargetWidth(), Renderer::GetTargetHeight(),
+                         g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(),
                          StaticShaderCache::GetColorCopyPixelShader(true),
                          StaticShaderCache::GetSimpleVertexShader(),
                          StaticShaderCache::GetSimpleVertexShaderInputLayout(),

Source/Core/VideoBackends/D3D12/PSTextureEncoder.cpp

@@ -166,7 +166,7 @@ void PSTextureEncoder::Encode(u8* dst, u32 format, u32 native_width, u32 bytes_p
     D3D::SetPointCopySampler();
 
   D3D::DrawShadedTexQuad(
-      efb_source, target_rect.AsRECT(), Renderer::GetTargetWidth(), Renderer::GetTargetHeight(),
+      efb_source, target_rect.AsRECT(), g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(),
       SetStaticShader(format, is_depth_copy, is_intensity, scale_by_half),
       StaticShaderCache::GetSimpleVertexShader(),
       StaticShaderCache::GetSimpleVertexShaderInputLayout(), D3D12_SHADER_BYTECODE(), 1.0f, 0,

Source/Core/VideoBackends/D3D12/Render.cpp

@@ -308,7 +308,7 @@ TargetRectangle Renderer::ConvertEFBRectangle(const EFBRectangle& rc)
 
 // With D3D, we have to resize the backbuffer if the window changed
 // size.
-__declspec(noinline) bool Renderer::CheckForResize()
+bool Renderer::CheckForResize()
 {
   RECT rc_window;
   GetClientRect(D3D::hWnd, &rc_window);

Source/Core/VideoBackends/D3D12/Render.h

@@ -59,7 +59,7 @@ public:
 
   void ReinterpretPixelData(unsigned int conv_type) override;
 
-  static bool CheckForResize();
+  bool CheckForResize();
 
   u32 GetMaxTextureSize() override;
 

Source/Core/VideoBackends/D3D12/TextureCache.cpp

@@ -288,7 +288,7 @@ void TextureCache::TCacheEntry::FromRenderTarget(bool is_depth_copy, const EFBRe
 
   // Create texture copy
   D3D::DrawShadedTexQuad(
-      efb_tex, &sourcerect, Renderer::GetTargetWidth(), Renderer::GetTargetHeight(),
+      efb_tex, &sourcerect, g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(),
       is_depth_copy ? StaticShaderCache::GetDepthMatrixPixelShader(multisampled) :
                       StaticShaderCache::GetColorMatrixPixelShader(multisampled),
       StaticShaderCache::GetSimpleVertexShader(),

Source/Core/VideoBackends/OGL/Render.h

@@ -71,8 +71,8 @@ public:
   Renderer();
   ~Renderer();
 
-  static void Init();
-  static void Shutdown();
+  void Init();
+  void Shutdown();
 
   void SetBlendMode(bool forceUpdate) override;
   void SetScissorRect(const EFBRectangle& rc) override;

Source/Core/VideoBackends/OGL/main.cpp

@@ -149,7 +149,7 @@ void VideoBackend::Video_Prepare()
   ProgramShaderCache::Init();
   g_texture_cache = std::make_unique<TextureCache>();
   g_sampler_cache = std::make_unique<SamplerCache>();
-  Renderer::Init();
+  static_cast<Renderer*>(g_renderer.get())->Init();
   TextureConverter::Init();
   BoundingBox::Init();
 }
@@ -166,7 +166,7 @@ void VideoBackend::Video_Cleanup()
   // The following calls are NOT Thread Safe
   // And need to be called from the video thread
   CleanupShared();
-  Renderer::Shutdown();
+  static_cast<Renderer*>(g_renderer.get())->Shutdown();
   BoundingBox::Shutdown();
   TextureConverter::Shutdown();
   g_sampler_cache.reset();

Source/Core/VideoBackends/Vulkan/FramebufferManager.cpp

@@ -226,8 +226,8 @@ void FramebufferManager::DestroyEFBRenderPass()
 
 bool FramebufferManager::CreateEFBFramebuffer()
 {
-  m_efb_width = static_cast<u32>(std::max(Renderer::GetTargetWidth(), 1));
-  m_efb_height = static_cast<u32>(std::max(Renderer::GetTargetHeight(), 1));
+  m_efb_width = static_cast<u32>(std::max(g_renderer->GetTargetWidth(), 1));
+  m_efb_height = static_cast<u32>(std::max(g_renderer->GetTargetHeight(), 1));
   m_efb_layers = (g_ActiveConfig.iStereoMode != STEREO_OFF) ? 2 : 1;
   INFO_LOG(VIDEO, "EFB size: %ux%ux%u", m_efb_width, m_efb_height, m_efb_layers);
 

Source/Core/VideoCommon/AsyncRequests.cpp

@@ -136,8 +136,8 @@ void AsyncRequests::HandleEvent(const AsyncRequests::Event& e)
     break;
 
   case Event::SWAP_EVENT:
-    Renderer::Swap(e.swap_event.xfbAddr, e.swap_event.fbWidth, e.swap_event.fbStride,
-                   e.swap_event.fbHeight, rc, e.time);
+    g_renderer->Swap(e.swap_event.xfbAddr, e.swap_event.fbWidth, e.swap_event.fbStride,
+                     e.swap_event.fbHeight, rc, e.time);
     break;
 
   case Event::BBOX_READ:

Source/Core/VideoCommon/BPFunctions.cpp

@@ -156,7 +156,7 @@ void OnPixelFormatChange()
   if (!g_ActiveConfig.bEFBEmulateFormatChanges)
     return;
 
-  auto old_format = Renderer::GetPrevPixelFormat();
+  auto old_format = g_renderer->GetPrevPixelFormat();
   auto new_format = bpmem.zcontrol.pixel_format;
 
   // no need to reinterpret pixel data in these cases
@@ -209,7 +209,7 @@ skip:
   DEBUG_LOG(VIDEO, "pixelfmt: pixel=%d, zc=%d", static_cast<int>(new_format),
             static_cast<int>(bpmem.zcontrol.zformat));
 
-  Renderer::StorePixelFormat(new_format);
+  g_renderer->StorePixelFormat(new_format);
 }
 
 void SetInterlacingMode(const BPCmd& bp)

Source/Core/VideoCommon/BPStructs.cpp

@@ -261,7 +261,7 @@ static void BPWritten(const BPCmd& bp)
                        "fbStride: %u | fbHeight: %u",
                 destAddr, srcRect.left, srcRect.top, srcRect.right, srcRect.bottom,
                 bpmem.copyTexSrcWH.x + 1, destStride, height);
-      Renderer::RenderToXFB(destAddr, srcRect, destStride, height, s_gammaLUT[PE_copy.gamma]);
+      g_renderer->RenderToXFB(destAddr, srcRect, destStride, height, s_gammaLUT[PE_copy.gamma]);
     }
 
     // Clear the rectangular region after copying it.

Source/Core/VideoCommon/FramebufferManagerBase.cpp

@@ -253,8 +253,8 @@ int FramebufferManagerBase::ScaleToVirtualXfbWidth(int x)
   if (g_ActiveConfig.RealXFBEnabled())
     return x;
 
-  return x * (int)Renderer::GetTargetRectangle().GetWidth() /
-         (int)FramebufferManagerBase::LastXfbWidth();
+  return x * static_cast<int>(g_renderer->GetTargetRectangle().GetWidth()) /
+         static_cast<int>(FramebufferManagerBase::LastXfbWidth());
 }
 
 int FramebufferManagerBase::ScaleToVirtualXfbHeight(int y)
@@ -262,6 +262,6 @@ int FramebufferManagerBase::ScaleToVirtualXfbHeight(int y)
   if (g_ActiveConfig.RealXFBEnabled())
     return y;
 
-  return y * (int)Renderer::GetTargetRectangle().GetHeight() /
-         (int)FramebufferManagerBase::LastXfbHeight();
+  return y * static_cast<int>(g_renderer->GetTargetRectangle().GetHeight()) /
+         static_cast<int>(FramebufferManagerBase::LastXfbHeight());
 }

Source/Core/VideoCommon/PixelShaderManager.cpp

@@ -27,7 +27,6 @@ void PixelShaderManager::Init()
   s_bFogRangeAdjustChanged = true;
   s_bViewPortChanged = false;
 
-  SetEfbScaleChanged();
   SetIndMatrixChanged(0);
   SetIndMatrixChanged(1);
   SetIndMatrixChanged(2);
@@ -78,7 +77,8 @@ void PixelShaderManager::SetConstants()
       // so to simplify I use the hi coefficient as K in the shader taking 256 as the scale
       // TODO: Shouldn't this be EFBToScaledXf?
       constants.fogf[0][0] = ScreenSpaceCenter;
-      constants.fogf[0][1] = (float)Renderer::EFBToScaledX((int)(2.0f * xfmem.viewport.wd));
+      constants.fogf[0][1] =
+          static_cast<float>(g_renderer->EFBToScaledX(static_cast<int>(2.0f * xfmem.viewport.wd)));
       constants.fogf[0][2] = bpmem.fogRange.K[4].HI / 256.0f;
     }
     else
@@ -161,8 +161,8 @@ void PixelShaderManager::SetViewportChanged()
 
 void PixelShaderManager::SetEfbScaleChanged()
 {
-  constants.efbscale[0] = 1.0f / Renderer::EFBToScaledXf(1);
-  constants.efbscale[1] = 1.0f / Renderer::EFBToScaledYf(1);
+  constants.efbscale[0] = 1.0f / g_renderer->EFBToScaledXf(1);
+  constants.efbscale[1] = 1.0f / g_renderer->EFBToScaledYf(1);
   dirty = true;
 }
 

Source/Core/VideoCommon/RenderBase.cpp

@@ -64,39 +64,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
@@ -118,11 +85,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();