Replace EFBRectangle/TargetRectangle with MathUtil::Rectangle

Source/Core/VideoBackends/D3D/Render.cpp

@@ -327,7 +327,7 @@ void Renderer::WaitForGPUIdle()
   D3D::context->Flush();
 }
 
-void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc)
+void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const MathUtil::Rectangle<int>& rc)
 {
   if (g_ActiveConfig.stereo_mode != StereoMode::Nvidia3DVision)
     return ::Renderer::RenderXFBToScreen(texture, rc);

Source/Core/VideoBackends/D3D/Render.h

@@ -67,7 +67,8 @@ public:
   void Flush() override;
   void WaitForGPUIdle() override;
 
-  void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc) override;
+  void RenderXFBToScreen(const AbstractTexture* texture,
+                         const MathUtil::Rectangle<int>& rc) override;
   void OnConfigChanged(u32 bits) override;
 
 private:

Source/Core/VideoBackends/D3D12/Renderer.cpp

@@ -132,7 +132,7 @@ void Renderer::WaitForGPUIdle()
   ExecuteCommandList(true);
 }
 
-void Renderer::ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable,
+void Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
                            bool z_enable, u32 color, u32 z)
 {
   // Use a fast path without the shader if both color/alpha are enabled.

Source/Core/VideoBackends/D3D12/Renderer.h

@@ -52,8 +52,8 @@ public:
   void Flush() override;
   void WaitForGPUIdle() override;
 
-  void ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable, bool z_enable,
-                   u32 color, u32 z) override;
+  void ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
+                   bool z_enable, u32 color, u32 z) override;
 
   void SetPipeline(const AbstractPipeline* pipeline) override;
   void SetFramebuffer(AbstractFramebuffer* framebuffer) override;

Source/Core/VideoBackends/Null/Render.h

@@ -37,8 +37,8 @@ public:
   u16 BBoxRead(int index) override { return 0; }
   void BBoxWrite(int index, u16 value) override {}
 
-  void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
-                   u32 color, u32 z) override
+  void ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
+                   bool zEnable, u32 color, u32 z) override
   {
   }
 

Source/Core/VideoBackends/Null/TextureCache.h

@@ -21,15 +21,17 @@ public:
 
 protected:
   void CopyEFB(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
-               u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
-               bool scale_by_half, bool linear_filter, float y_scale, float gamma, bool clamp_top,
-               bool clamp_bottom, const EFBCopyFilterCoefficients& filter_coefficients) override
+               u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
+               const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, bool linear_filter,
+               float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
+               const EFBCopyFilterCoefficients& filter_coefficients) override
   {
   }
 
-  void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
-                           bool scale_by_half, bool linear_filter, EFBCopyFormat dst_format,
-                           bool is_intensity, float gamma, bool clamp_top, bool clamp_bottom,
+  void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
+                           const MathUtil::Rectangle<int>& src_rect, bool scale_by_half,
+                           bool linear_filter, EFBCopyFormat dst_format, bool is_intensity,
+                           float gamma, bool clamp_top, bool clamp_bottom,
                            const EFBCopyFilterCoefficients& filter_coefficients) override
   {
   }

Source/Core/VideoBackends/OGL/Render.cpp

@@ -932,8 +932,8 @@ void Renderer::DispatchComputeShader(const AbstractShader* shader, u32 groups_x,
     glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
 }
 
-void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
-                           u32 color, u32 z)
+void Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
+                           bool zEnable, u32 color, u32 z)
 {
   g_framebuffer_manager->FlushEFBPokes();
   g_framebuffer_manager->FlagPeekCacheAsOutOfDate();
@@ -974,7 +974,7 @@ void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaE
   BPFunctions::SetScissor();
 }
 
-void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc)
+void Renderer::RenderXFBToScreen(const AbstractTexture* texture, const MathUtil::Rectangle<int>& rc)
 {
   // Quad-buffered stereo is annoying on GL.
   if (g_ActiveConfig.stereo_mode != StereoMode::QuadBuffer)

Source/Core/VideoBackends/OGL/Render.h

@@ -134,11 +134,12 @@ public:
 
   void Flush() override;
   void WaitForGPUIdle() override;
-  void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc) override;
+  void RenderXFBToScreen(const AbstractTexture* texture,
+                         const MathUtil::Rectangle<int>& rc) override;
   void OnConfigChanged(u32 bits) override;
 
-  void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
-                   u32 color, u32 z) override;
+  void ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
+                   bool zEnable, u32 color, u32 z) override;
 
   std::unique_ptr<VideoCommon::AsyncShaderCompiler> CreateAsyncShaderCompiler() override;
 

