AbstractTexture: Seperate CopyRectangleFromTexture to two methods

ScaleRectangleFromTexture, which does a draw, and
CopyRectangleFromTexture, which where possible, does a bit-for-bit copy.

Source/Core/VideoBackends/D3D/DXTexture.cpp

@@ -165,29 +165,36 @@ void DXTexture::Unmap()
   D3D::context->Unmap(m_staging_texture, 0);
 }
 
-void DXTexture::CopyRectangleFromTexture(const AbstractTexture* source,
+void DXTexture::CopyRectangleFromTexture(const AbstractTexture* src,
-                                         const MathUtil::Rectangle<int>& srcrect,
+                                         const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                         const MathUtil::Rectangle<int>& dstrect)
+                                         u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                         u32 dst_layer, u32 dst_level)
+{
+  const DXTexture* srcentry = static_cast<const DXTexture*>(src);
+  _assert_(src_rect.GetWidth() == dst_rect.GetWidth() &&
+           src_rect.GetHeight() == dst_rect.GetHeight());
+
+  D3D11_BOX src_box;
+  src_box.left = src_rect.left;
+  src_box.top = src_rect.top;
+  src_box.right = src_rect.right;
+  src_box.bottom = src_rect.bottom;
+  src_box.front = 0;
+  src_box.back = 1;
+
+  D3D::context->CopySubresourceRegion(
+      m_texture->GetTex(), D3D11CalcSubresource(dst_level, dst_layer, m_config.levels),
+      dst_rect.left, dst_rect.top, 0, srcentry->m_texture->GetTex(),
+      D3D11CalcSubresource(src_level, src_layer, srcentry->m_config.levels), &src_box);
+}
+
+void DXTexture::ScaleRectangleFromTexture(const AbstractTexture* source,
+                                          const MathUtil::Rectangle<int>& srcrect,
+                                          const MathUtil::Rectangle<int>& dstrect)
 {
   const DXTexture* srcentry = static_cast<const DXTexture*>(source);
-  if (srcrect.GetWidth() == dstrect.GetWidth() && srcrect.GetHeight() == dstrect.GetHeight())
+  _assert_(m_config.rendertarget);
-  {
-    D3D11_BOX srcbox;
-    srcbox.left = srcrect.left;
-    srcbox.top = srcrect.top;
-    srcbox.right = srcrect.right;
-    srcbox.bottom = srcrect.bottom;
-    srcbox.front = 0;
-    srcbox.back = srcentry->m_config.layers;
 
-    D3D::context->CopySubresourceRegion(m_texture->GetTex(), 0, dstrect.left, dstrect.top, 0,
-                                        srcentry->m_texture->GetTex(), 0, &srcbox);
-    return;
-  }
-  else if (!m_config.rendertarget)
-  {
-    return;
-  }
   g_renderer->ResetAPIState();  // reset any game specific settings
 
   const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(float(dstrect.left), float(dstrect.top),

Source/Core/VideoBackends/D3D/DXTexture.h

@@ -22,9 +22,13 @@ public:
   void Bind(unsigned int stage) override;
   void Unmap() override;
 
-  void CopyRectangleFromTexture(const AbstractTexture* source,
+  void CopyRectangleFromTexture(const AbstractTexture* src,
-                                const MathUtil::Rectangle<int>& srcrect,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                const MathUtil::Rectangle<int>& dstrect) override;
+                                u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                u32 dst_layer, u32 dst_level) override;
+  void ScaleRectangleFromTexture(const AbstractTexture* source,
+                                 const MathUtil::Rectangle<int>& srcrect,
+                                 const MathUtil::Rectangle<int>& dstrect) override;
   void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
             size_t buffer_size) override;
 

Source/Core/VideoBackends/Null/NullTexture.cpp

@@ -14,9 +14,15 @@ void NullTexture::Bind(unsigned int stage)
 {
 }
 
-void NullTexture::CopyRectangleFromTexture(const AbstractTexture* source,
+void NullTexture::CopyRectangleFromTexture(const AbstractTexture* src,
-                                           const MathUtil::Rectangle<int>& srcrect,
+                                           const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                           const MathUtil::Rectangle<int>& dstrect)
+                                           u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                           u32 dst_layer, u32 dst_level)
+{
+}
+void NullTexture::ScaleRectangleFromTexture(const AbstractTexture* source,
+                                            const MathUtil::Rectangle<int>& srcrect,
+                                            const MathUtil::Rectangle<int>& dstrect)
 {
 }
 

Source/Core/VideoBackends/Null/NullTexture.h

@@ -21,9 +21,13 @@ public:
 
   void Bind(unsigned int stage) override;
 
-  void CopyRectangleFromTexture(const AbstractTexture* source,
+  void CopyRectangleFromTexture(const AbstractTexture* src,
-                                const MathUtil::Rectangle<int>& srcrect,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                const MathUtil::Rectangle<int>& dstrect) override;
+                                u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                u32 dst_layer, u32 dst_level) override;
+  void ScaleRectangleFromTexture(const AbstractTexture* source,
+                                 const MathUtil::Rectangle<int>& srcrect,
+                                 const MathUtil::Rectangle<int>& dstrect) override;
   void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
             size_t buffer_size) override;
 };

