VideoBackends: Add AbstractStagingTexture class

Can be used for asynchronous readback or upload of textures.

Source/Core/VideoBackends/Software/SWRenderer.cpp

@@ -40,6 +40,12 @@ std::unique_ptr<AbstractTexture> SWRenderer::CreateTexture(const TextureConfig&
   return std::make_unique<SW::SWTexture>(config);
 }
 
+std::unique_ptr<AbstractStagingTexture>
+SWRenderer::CreateStagingTexture(StagingTextureType type, const TextureConfig& config)
+{
+  return std::make_unique<SW::SWStagingTexture>(type, config);
+}
+
 void SWRenderer::RenderText(const std::string& pstr, int left, int top, u32 color)
 {
   SWOGLWindow::s_instance->PrintText(pstr, left, top, color);

Source/Core/VideoBackends/Software/SWRenderer.h

@@ -17,6 +17,8 @@ public:
   static void Shutdown();
 
   std::unique_ptr<AbstractTexture> CreateTexture(const TextureConfig& config) override;
+  std::unique_ptr<AbstractStagingTexture>
+  CreateStagingTexture(StagingTextureType type, const TextureConfig& config) override;
 
   void RenderText(const std::string& pstr, int left, int top, u32 color) override;
   u32 AccessEFB(EFBAccessType type, u32 x, u32 y, u32 poke_data) override;

Source/Core/VideoBackends/Software/SWTexture.cpp

@@ -5,6 +5,7 @@
 #include "VideoBackends/Software/SWTexture.h"
 
 #include <cstring>
+#include "Common/Assert.h"
 
 #include "VideoBackends/Software/CopyRegion.h"
 
@@ -21,7 +22,31 @@ struct Pixel
   u8 a;
 };
 #pragma pack(pop)
+
+void CopyTextureData(const TextureConfig& src_config, const u8* src_ptr, u32 src_x, u32 src_y,
+                     u32 width, u32 height, const TextureConfig& dst_config, u8* dst_ptr, u32 dst_x,
+                     u32 dst_y)
+{
+  size_t texel_size = AbstractTexture::GetTexelSizeForFormat(src_config.format);
+  size_t src_stride = src_config.GetStride();
+  size_t src_offset =
+      static_cast<size_t>(src_y) * src_stride + static_cast<size_t>(src_x) * texel_size;
+  size_t dst_stride = dst_config.GetStride();
+  size_t dst_offset =
+      static_cast<size_t>(dst_y) * dst_stride + static_cast<size_t>(dst_x) * texel_size;
+  size_t copy_len = static_cast<size_t>(width) * texel_size;
+
+  src_ptr += src_offset;
+  dst_ptr += dst_offset;
+  for (u32 i = 0; i < height; i++)
+  {
+    std::memcpy(dst_ptr, src_ptr, copy_len);
+    src_ptr += src_stride;
+    dst_ptr += dst_stride;
+  }
 }
+}
+
 SWTexture::SWTexture(const TextureConfig& tex_config) : AbstractTexture(tex_config)
 {
   m_data.resize(tex_config.width * tex_config.height * 4);
@@ -78,4 +103,49 @@ std::optional<AbstractTexture::RawTextureInfo> SWTexture::MapFullImpl()
                                          m_config.height};
 }
 
+SWStagingTexture::SWStagingTexture(StagingTextureType type, const TextureConfig& config)
+    : AbstractStagingTexture(type, config)
+{
+  m_data.resize(m_texel_size * config.width * config.height);
+  m_map_pointer = reinterpret_cast<char*>(m_data.data());
+  m_map_stride = m_texel_size * config.width;
+}
+
+SWStagingTexture::~SWStagingTexture() = default;
+
+void SWStagingTexture::CopyFromTexture(const AbstractTexture* src,
+                                       const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                       u32 src_level, const MathUtil::Rectangle<int>& dst_rect)
+{
+  _assert_(src_level == 0 && src_layer == 0);
+  CopyTextureData(src->GetConfig(), static_cast<const SWTexture*>(src)->GetData(), src_rect.left,
+                  src_rect.top, src_rect.GetWidth(), src_rect.GetHeight(), m_config, m_data.data(),
+                  dst_rect.left, dst_rect.top);
+  m_needs_flush = true;
+}
+
+void SWStagingTexture::CopyToTexture(const MathUtil::Rectangle<int>& src_rect, AbstractTexture* dst,
+                                     const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer,
+                                     u32 dst_level)
+{
+  _assert_(dst_level == 0 && dst_layer == 0);
+  CopyTextureData(m_config, m_data.data(), src_rect.left, src_rect.top, src_rect.GetWidth(),
+                  src_rect.GetHeight(), dst->GetConfig(), static_cast<SWTexture*>(dst)->GetData(),
+                  dst_rect.left, dst_rect.top);
+  m_needs_flush = true;
+}
+
+bool SWStagingTexture::Map()
+{
+  return true;
+}
+
+void SWStagingTexture::Unmap()
+{
+}
+
+void SWStagingTexture::Flush()
+{
+  m_needs_flush = false;
+}
 }  // namespace SW

Source/Core/VideoBackends/Software/SWTexture.h

@@ -8,6 +8,7 @@
 
 #include "Common/CommonTypes.h"
 
+#include "VideoCommon/AbstractStagingTexture.h"
 #include "VideoCommon/AbstractTexture.h"
 
 namespace SW
@@ -35,4 +36,25 @@ private:
   std::vector<u8> m_data;
 };
 
+class SWStagingTexture final : public AbstractStagingTexture
+{
+public:
+  explicit SWStagingTexture(StagingTextureType type, const TextureConfig& config);
+  ~SWStagingTexture();
+
+  void CopyFromTexture(const AbstractTexture* src, const MathUtil::Rectangle<int>& src_rect,
+                       u32 src_layer, u32 src_level,
+                       const MathUtil::Rectangle<int>& dst_rect) override;
+  void CopyToTexture(const MathUtil::Rectangle<int>& src_rect, AbstractTexture* dst,
+                     const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer,
+                     u32 dst_level) override;
+
+  bool Map() override;
+  void Unmap() override;
+  void Flush() override;
+
+private:
+  std::vector<u8> m_data;
+};
+
 }  // namespace SW