Source/Core/VideoBackends/Software/EfbInterface.cpp

@@ -549,8 +549,8 @@ u8* GetPixelPointer(u16 x, u16 y, bool depth)
   return &efb[GetColorOffset(x, y)];
 }
 
-void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const EFBRectangle& source_rect, float y_scale,
-               float gamma)
+void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const MathUtil::Rectangle<int>& source_rect,
+               float y_scale, float gamma)
 {
   if (!xfb_in_ram)
   {
@@ -628,8 +628,9 @@ void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const EFBRectangle& source_rec
     src_ptr += memory_stride;
   }
 
-  auto dest_rect = EFBRectangle{source_rect.left, source_rect.top, source_rect.right,
-                                static_cast<int>(static_cast<float>(source_rect.bottom) * y_scale)};
+  auto dest_rect =
+      MathUtil::Rectangle<int>{source_rect.left, source_rect.top, source_rect.right,
+                               static_cast<int>(static_cast<float>(source_rect.bottom) * y_scale)};
 
   const std::size_t destination_size = dest_rect.GetWidth() * dest_rect.GetHeight() * 2;
   static std::vector<yuv422_packed> destination;

Source/Core/VideoBackends/Software/EfbInterface.h

@@ -54,8 +54,8 @@ u32 GetDepth(u16 x, u16 y);
 
 u8* GetPixelPointer(u16 x, u16 y, bool depth);
 
-void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const EFBRectangle& source_rect, float y_scale,
-               float gamma);
+void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const MathUtil::Rectangle<int>& source_rect,
+               float y_scale, float gamma);
 
 u32 GetPerfQueryResult(PerfQueryType type);
 void ResetPerfQuery();

Source/Core/VideoBackends/Software/SWOGLWindow.cpp

@@ -84,7 +84,8 @@ bool SWOGLWindow::Initialize(const WindowSystemInfo& wsi)
   return true;
 }
 
-void SWOGLWindow::ShowImage(const AbstractTexture* image, const EFBRectangle& xfb_region)
+void SWOGLWindow::ShowImage(const AbstractTexture* image,
+                            const MathUtil::Rectangle<int>& xfb_region)
 {
   const SW::SWTexture* sw_image = static_cast<const SW::SWTexture*>(image);
   m_gl_context->Update();  // just updates the render window position and the backbuffer size

Source/Core/VideoBackends/Software/SWOGLWindow.h

@@ -25,7 +25,7 @@ public:
   bool IsHeadless() const;
 
   // Image to show, will be swapped immediately
-  void ShowImage(const AbstractTexture* image, const EFBRectangle& xfb_region);
+  void ShowImage(const AbstractTexture* image, const MathUtil::Rectangle<int>& xfb_region);
 
   static std::unique_ptr<SWOGLWindow> Create(const WindowSystemInfo& wsi);
 

Source/Core/VideoBackends/Software/SWRenderer.cpp

@@ -94,7 +94,8 @@ std::unique_ptr<AbstractPipeline> SWRenderer::CreatePipeline(const AbstractPipel
 }
 
 // Called on the GPU thread
-void SWRenderer::RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& xfb_region)
+void SWRenderer::RenderXFBToScreen(const AbstractTexture* texture,
+                                   const MathUtil::Rectangle<int>& xfb_region)
 {
   if (!IsHeadless())
     m_window->ShowImage(texture, xfb_region);
@@ -136,7 +137,7 @@ void SWRenderer::BBoxWrite(int index, u16 value)
   BoundingBox::coords[index] = value;
 }
 
-void SWRenderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable,
+void SWRenderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
                              bool zEnable, u32 color, u32 z)
 {
   EfbCopy::ClearEfb();

Source/Core/VideoBackends/Software/SWRenderer.h

@@ -42,10 +42,11 @@ public:
   u16 BBoxRead(int index) override;
   void BBoxWrite(int index, u16 value) override;
 
-  void RenderXFBToScreen(const AbstractTexture* texture, const EFBRectangle& rc) override;
+  void RenderXFBToScreen(const AbstractTexture* texture,
+                         const MathUtil::Rectangle<int>& rc) override;
 
-  void ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable,
-                   u32 color, u32 z) override;
+  void ClearScreen(const MathUtil::Rectangle<int>& rc, bool colorEnable, bool alphaEnable,
+                   bool zEnable, u32 color, u32 z) override;
 
   void ReinterpretPixelData(EFBReinterpretType convtype) override {}
 