Source/Core/VideoBackends/OGL/OGLTexture.cpp

@@ -236,20 +236,70 @@ void OGLTexture::MapRegionSlow(u32 level, u32 x, u32 y, u32 width, u32 height)
   m_staging_data.swap(partial_data);
 }
 
-void OGLTexture::CopyRectangleFromTexture(const AbstractTexture* source,
+void OGLTexture::CopyRectangleFromTexture(const AbstractTexture* src,
-                                          const MathUtil::Rectangle<int>& srcrect,
+                                          const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                          const MathUtil::Rectangle<int>& dstrect)
+                                          u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                          u32 dst_layer, u32 dst_level)
+{
+  const OGLTexture* srcentry = static_cast<const OGLTexture*>(src);
+  _assert_(src_rect.GetWidth() == dst_rect.GetWidth() &&
+           src_rect.GetHeight() == dst_rect.GetHeight());
+  if (g_ogl_config.bSupportsCopySubImage)
+  {
+    glCopyImageSubData(srcentry->m_texId, GL_TEXTURE_2D_ARRAY, src_level, src_rect.left,
+                       src_rect.top, src_layer, m_texId, GL_TEXTURE_2D_ARRAY, dst_level,
+                       dst_rect.left, dst_rect.top, dst_layer, dst_rect.GetWidth(),
+                       dst_rect.GetHeight(), 1);
+  }
+  else
+  {
+    // If it isn't a single leveled/layered texture, we need to update the framebuffer.
+    bool update_src_framebuffer =
+        srcentry->m_framebuffer == 0 || srcentry->m_config.layers != 0 || src_level != 0;
+    bool update_dst_framebuffer = m_framebuffer == 0 || m_config.layers != 0 || dst_level != 0;
+    if (!m_framebuffer)
+      glGenFramebuffers(1, &m_framebuffer);
+    if (!srcentry->m_framebuffer)
+      glGenFramebuffers(1, &const_cast<OGLTexture*>(srcentry)->m_framebuffer);
+
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, srcentry->m_framebuffer);
+    if (update_src_framebuffer)
+    {
+      glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, srcentry->m_texId,
+                                src_level, src_layer);
+    }
+
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_framebuffer);
+    if (update_dst_framebuffer)
+    {
+      glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texId, dst_level,
+                                dst_layer);
+    }
+
+    glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom, dst_rect.left,
+                      dst_rect.top, dst_rect.right, dst_rect.bottom, GL_COLOR_BUFFER_BIT,
+                      GL_NEAREST);
+
+    if (update_src_framebuffer)
+    {
+      FramebufferManager::FramebufferTexture(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                             GL_TEXTURE_2D_ARRAY, srcentry->m_texId, 0);
+    }
+    if (update_dst_framebuffer)
+    {
+      FramebufferManager::FramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                             GL_TEXTURE_2D_ARRAY, m_texId, 0);
+    }
+
+    FramebufferManager::SetFramebuffer(0);
+  }
+}
+void OGLTexture::ScaleRectangleFromTexture(const AbstractTexture* source,
+                                           const MathUtil::Rectangle<int>& srcrect,
+                                           const MathUtil::Rectangle<int>& dstrect)
 {
   const OGLTexture* srcentry = static_cast<const OGLTexture*>(source);
-  if (srcrect.GetWidth() == dstrect.GetWidth() && srcrect.GetHeight() == dstrect.GetHeight() &&
+  if (!m_framebuffer)
-      g_ogl_config.bSupportsCopySubImage)
-  {
-    glCopyImageSubData(srcentry->m_texId, GL_TEXTURE_2D_ARRAY, 0, srcrect.left, srcrect.top, 0,
-                       m_texId, GL_TEXTURE_2D_ARRAY, 0, dstrect.left, dstrect.top, 0,
-                       dstrect.GetWidth(), dstrect.GetHeight(), srcentry->m_config.layers);
-    return;
-  }
-  else if (!m_framebuffer)
   {
     glGenFramebuffers(1, &m_framebuffer);
     FramebufferManager::SetFramebuffer(m_framebuffer);

Source/Core/VideoBackends/OGL/OGLTexture.h

@@ -21,9 +21,13 @@ public:
 
   void Bind(unsigned int stage) override;
 
-  void CopyRectangleFromTexture(const AbstractTexture* source,
+  void CopyRectangleFromTexture(const AbstractTexture* src,
-                                const MathUtil::Rectangle<int>& srcrect,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                const MathUtil::Rectangle<int>& dstrect) override;
+                                u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                u32 dst_layer, u32 dst_level) override;
+  void ScaleRectangleFromTexture(const AbstractTexture* source,
+                                 const MathUtil::Rectangle<int>& srcrect,
+                                 const MathUtil::Rectangle<int>& dstrect) override;
   void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
             size_t buffer_size) override;
 

Source/Core/VideoBackends/Software/SWTexture.cpp

@@ -56,9 +56,19 @@ void SWTexture::Bind(unsigned int stage)
 {
 }
 
-void SWTexture::CopyRectangleFromTexture(const AbstractTexture* source,
+void SWTexture::CopyRectangleFromTexture(const AbstractTexture* src,
-                                         const MathUtil::Rectangle<int>& srcrect,
+                                         const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                         const MathUtil::Rectangle<int>& dstrect)
+                                         u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                         u32 dst_layer, u32 dst_level)
+{
+  _assert_(src_level == 0 && src_layer == 0 && dst_layer == 0 && dst_level == 0);
+  CopyTextureData(src->GetConfig(), static_cast<const SWTexture*>(src)->m_data.data(),
+                  src_rect.left, src_rect.top, src_rect.GetWidth(), src_rect.GetHeight(), m_config,
+                  m_data.data(), dst_rect.left, dst_rect.top);
+}
+void SWTexture::ScaleRectangleFromTexture(const AbstractTexture* source,
+                                          const MathUtil::Rectangle<int>& srcrect,
+                                          const MathUtil::Rectangle<int>& dstrect)
 {
   const SWTexture* software_source_texture = static_cast<const SWTexture*>(source);
 

Source/Core/VideoBackends/Software/SWTexture.h

@@ -21,9 +21,13 @@ public:
 
   void Bind(unsigned int stage) override;
 
-  void CopyRectangleFromTexture(const AbstractTexture* source,
+  void CopyRectangleFromTexture(const AbstractTexture* src,
-                                const MathUtil::Rectangle<int>& srcrect,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                const MathUtil::Rectangle<int>& dstrect) override;
+                                u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                u32 dst_layer, u32 dst_level) override;
+  void ScaleRectangleFromTexture(const AbstractTexture* source,
+                                 const MathUtil::Rectangle<int>& srcrect,
+                                 const MathUtil::Rectangle<int>& dstrect) override;
   void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
             size_t buffer_size) override;
 

Source/Core/VideoBackends/Vulkan/VKTexture.cpp

@@ -163,10 +163,13 @@ void VKTexture::Unmap()
   m_staging_texture->Unmap();
 }
 
-void VKTexture::CopyTextureRectangle(const MathUtil::Rectangle<int>& dst_rect,
+void VKTexture::CopyRectangleFromTexture(const AbstractTexture* src,
-                                     Texture2D* src_texture,
+                                         const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                     const MathUtil::Rectangle<int>& src_rect)
+                                         u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                         u32 dst_layer, u32 dst_level)
 {
+  Texture2D* src_texture = static_cast<const VKTexture*>(src)->GetRawTexIdentifier();
+
   _assert_msg_(VIDEO, static_cast<u32>(src_rect.GetWidth()) <= src_texture->GetWidth() &&
                           static_cast<u32>(src_rect.GetHeight()) <= src_texture->GetHeight(),
                "Source rect is too large for CopyRectangleFromTexture");
@@ -176,15 +179,11 @@ void VKTexture::CopyTextureRectangle(const MathUtil::Rectangle<int>& dst_rect,
                "Dest rect is too large for CopyRectangleFromTexture");
 
   VkImageCopy image_copy = {
-      {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0,
+      {VK_IMAGE_ASPECT_COLOR_BIT, src_level, src_layer, src_texture->GetLayers()},
-       src_texture->GetLayers()},        // VkImageSubresourceLayers    srcSubresource
+      {src_rect.left, src_rect.top, 0},
-      {src_rect.left, src_rect.top, 0},  // VkOffset3D                  srcOffset
+      {VK_IMAGE_ASPECT_COLOR_BIT, dst_level, dst_layer, m_config.layers},
-      {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0,  // VkImageSubresourceLayers    dstSubresource
+      {dst_rect.left, dst_rect.top, 0},
-       m_config.layers},
+      {static_cast<uint32_t>(src_rect.GetWidth()), static_cast<uint32_t>(src_rect.GetHeight()), 1}};
-      {dst_rect.left, dst_rect.top, 0},  // VkOffset3D                  dstOffset
-      {static_cast<uint32_t>(src_rect.GetWidth()), static_cast<uint32_t>(src_rect.GetHeight()),
-       1}  // VkExtent3D                  extent
-  };
 
   // Must be called outside of a render pass.
   StateTracker::GetInstance()->EndRenderPass();