Source/Core/VideoBackends/Software/TextureCache.h

@@ -11,16 +11,18 @@ class TextureCache : public TextureCacheBase
 {
 protected:
   void CopyEFB(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
-               u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
-               bool scale_by_half, bool linear_filter, float y_scale, float gamma, bool clamp_top,
-               bool clamp_bottom, const EFBCopyFilterCoefficients& filter_coefficients) override
+               u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
+               const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, bool linear_filter,
+               float y_scale, float gamma, bool clamp_top, bool clamp_bottom,
+               const EFBCopyFilterCoefficients& filter_coefficients) override
   {
     TextureEncoder::Encode(dst, params, native_width, bytes_per_row, num_blocks_y, memory_stride,
                            src_rect, scale_by_half, y_scale, gamma);
   }
-  void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
-                           bool scale_by_half, bool linear_filter, EFBCopyFormat dst_format,
-                           bool is_intensity, float gamma, bool clamp_top, bool clamp_bottom,
+  void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
+                           const MathUtil::Rectangle<int>& src_rect, bool scale_by_half,
+                           bool linear_filter, EFBCopyFormat dst_format, bool is_intensity,
+                           float gamma, bool clamp_top, bool clamp_bottom,
                            const EFBCopyFilterCoefficients& filter_coefficients) override
   {
     // TODO: If we ever want to "fake" vram textures, we would need to implement this

Source/Core/VideoBackends/Software/TextureEncoder.cpp

@@ -1422,7 +1422,7 @@ static void EncodeZ24halfscale(u8* dst, const u8* src, EFBCopyFormat format)
 namespace
 {
 void EncodeEfbCopy(u8* dst, const EFBCopyParams& params, u32 native_width, u32 bytes_per_row,
-                   u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
+                   u32 num_blocks_y, u32 memory_stride, const MathUtil::Rectangle<int>& src_rect,
                    bool scale_by_half)
 {
   const u8* src = EfbInterface::GetPixelPointer(src_rect.left, src_rect.top, params.depth);
@@ -1471,8 +1471,9 @@ void EncodeEfbCopy(u8* dst, const EFBCopyParams& params, u32 native_width, u32 b
 }
 
 void Encode(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
-            u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
-            bool scale_by_half, float y_scale, float gamma)
+            u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
+            const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, float y_scale,
+            float gamma)
 {
   // HACK: Override the memory stride for this staging texture with new copy stride.
   // This is required because the texture encoder assumes that we're writing directly to memory,

Source/Core/VideoBackends/Software/TextureEncoder.h

@@ -11,6 +11,7 @@
 namespace TextureEncoder
 {
 void Encode(AbstractStagingTexture* dst, const EFBCopyParams& params, u32 native_width,
-            u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride, const EFBRectangle& src_rect,
-            bool scale_by_half, float y_scale, float gamma);
+            u32 bytes_per_row, u32 num_blocks_y, u32 memory_stride,
+            const MathUtil::Rectangle<int>& src_rect, bool scale_by_half, float y_scale,
+            float gamma);
 }

Source/Core/VideoBackends/Vulkan/Renderer.cpp

@@ -147,14 +147,14 @@ void Renderer::BBoxFlush()
   m_bounding_box->Invalidate();
 }
 
-void Renderer::ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable,
+void Renderer::ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
                            bool z_enable, u32 color, u32 z)
 {
   g_framebuffer_manager->FlushEFBPokes();
   g_framebuffer_manager->FlagPeekCacheAsOutOfDate();
 
   // Native -> EFB coordinates
-  TargetRectangle target_rc = Renderer::ConvertEFBRectangle(rc);
+  MathUtil::Rectangle<int> target_rc = Renderer::ConvertEFBRectangle(rc);
 
   // Size we pass this size to vkBeginRenderPass, it has to be clamped to the framebuffer
   // dimensions. The other backends just silently ignore this case.

Source/Core/VideoBackends/Vulkan/Renderer.h

@@ -62,8 +62,8 @@ public:
   void WaitForGPUIdle() override;
   void OnConfigChanged(u32 bits) override;
 
-  void ClearScreen(const EFBRectangle& rc, bool color_enable, bool alpha_enable, bool z_enable,
-                   u32 color, u32 z) override;
+  void ClearScreen(const MathUtil::Rectangle<int>& rc, bool color_enable, bool alpha_enable,
+                   bool z_enable, u32 color, u32 z) override;
 
   void SetPipeline(const AbstractPipeline* pipeline) override;
   void SetFramebuffer(AbstractFramebuffer* framebuffer) override;