@@ -197,12 +196,20 @@ void VKTexture::CopyTextureRectangle(const MathUtil::Rectangle<int>& dst_rect,
   vkCmdCopyImage(g_command_buffer_mgr->GetCurrentCommandBuffer(), src_texture->GetImage(),
                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_texture->GetImage(),
                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &image_copy);
+
+  // Ensure both textures remain in the SHADER_READ_ONLY layout so they can be bound.
+  src_texture->TransitionToLayout(g_command_buffer_mgr->GetCurrentCommandBuffer(),
+                                  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+  m_texture->TransitionToLayout(g_command_buffer_mgr->GetCurrentCommandBuffer(),
+                                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 }
 
-void VKTexture::ScaleTextureRectangle(const MathUtil::Rectangle<int>& dst_rect,
+void VKTexture::ScaleRectangleFromTexture(const AbstractTexture* source,
-                                      Texture2D* src_texture,
+                                          const MathUtil::Rectangle<int>& src_rect,
-                                      const MathUtil::Rectangle<int>& src_rect)
+                                          const MathUtil::Rectangle<int>& dst_rect)
 {
+  Texture2D* src_texture = static_cast<const VKTexture*>(source)->GetRawTexIdentifier();
+
   // Can't do this within a game render pass.
   StateTracker::GetInstance()->EndRenderPass();
   StateTracker::GetInstance()->SetPendingRebind();
@@ -235,27 +242,10 @@ void VKTexture::ScaleTextureRectangle(const MathUtil::Rectangle<int>& dst_rect,
                 static_cast<int>(src_texture->GetWidth()),
                 static_cast<int>(src_texture->GetHeight()));
   draw.EndRenderPass();
-}
-
-void VKTexture::CopyRectangleFromTexture(const AbstractTexture* source,
-                                         const MathUtil::Rectangle<int>& srcrect,
-                                         const MathUtil::Rectangle<int>& dstrect)
-{
-  auto* raw_source_texture = static_cast<const VKTexture*>(source)->GetRawTexIdentifier();
-  CopyRectangleFromTexture(raw_source_texture, srcrect, dstrect);
-}
-
-void VKTexture::CopyRectangleFromTexture(Texture2D* source, const MathUtil::Rectangle<int>& srcrect,
-                                         const MathUtil::Rectangle<int>& dstrect)
-{
-  if (srcrect.GetWidth() == dstrect.GetWidth() && srcrect.GetHeight() == dstrect.GetHeight())
-    CopyTextureRectangle(dstrect, source, srcrect);
-  else
-    ScaleTextureRectangle(dstrect, source, srcrect);
 
   // Ensure both textures remain in the SHADER_READ_ONLY layout so they can be bound.
-  source->TransitionToLayout(g_command_buffer_mgr->GetCurrentCommandBuffer(),
+  src_texture->TransitionToLayout(g_command_buffer_mgr->GetCurrentCommandBuffer(),
-                             VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+                                  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
   m_texture->TransitionToLayout(g_command_buffer_mgr->GetCurrentCommandBuffer(),
                                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 }

Source/Core/VideoBackends/Vulkan/VKTexture.h

@@ -24,11 +24,15 @@ public:
   void Bind(unsigned int stage) override;
   void Unmap() override;
 
-  void CopyRectangleFromTexture(const AbstractTexture* source,
+  void CopyRectangleFromTexture(const AbstractTexture* src,
-                                const MathUtil::Rectangle<int>& srcrect,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                const MathUtil::Rectangle<int>& dstrect) override;
+                                u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
-  void CopyRectangleFromTexture(Texture2D* source, const MathUtil::Rectangle<int>& srcrect,
+                                u32 dst_layer, u32 dst_level) override;
-                                const MathUtil::Rectangle<int>& dstrect);
+  void ScaleRectangleFromTexture(const AbstractTexture* source,
+                                 const MathUtil::Rectangle<int>& src_rect,
+                                 const MathUtil::Rectangle<int>& dst_rect);
+  void ScaleRectangleFromTexture(Texture2D* src_texture, const MathUtil::Rectangle<int>& src_rect,
+                                 const MathUtil::Rectangle<int>& dst_rect);
   void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
             size_t buffer_size) override;
 
@@ -41,14 +45,6 @@ private:
   VKTexture(const TextureConfig& tex_config, std::unique_ptr<Texture2D> texture,
             VkFramebuffer framebuffer);
 
-  // Copies the contents of a texture using vkCmdCopyImage
-  void CopyTextureRectangle(const MathUtil::Rectangle<int>& dst_rect, Texture2D* src_texture,
-                            const MathUtil::Rectangle<int>& src_rect);
-
-  // Copies (and optionally scales) the contents of a texture using a framgent shader.
-  void ScaleTextureRectangle(const MathUtil::Rectangle<int>& dst_rect, Texture2D* src_texture,
-                             const MathUtil::Rectangle<int>& src_rect);
-
   std::optional<RawTextureInfo> MapFullImpl() override;
   std::optional<RawTextureInfo> MapRegionImpl(u32 level, u32 x, u32 y, u32 width,
                                               u32 height) override;

Source/Core/VideoCommon/AbstractTexture.h

@@ -33,9 +33,13 @@ public:
   std::optional<RawTextureInfo> Map(u32 level);
   virtual void Unmap();
 
-  virtual void CopyRectangleFromTexture(const AbstractTexture* source,
+  virtual void CopyRectangleFromTexture(const AbstractTexture* src,
-                                        const MathUtil::Rectangle<int>& srcrect,
+                                        const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
-                                        const MathUtil::Rectangle<int>& dstrect) = 0;
+                                        u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                        u32 dst_layer, u32 dst_level) = 0;
+  virtual void ScaleRectangleFromTexture(const AbstractTexture* source,
+                                         const MathUtil::Rectangle<int>& srcrect,
+                                         const MathUtil::Rectangle<int>& dstrect) = 0;
   virtual void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
                     size_t buffer_size) = 0;
 

Source/Core/VideoCommon/RenderBase.cpp

@@ -733,8 +733,8 @@ void Renderer::UpdateFrameDumpTexture()
     config.rendertarget = true;
     m_dump_texture = CreateTexture(config);
   }
-  m_dump_texture->CopyRectangleFromTexture(m_last_xfb_texture, m_last_xfb_region,
+  m_dump_texture->CopyRectangleFromTexture(m_last_xfb_texture, m_last_xfb_region, 0, 0,
-                                           EFBRectangle{0, 0, target_width, target_height});
+                                           EFBRectangle{0, 0, target_width, target_height}, 0, 0);
 }
 
 void Renderer::ShutdownFrameDumping()

Source/Core/VideoCommon/TextureCacheBase.cpp

@@ -277,9 +277,9 @@ void TextureCacheBase::ScaleTextureCacheEntryTo(TextureCacheBase::TCacheEntry* e
   std::unique_ptr<AbstractTexture> new_texture = AllocateTexture(newconfig);
   if (new_texture)
   {
-    new_texture->CopyRectangleFromTexture(entry->texture.get(),
+    new_texture->ScaleRectangleFromTexture(entry->texture.get(),
-                                          entry->texture->GetConfig().GetRect(),
+                                           entry->texture->GetConfig().GetRect(),
-                                          new_texture->GetConfig().GetRect());
+                                           new_texture->GetConfig().GetRect());
     entry->texture.swap(new_texture);
 
     auto config = new_texture->GetConfig();
@@ -406,7 +406,8 @@ TextureCacheBase::DoPartialTextureUpdates(TCacheEntry* entry_to_update, u8* pale
         dstrect.top = dst_y;
         dstrect.right = (dst_x + copy_width);
         dstrect.bottom = (dst_y + copy_height);
-        entry_to_update->texture->CopyRectangleFromTexture(entry->texture.get(), srcrect, dstrect);
+        entry_to_update->texture->CopyRectangleFromTexture(entry->texture.get(), srcrect, 0, 0,
+                                                           dstrect, 0, 0);
 
         if (isPaletteTexture)
         {
@@ -1391,7 +1392,8 @@ bool TextureCacheBase::LoadTextureFromOverlappingTextures(TCacheEntry* entry_to_
           dstrect.bottom -= 1;
         }
 
-        entry_to_update->texture->CopyRectangleFromTexture(entry->texture.get(), srcrect, dstrect);
+        entry_to_update->texture->CopyRectangleFromTexture(entry->texture.get(), srcrect, 0, 0,
+                                                           dstrect, 0, 0);
 
         updated_entry = true;