Merge pull request #6193 from stenzek/readbacks

Abstract Staging Textures - VideoCommon interface for texture readbacks/uploads

Source/Core/Common/GL/GLExtensions/GLExtensions.cpp

@@ -1870,6 +1870,9 @@ const GLFunc gl_function_array[] = {
     GLFUNC_REQUIRES(glDispatchCompute, "GL_ARB_compute_shader !VERSION_4_3 |VERSION_GLES_3_1"),
     GLFUNC_REQUIRES(glDispatchComputeIndirect,
                     "GL_ARB_compute_shader !VERSION_4_3 |VERSION_GLES_3_1"),
+
+    // ARB_get_texture_sub_image
+    GLFUNC_REQUIRES(glGetTextureSubImage, "GL_ARB_get_texture_sub_image !VERSION_4_5"),
 };
 
 namespace GLExtensions

Source/Core/VideoBackends/D3D/D3DBase.cpp

@@ -52,8 +52,6 @@ const D3D_FEATURE_LEVEL supported_feature_levels[NUM_SUPPORTED_FEATURE_LEVELS] =
 
 unsigned int xres, yres;
 
-bool bFrameInProgress = false;
-
 HRESULT LoadDXGI()
 {
   if (dxgi_dll_ref++ > 0)
@@ -602,27 +600,6 @@ void Reset()
   SetDebugObjectName(backbuf->GetRTV(), "backbuffer render target view");
 }
 
-bool BeginFrame()
-{
-  if (bFrameInProgress)
-  {
-    PanicAlert("BeginFrame called although a frame is already in progress");
-    return false;
-  }
-  bFrameInProgress = true;
-  return (device != nullptr);
-}
-
-void EndFrame()
-{
-  if (!bFrameInProgress)
-  {
-    PanicAlert("EndFrame called although no frame is in progress");
-    return;
-  }
-  bFrameInProgress = false;
-}
-
 void Present()
 {
   UINT present_flags = 0;

Source/Core/VideoBackends/D3D/D3DBase.h

@@ -63,8 +63,6 @@ extern HWND hWnd;
 extern bool bFrameInProgress;
 
 void Reset();
-bool BeginFrame();
-void EndFrame();
 void Present();
 
 unsigned int GetBackBufferWidth();

Source/Core/VideoBackends/D3D/D3DState.cpp

@@ -263,6 +263,21 @@ void StateManager::SetTextureByMask(u32 textureSlotMask, ID3D11ShaderResourceVie
 
 }  // namespace D3D
 
+StateCache::~StateCache()
+{
+  for (auto& it : m_depth)
+    SAFE_RELEASE(it.second);
+
+  for (auto& it : m_raster)
+    SAFE_RELEASE(it.second);
+
+  for (auto& it : m_blend)
+    SAFE_RELEASE(it.second);
+
+  for (auto& it : m_sampler)
+    SAFE_RELEASE(it.second);
+}
+
 ID3D11SamplerState* StateCache::Get(SamplerState state)
 {
   auto it = m_sampler.find(state.hex);
@@ -471,33 +486,6 @@ ID3D11DepthStencilState* StateCache::Get(DepthState state)
   return res;
 }
 
-void StateCache::Clear()
-{
-  for (auto it : m_depth)
-  {
-    SAFE_RELEASE(it.second);
-  }
-  m_depth.clear();
-
-  for (auto it : m_raster)
-  {
-    SAFE_RELEASE(it.second);
-  }
-  m_raster.clear();
-
-  for (auto it : m_blend)
-  {
-    SAFE_RELEASE(it.second);
-  }
-  m_blend.clear();
-
-  for (auto it : m_sampler)
-  {
-    SAFE_RELEASE(it.second);
-  }
-  m_sampler.clear();
-}
-
 D3D11_PRIMITIVE_TOPOLOGY StateCache::GetPrimitiveTopology(PrimitiveType primitive)
 {
   static constexpr std::array<D3D11_PRIMITIVE_TOPOLOGY, 4> primitives = {

Source/Core/VideoBackends/D3D/D3DState.h

@@ -23,6 +23,8 @@ namespace DX11
 class StateCache
 {
 public:
+  ~StateCache();
+
   // Get existing or create new render state.
   // Returned objects is owned by the cache and does not need to be released.
   ID3D11SamplerState* Get(SamplerState state);
@@ -30,9 +32,6 @@ public:
   ID3D11RasterizerState* Get(RasterizationState state);
   ID3D11DepthStencilState* Get(DepthState state);
 
-  // Release all cached states and clear hash tables.
-  void Clear();
-
   // Convert RasterState primitive type to D3D11 primitive topology.
   static D3D11_PRIMITIVE_TOPOLOGY GetPrimitiveTopology(PrimitiveType primitive);
 

Source/Core/VideoBackends/D3D/DXTexture.cpp

@@ -40,7 +40,11 @@ DXGI_FORMAT GetDXGIFormatForHostFormat(AbstractTextureFormat format)
   case AbstractTextureFormat::BPTC:
     return DXGI_FORMAT_BC7_UNORM;
   case AbstractTextureFormat::RGBA8:
+    return DXGI_FORMAT_R8G8B8A8_UNORM;
+  case AbstractTextureFormat::BGRA8:
+    return DXGI_FORMAT_B8G8R8A8_UNORM;
   default:
+    PanicAlert("Unhandled texture format.");
     return DXGI_FORMAT_R8G8B8A8_UNORM;
   }
 }
@@ -80,7 +84,6 @@ DXTexture::DXTexture(const TextureConfig& tex_config) : AbstractTexture(tex_conf
 DXTexture::~DXTexture()
 {
   m_texture->Release();
-  SAFE_RELEASE(m_staging_texture);
 }
 
 D3DTexture2D* DXTexture::GetRawTexIdentifier() const
@@ -93,97 +96,36 @@ void DXTexture::Bind(unsigned int stage)
   D3D::stateman->SetTexture(stage, m_texture->GetSRV());
 }
 
-std::optional<AbstractTexture::RawTextureInfo> DXTexture::MapFullImpl()
+void DXTexture::CopyRectangleFromTexture(const AbstractTexture* src,
+                                         const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                         u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                         u32 dst_layer, u32 dst_level)
 {
-  CD3D11_TEXTURE2D_DESC staging_texture_desc(DXGI_FORMAT_R8G8B8A8_UNORM, m_config.width,
-                                             m_config.height, 1, 1, 0, D3D11_USAGE_STAGING,
-                                             D3D11_CPU_ACCESS_READ);
+  const DXTexture* srcentry = static_cast<const DXTexture*>(src);
+  _assert_(src_rect.GetWidth() == dst_rect.GetWidth() &&
+           src_rect.GetHeight() == dst_rect.GetHeight());
 
-  HRESULT hr = D3D::device->CreateTexture2D(&staging_texture_desc, nullptr, &m_staging_texture);
-  if (FAILED(hr))
-  {
-    WARN_LOG(VIDEO, "Failed to create texture dumping readback texture: %X", static_cast<u32>(hr));
-    return {};
-  }
+  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;
 
-  // Copy the selected data to the staging texture
-  D3D::context->CopyResource(m_staging_texture, m_texture->GetTex());
-
-  // Map the staging texture to client memory, and encode it as a .png image.
-  D3D11_MAPPED_SUBRESOURCE map;
-  hr = D3D::context->Map(m_staging_texture, 0, D3D11_MAP_READ, 0, &map);
-  if (FAILED(hr))
-  {
-    WARN_LOG(VIDEO, "Failed to map texture dumping readback texture: %X", static_cast<u32>(hr));
-    return {};
-  }
-
-  return AbstractTexture::RawTextureInfo{reinterpret_cast<u8*>(map.pData), map.RowPitch,
-                                         m_config.width, m_config.height};
+  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);
 }
 
-std::optional<AbstractTexture::RawTextureInfo> DXTexture::MapRegionImpl(u32 level, u32 x, u32 y,
-                                                                        u32 width, u32 height)
-{
-  CD3D11_TEXTURE2D_DESC staging_texture_desc(DXGI_FORMAT_R8G8B8A8_UNORM, width, height, 1, 1, 0,
-                                             D3D11_USAGE_STAGING, D3D11_CPU_ACCESS_READ);
-
-  HRESULT hr = D3D::device->CreateTexture2D(&staging_texture_desc, nullptr, &m_staging_texture);
-  if (FAILED(hr))
-  {
-    WARN_LOG(VIDEO, "Failed to create texture dumping readback texture: %X", static_cast<u32>(hr));
-    return {};
-  }
-
-  // Copy the selected data to the staging texture
-  CD3D11_BOX src_box(x, y, 0, width, height, 1);
-  D3D::context->CopySubresourceRegion(m_staging_texture, 0, 0, 0, 0, m_texture->GetTex(),
-                                      D3D11CalcSubresource(level, 0, m_config.levels), &src_box);
-
-  // Map the staging texture to client memory, and encode it as a .png image.
-  D3D11_MAPPED_SUBRESOURCE map;
-  hr = D3D::context->Map(m_staging_texture, 0, D3D11_MAP_READ, 0, &map);
-  if (FAILED(hr))
-  {
-    WARN_LOG(VIDEO, "Failed to map texture dumping readback texture: %X", static_cast<u32>(hr));
-    return {};
-  }
-
-  return AbstractTexture::RawTextureInfo{reinterpret_cast<u8*>(map.pData), map.RowPitch,
-                                         m_config.width, m_config.height};
-}
-
-void DXTexture::Unmap()
-{
-  if (!m_staging_texture)
-    return;
-
-  D3D::context->Unmap(m_staging_texture, 0);
-}
-
-void DXTexture::CopyRectangleFromTexture(const AbstractTexture* source,
-                                         const MathUtil::Rectangle<int>& srcrect,
-                                         const MathUtil::Rectangle<int>& dstrect)
+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())
-  {
-    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;
+  _assert_(m_config.rendertarget);
 
-    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),
@@ -213,8 +155,140 @@ void DXTexture::CopyRectangleFromTexture(const AbstractTexture* source,
 void DXTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
                      size_t buffer_size)
 {
-  size_t src_pitch = CalculateHostTextureLevelPitch(m_config.format, row_length);
+  size_t src_pitch = CalculateStrideForFormat(m_config.format, row_length);
   D3D::context->UpdateSubresource(m_texture->GetTex(), level, nullptr, buffer,
                                   static_cast<UINT>(src_pitch), 0);
 }
+
+DXStagingTexture::DXStagingTexture(StagingTextureType type, const TextureConfig& config,
+                                   ID3D11Texture2D* tex)
+    : AbstractStagingTexture(type, config), m_tex(tex)
+{
+}
+
+DXStagingTexture::~DXStagingTexture()
+{
+  if (IsMapped())
+    DXStagingTexture::Unmap();
+  SAFE_RELEASE(m_tex);
+}
+
+std::unique_ptr<DXStagingTexture> DXStagingTexture::Create(StagingTextureType type,
+                                                           const TextureConfig& config)
+{
+  D3D11_USAGE usage;
+  UINT cpu_flags;
+  if (type == StagingTextureType::Readback)
+  {
+    usage = D3D11_USAGE_STAGING;
+    cpu_flags = D3D11_CPU_ACCESS_READ;
+  }
+  else if (type == StagingTextureType::Upload)
+  {
+    usage = D3D11_USAGE_DYNAMIC;
+    cpu_flags = D3D11_CPU_ACCESS_WRITE;
+  }
+  else
+  {
+    usage = D3D11_USAGE_STAGING;
+    cpu_flags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
+  }
+
+  CD3D11_TEXTURE2D_DESC desc(GetDXGIFormatForHostFormat(config.format), config.width, config.height,
+                             1, 1, 0, usage, cpu_flags);
+
+  ID3D11Texture2D* texture;
+  HRESULT hr = D3D::device->CreateTexture2D(&desc, nullptr, &texture);
+  CHECK(SUCCEEDED(hr), "Create staging texture");
+  if (FAILED(hr))
+    return nullptr;
+
+  return std::unique_ptr<DXStagingTexture>(new DXStagingTexture(type, config, texture));
+}
+
+void DXStagingTexture::CopyFromTexture(const AbstractTexture* src,
+                                       const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                       u32 src_level, const MathUtil::Rectangle<int>& dst_rect)
+{
+  _assert_(m_type == StagingTextureType::Readback);
+  _assert_(src_rect.GetWidth() == dst_rect.GetWidth() &&
+           src_rect.GetHeight() == dst_rect.GetHeight());
+  _assert_(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= src->GetConfig().width &&
+           src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= src->GetConfig().height);
+  _assert_(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= m_config.width &&
+           dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= m_config.height);
+
+  if (IsMapped())
+    DXStagingTexture::Unmap();
+
+  CD3D11_BOX src_box(src_rect.left, src_rect.top, 0, src_rect.right, src_rect.bottom, 1);
+  D3D::context->CopySubresourceRegion(
+      m_tex, 0, static_cast<u32>(dst_rect.left), static_cast<u32>(dst_rect.top), 0,
+      static_cast<const DXTexture*>(src)->GetRawTexIdentifier()->GetTex(),
+      D3D11CalcSubresource(src_level, src_layer, src->GetConfig().levels), &src_box);
+
+  m_needs_flush = true;
+}
+
+void DXStagingTexture::CopyToTexture(const MathUtil::Rectangle<int>& src_rect, AbstractTexture* dst,
+                                     const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer,
+                                     u32 dst_level)
+{
+  _assert_(m_type == StagingTextureType::Upload);
+  _assert_(src_rect.GetWidth() == dst_rect.GetWidth() &&
+           src_rect.GetHeight() == dst_rect.GetHeight());
+  _assert_(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= m_config.width &&
+           src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= m_config.height);
+  _assert_(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= dst->GetConfig().width &&
+           dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= dst->GetConfig().height);
+
+  if (IsMapped())
+    DXStagingTexture::Unmap();
+
+  CD3D11_BOX src_box(src_rect.left, src_rect.top, 0, src_rect.right, src_rect.bottom, 1);
+  D3D::context->CopySubresourceRegion(
+      static_cast<const DXTexture*>(dst)->GetRawTexIdentifier()->GetTex(),
+      D3D11CalcSubresource(dst_level, dst_layer, dst->GetConfig().levels),
+      static_cast<u32>(dst_rect.left), static_cast<u32>(dst_rect.top), 0, m_tex, 0, &src_box);
+}
+
+bool DXStagingTexture::Map()
+{
+  if (m_map_pointer)
+    return true;
+
+  D3D11_MAP map_type;
+  if (m_type == StagingTextureType::Readback)
+    map_type = D3D11_MAP_READ;
+  else if (m_type == StagingTextureType::Upload)
+    map_type = D3D11_MAP_WRITE;
+  else
+    map_type = D3D11_MAP_READ_WRITE;
+
+  D3D11_MAPPED_SUBRESOURCE sr;
+  HRESULT hr = D3D::context->Map(m_tex, 0, map_type, 0, &sr);
+  CHECK(SUCCEEDED(hr), "Map readback texture");
+  if (FAILED(hr))
+    return false;
+
+  m_map_pointer = reinterpret_cast<char*>(sr.pData);
+  m_map_stride = sr.RowPitch;
+  return true;
+}
+
+void DXStagingTexture::Unmap()
+{
+  if (!m_map_pointer)
+    return;
+
+  D3D::context->Unmap(m_tex, 0);
+  m_map_pointer = nullptr;
+}
+
+void DXStagingTexture::Flush()
+{
+  // Flushing is handled by the API.
+  m_needs_flush = false;
+}
+
 }  // namespace DX11

Source/Core/VideoBackends/D3D/DXTexture.h

@@ -6,6 +6,7 @@
 
 #include "Common/CommonTypes.h"
 
+#include "VideoCommon/AbstractStagingTexture.h"
 #include "VideoCommon/AbstractTexture.h"
 
 class D3DTexture2D;
@@ -19,23 +20,47 @@ public:
   ~DXTexture();
 
   void Bind(unsigned int stage) override;
-  void Unmap() override;
 
-  void CopyRectangleFromTexture(const AbstractTexture* source,
-                                const MathUtil::Rectangle<int>& srcrect,
-                                const MathUtil::Rectangle<int>& dstrect) override;
+  void CopyRectangleFromTexture(const AbstractTexture* src,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                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;
 
   D3DTexture2D* GetRawTexIdentifier() const;
 
 private:
-  std::optional<RawTextureInfo> MapFullImpl() override;
-  std::optional<RawTextureInfo> MapRegionImpl(u32 level, u32 x, u32 y, u32 width,
-                                              u32 height) override;
-
   D3DTexture2D* m_texture;
-  ID3D11Texture2D* m_staging_texture = nullptr;
+};
+
+class DXStagingTexture final : public AbstractStagingTexture
+{
+public:
+  DXStagingTexture() = delete;
+  ~DXStagingTexture();
+
+  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;
+
+  static std::unique_ptr<DXStagingTexture> Create(StagingTextureType type,
+                                                  const TextureConfig& config);
+
+private:
+  DXStagingTexture(StagingTextureType type, const TextureConfig& config, ID3D11Texture2D* tex);
+
+  ID3D11Texture2D* m_tex = nullptr;
 };
 
 }  // namespace DX11

Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp

@@ -4,17 +4,21 @@
 
 #include "VideoBackends/D3D/PSTextureEncoder.h"
 
+#include "Common/Assert.h"
 #include "Common/Logging/Log.h"
 #include "Core/HW/Memmap.h"
 #include "VideoBackends/D3D/D3DBase.h"
 #include "VideoBackends/D3D/D3DShader.h"
 #include "VideoBackends/D3D/D3DState.h"
 #include "VideoBackends/D3D/D3DUtil.h"
+#include "VideoBackends/D3D/DXTexture.h"
 #include "VideoBackends/D3D/FramebufferManager.h"
 #include "VideoBackends/D3D/Render.h"
 #include "VideoBackends/D3D/TextureCache.h"
 #include "VideoBackends/D3D/VertexShaderCache.h"
 
+#include "VideoCommon/AbstractStagingTexture.h"
+#include "VideoCommon/AbstractTexture.h"
 #include "VideoCommon/TextureConversionShader.h"
 #include "VideoCommon/VideoCommon.h"
 
@@ -31,76 +35,41 @@ struct EFBEncodeParams
 };
 
 PSTextureEncoder::PSTextureEncoder()
-    : m_ready(false), m_out(nullptr), m_outRTV(nullptr), m_outStage(nullptr),
-      m_encodeParams(nullptr)
 {
 }
 
+PSTextureEncoder::~PSTextureEncoder() = default;
+
 void PSTextureEncoder::Init()
 {
-  m_ready = false;
-
-  HRESULT hr;
-
-  // Create output texture RGBA format
-  // TODO: This Texture is overly large and parts of it are unused
-  //       EFB2RAM copies use max (EFB_WIDTH * 4) by (EFB_HEIGHT / 4)
-  //       XFB2RAM copies use max (EFB_WIDTH / 2) by (EFB_HEIGHT)
-  D3D11_TEXTURE2D_DESC t2dd = CD3D11_TEXTURE2D_DESC(DXGI_FORMAT_B8G8R8A8_UNORM, EFB_WIDTH * 4, 1024,
-                                                    1, 1, D3D11_BIND_RENDER_TARGET);
-  hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_out);
-  CHECK(SUCCEEDED(hr), "create efb encode output texture");
-  D3D::SetDebugObjectName(m_out, "efb encoder output texture");
-
-  // Create output render target view
-  D3D11_RENDER_TARGET_VIEW_DESC rtvd = CD3D11_RENDER_TARGET_VIEW_DESC(
-      m_out, D3D11_RTV_DIMENSION_TEXTURE2D, DXGI_FORMAT_B8G8R8A8_UNORM);
-  hr = D3D::device->CreateRenderTargetView(m_out, &rtvd, &m_outRTV);
-  CHECK(SUCCEEDED(hr), "create efb encode output render target view");
-  D3D::SetDebugObjectName(m_outRTV, "efb encoder output rtv");
-
-  // Create output staging buffer
-  t2dd.Usage = D3D11_USAGE_STAGING;
-  t2dd.BindFlags = 0;
-  t2dd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-  hr = D3D::device->CreateTexture2D(&t2dd, nullptr, &m_outStage);
-  CHECK(SUCCEEDED(hr), "create efb encode output staging buffer");
-  D3D::SetDebugObjectName(m_outStage, "efb encoder output staging buffer");
+  // TODO: Move this to a constant somewhere in common.
+  TextureConfig encoding_texture_config(EFB_WIDTH * 4, 1024, 1, 1, AbstractTextureFormat::BGRA8,
+                                        true);
+  m_encoding_render_texture = g_renderer->CreateTexture(encoding_texture_config);
+  m_encoding_readback_texture =
+      g_renderer->CreateStagingTexture(StagingTextureType::Readback, encoding_texture_config);
+  _assert_(m_encoding_render_texture && m_encoding_readback_texture);
 
   // Create constant buffer for uploading data to shaders
   D3D11_BUFFER_DESC bd = CD3D11_BUFFER_DESC(sizeof(EFBEncodeParams), D3D11_BIND_CONSTANT_BUFFER);
-  hr = D3D::device->CreateBuffer(&bd, nullptr, &m_encodeParams);
+  HRESULT hr = D3D::device->CreateBuffer(&bd, nullptr, &m_encode_params);
   CHECK(SUCCEEDED(hr), "create efb encode params buffer");
-  D3D::SetDebugObjectName(m_encodeParams, "efb encoder params buffer");
-
-  m_ready = true;
+  D3D::SetDebugObjectName(m_encode_params, "efb encoder params buffer");
 }
 
 void PSTextureEncoder::Shutdown()
 {
-  m_ready = false;
-
   for (auto& it : m_encoding_shaders)
-  {
     SAFE_RELEASE(it.second);
-  }
   m_encoding_shaders.clear();
 
-  SAFE_RELEASE(m_encodeParams);
-  SAFE_RELEASE(m_outStage);
-  SAFE_RELEASE(m_outRTV);
-  SAFE_RELEASE(m_out);
+  SAFE_RELEASE(m_encode_params);
 }
 
 void PSTextureEncoder::Encode(u8* 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)
 {
-  if (!m_ready)  // Make sure we initialized OK
-    return;
-
-  HRESULT hr;
-
   // Resolve MSAA targets before copying.
   // FIXME: Instead of resolving EFB, it would be better to pick out a
   // single sample from each pixel. The game may break if it isn't
@@ -122,7 +91,10 @@ void PSTextureEncoder::Encode(u8* dst, const EFBCopyParams& params, u32 native_w
     constexpr EFBRectangle fullSrcRect(0, 0, EFB_WIDTH, EFB_HEIGHT);
     TargetRectangle targetRect = g_renderer->ConvertEFBRectangle(fullSrcRect);
 
-    D3D::context->OMSetRenderTargets(1, &m_outRTV, nullptr);
+    D3D::context->OMSetRenderTargets(
+        1,
+        &static_cast<DXTexture*>(m_encoding_render_texture.get())->GetRawTexIdentifier()->GetRTV(),
+        nullptr);
 
     EFBEncodeParams encode_params;
     encode_params.SrcLeft = src_rect.left;
@@ -130,8 +102,8 @@ void PSTextureEncoder::Encode(u8* dst, const EFBCopyParams& params, u32 native_w
     encode_params.DestWidth = native_width;
     encode_params.ScaleFactor = scale_by_half ? 2 : 1;
     encode_params.y_scale = params.y_scale;
-    D3D::context->UpdateSubresource(m_encodeParams, 0, nullptr, &encode_params, 0, 0);
-    D3D::stateman->SetPixelConstants(m_encodeParams);
+    D3D::context->UpdateSubresource(m_encode_params, 0, nullptr, &encode_params, 0, 0);
+    D3D::stateman->SetPixelConstants(m_encode_params);
 
     // We also linear filtering for both box filtering and downsampling higher resolutions to 1x
     // TODO: This only produces perfect downsampling for 2x IR, other resolutions will need more
@@ -148,24 +120,15 @@ void PSTextureEncoder::Encode(u8* dst, const EFBCopyParams& params, u32 native_w
                            VertexShaderCache::GetSimpleInputLayout());
 
     // Copy to staging buffer
-    D3D11_BOX srcBox = CD3D11_BOX(0, 0, 0, words_per_row, num_blocks_y, 1);
-    D3D::context->CopySubresourceRegion(m_outStage, 0, 0, 0, 0, m_out, 0, &srcBox);
-
-    // Transfer staging buffer to GameCube/Wii RAM
-    D3D11_MAPPED_SUBRESOURCE map = {0};
-    hr = D3D::context->Map(m_outStage, 0, D3D11_MAP_READ, 0, &map);
-    CHECK(SUCCEEDED(hr), "map staging buffer (0x%x)", hr);
-
-    u8* src = (u8*)map.pData;
-    u32 readStride = std::min(bytes_per_row, map.RowPitch);
-    for (unsigned int y = 0; y < num_blocks_y; ++y)
+    MathUtil::Rectangle<int> copy_rect(0, 0, words_per_row, num_blocks_y);
+    m_encoding_readback_texture->CopyFromTexture(m_encoding_render_texture.get(), copy_rect, 0, 0,
+                                                 copy_rect);
+    m_encoding_readback_texture->Flush();
+    if (m_encoding_readback_texture->Map())
     {
-      memcpy(dst, src, readStride);
-      dst += memory_stride;
-      src += map.RowPitch;
+      m_encoding_readback_texture->ReadTexels(copy_rect, dst, memory_stride);
+      m_encoding_readback_texture->Unmap();
     }
-
-    D3D::context->Unmap(m_outStage, 0);
   }
 
   // Restore API

Source/Core/VideoBackends/D3D/PSTextureEncoder.h

@@ -5,11 +5,15 @@
 #pragma once
 
 #include <map>
+#include <memory>
 
 #include "Common/CommonTypes.h"
 #include "VideoCommon/TextureConversionShader.h"
 #include "VideoCommon/VideoCommon.h"
 
+class AbstractTexture;
+class AbstractStagingTexture;
+
 struct ID3D11Texture2D;
 struct ID3D11RenderTargetView;
 struct ID3D11Buffer;
@@ -29,6 +33,7 @@ class PSTextureEncoder final
 {
 public:
   PSTextureEncoder();
+  ~PSTextureEncoder();
 
   void Init();
   void Shutdown();
@@ -39,12 +44,9 @@ public:
 private:
   ID3D11PixelShader* GetEncodingPixelShader(const EFBCopyParams& params);
 
-  bool m_ready;
-
-  ID3D11Texture2D* m_out;
-  ID3D11RenderTargetView* m_outRTV;
-  ID3D11Texture2D* m_outStage;
-  ID3D11Buffer* m_encodeParams;
+  ID3D11Buffer* m_encode_params = nullptr;
+  std::unique_ptr<AbstractTexture> m_encoding_render_texture;
+  std::unique_ptr<AbstractStagingTexture> m_encoding_readback_texture;
   std::map<EFBCopyParams, ID3D11PixelShader*> m_encoding_shaders;
 };
 }

Source/Core/VideoBackends/D3D/Render.cpp

@@ -53,31 +53,42 @@ typedef struct _Nv_Stereo_Image_Header
 
 #define NVSTEREO_IMAGE_SIGNATURE 0x4433564e
 
-struct GXPipelineState
+Renderer::Renderer() : ::Renderer(D3D::GetBackBufferWidth(), D3D::GetBackBufferHeight())
 {
-  std::array<SamplerState, 8> samplers;
-  BlendingState blend;
-  DepthState zmode;
-  RasterizationState raster;
-};
+  m_last_multisamples = g_ActiveConfig.iMultisamples;
+  m_last_stereo_mode = g_ActiveConfig.stereo_mode != StereoMode::Off;
+  m_last_fullscreen_mode = D3D::GetFullscreenState();
 
-static u32 s_last_multisamples = 1;
-static bool s_last_stereo_mode = false;
-static bool s_last_fullscreen_mode = false;
+  g_framebuffer_manager = std::make_unique<FramebufferManager>(m_target_width, m_target_height);
+  SetupDeviceObjects();
 
-static std::array<ID3D11BlendState*, 4> s_clear_blend_states{};
-static std::array<ID3D11DepthStencilState*, 3> s_clear_depth_states{};
-static ID3D11BlendState* s_reset_blend_state = nullptr;
-static ID3D11DepthStencilState* s_reset_depth_state = nullptr;
-static ID3D11RasterizerState* s_reset_rast_state = nullptr;
+  // Setup GX pipeline state
+  for (auto& sampler : m_gx_state.samplers)
+    sampler.hex = RenderState::GetPointSamplerState().hex;
 
-static ID3D11Texture2D* s_screenshot_texture = nullptr;
-static D3DTexture2D* s_3d_vision_texture = nullptr;
+  m_gx_state.zmode.testenable = false;
+  m_gx_state.zmode.updateenable = false;
+  m_gx_state.zmode.func = ZMode::NEVER;
+  m_gx_state.raster.cullmode = GenMode::CULL_NONE;
 
-static GXPipelineState s_gx_state;
-static StateCache s_gx_state_cache;
+  // Clear EFB textures
+  constexpr std::array<float, 4> clear_color{{0.f, 0.f, 0.f, 1.f}};
+  D3D::context->ClearRenderTargetView(FramebufferManager::GetEFBColorTexture()->GetRTV(),
+                                      clear_color.data());
+  D3D::context->ClearDepthStencilView(FramebufferManager::GetEFBDepthTexture()->GetDSV(),
+                                      D3D11_CLEAR_DEPTH, 0.f, 0);
 
-static void SetupDeviceObjects()
+  D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)m_target_width, (float)m_target_height);
+  D3D::context->RSSetViewports(1, &vp);
+  FramebufferManager::BindEFBRenderTarget();
+}
+
+Renderer::~Renderer()
+{
+  TeardownDeviceObjects();
+}
+
+void Renderer::SetupDeviceObjects()
 {
   HRESULT hr;
 
@@ -88,22 +99,22 @@ static void SetupDeviceObjects()
   ddesc.StencilEnable = FALSE;
   ddesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
   ddesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
-  hr = D3D::device->CreateDepthStencilState(&ddesc, &s_clear_depth_states[0]);
+  hr = D3D::device->CreateDepthStencilState(&ddesc, &m_clear_depth_states[0]);
   CHECK(hr == S_OK, "Create depth state for Renderer::ClearScreen");
   ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
   ddesc.DepthEnable = TRUE;
-  hr = D3D::device->CreateDepthStencilState(&ddesc, &s_clear_depth_states[1]);
+  hr = D3D::device->CreateDepthStencilState(&ddesc, &m_clear_depth_states[1]);
   CHECK(hr == S_OK, "Create depth state for Renderer::ClearScreen");
   ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
-  hr = D3D::device->CreateDepthStencilState(&ddesc, &s_clear_depth_states[2]);
+  hr = D3D::device->CreateDepthStencilState(&ddesc, &m_clear_depth_states[2]);
   CHECK(hr == S_OK, "Create depth state for Renderer::ClearScreen");
-  D3D::SetDebugObjectName(s_clear_depth_states[0],
+  D3D::SetDebugObjectName(m_clear_depth_states[0],
                           "depth state for Renderer::ClearScreen (depth buffer disabled)");
   D3D::SetDebugObjectName(
-      s_clear_depth_states[1],
+      m_clear_depth_states[1],
       "depth state for Renderer::ClearScreen (depth buffer enabled, writing enabled)");
   D3D::SetDebugObjectName(
-      s_clear_depth_states[2],
+      m_clear_depth_states[2],
       "depth state for Renderer::ClearScreen (depth buffer enabled, writing disabled)");
 
   D3D11_BLEND_DESC blenddesc;
@@ -117,24 +128,24 @@ static void SetupDeviceObjects()
   blenddesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
   blenddesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
   blenddesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
-  hr = D3D::device->CreateBlendState(&blenddesc, &s_reset_blend_state);
+  hr = D3D::device->CreateBlendState(&blenddesc, &m_reset_blend_state);
   CHECK(hr == S_OK, "Create blend state for Renderer::ResetAPIState");
-  D3D::SetDebugObjectName(s_reset_blend_state, "blend state for Renderer::ResetAPIState");
+  D3D::SetDebugObjectName(m_reset_blend_state, "blend state for Renderer::ResetAPIState");
 
-  s_clear_blend_states[0] = s_reset_blend_state;
-  s_reset_blend_state->AddRef();
+  m_clear_blend_states[0] = m_reset_blend_state;
+  m_reset_blend_state->AddRef();
 
   blenddesc.RenderTarget[0].RenderTargetWriteMask =
       D3D11_COLOR_WRITE_ENABLE_RED | D3D11_COLOR_WRITE_ENABLE_GREEN | D3D11_COLOR_WRITE_ENABLE_BLUE;
-  hr = D3D::device->CreateBlendState(&blenddesc, &s_clear_blend_states[1]);
+  hr = D3D::device->CreateBlendState(&blenddesc, &m_clear_blend_states[1]);
   CHECK(hr == S_OK, "Create blend state for Renderer::ClearScreen");
 
   blenddesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALPHA;
-  hr = D3D::device->CreateBlendState(&blenddesc, &s_clear_blend_states[2]);
+  hr = D3D::device->CreateBlendState(&blenddesc, &m_clear_blend_states[2]);
   CHECK(hr == S_OK, "Create blend state for Renderer::ClearScreen");
 
   blenddesc.RenderTarget[0].RenderTargetWriteMask = 0;
-  hr = D3D::device->CreateBlendState(&blenddesc, &s_clear_blend_states[3]);
+  hr = D3D::device->CreateBlendState(&blenddesc, &m_clear_blend_states[3]);
   CHECK(hr == S_OK, "Create blend state for Renderer::ClearScreen");
 
   ddesc.DepthEnable = FALSE;
@@ -143,41 +154,39 @@ static void SetupDeviceObjects()
   ddesc.StencilEnable = FALSE;
   ddesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
   ddesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
-  hr = D3D::device->CreateDepthStencilState(&ddesc, &s_reset_depth_state);
+  hr = D3D::device->CreateDepthStencilState(&ddesc, &m_reset_depth_state);
   CHECK(hr == S_OK, "Create depth state for Renderer::ResetAPIState");
-  D3D::SetDebugObjectName(s_reset_depth_state, "depth stencil state for Renderer::ResetAPIState");
+  D3D::SetDebugObjectName(m_reset_depth_state, "depth stencil state for Renderer::ResetAPIState");
 
   D3D11_RASTERIZER_DESC rastdesc = CD3D11_RASTERIZER_DESC(D3D11_FILL_SOLID, D3D11_CULL_NONE, false,
                                                           0, 0.f, 0.f, false, false, false, false);
-  hr = D3D::device->CreateRasterizerState(&rastdesc, &s_reset_rast_state);
+  hr = D3D::device->CreateRasterizerState(&rastdesc, &m_reset_rast_state);
   CHECK(hr == S_OK, "Create rasterizer state for Renderer::ResetAPIState");
-  D3D::SetDebugObjectName(s_reset_rast_state, "rasterizer state for Renderer::ResetAPIState");
+  D3D::SetDebugObjectName(m_reset_rast_state, "rasterizer state for Renderer::ResetAPIState");
 
-  s_screenshot_texture = nullptr;
+  m_screenshot_texture = nullptr;
 }
 
 // Kill off all device objects
-static void TeardownDeviceObjects()
+void Renderer::TeardownDeviceObjects()
 {
   g_framebuffer_manager.reset();
 
-  SAFE_RELEASE(s_clear_blend_states[0]);
-  SAFE_RELEASE(s_clear_blend_states[1]);
-  SAFE_RELEASE(s_clear_blend_states[2]);
-  SAFE_RELEASE(s_clear_blend_states[3]);
-  SAFE_RELEASE(s_clear_depth_states[0]);
-  SAFE_RELEASE(s_clear_depth_states[1]);
-  SAFE_RELEASE(s_clear_depth_states[2]);
-  SAFE_RELEASE(s_reset_blend_state);
-  SAFE_RELEASE(s_reset_depth_state);
-  SAFE_RELEASE(s_reset_rast_state);
-  SAFE_RELEASE(s_screenshot_texture);
-  SAFE_RELEASE(s_3d_vision_texture);
-
-  s_gx_state_cache.Clear();
+  SAFE_RELEASE(m_clear_blend_states[0]);
+  SAFE_RELEASE(m_clear_blend_states[1]);
+  SAFE_RELEASE(m_clear_blend_states[2]);
+  SAFE_RELEASE(m_clear_blend_states[3]);
+  SAFE_RELEASE(m_clear_depth_states[0]);
+  SAFE_RELEASE(m_clear_depth_states[1]);
+  SAFE_RELEASE(m_clear_depth_states[2]);
+  SAFE_RELEASE(m_reset_blend_state);
+  SAFE_RELEASE(m_reset_depth_state);
+  SAFE_RELEASE(m_reset_rast_state);
+  SAFE_RELEASE(m_screenshot_texture);
+  SAFE_RELEASE(m_3d_vision_texture);
 }
 
-static void Create3DVisionTexture(int width, int height)
+void Renderer::Create3DVisionTexture(int width, int height)
 {
   // Create a staging texture for 3D vision with signature information in the last row.
   // Nvidia 3D Vision supports full SBS, so there is no loss in resolution during this process.
@@ -197,48 +206,20 @@ static void Create3DVisionTexture(int width, int height)
   sys_data.SysMemPitch = pitch;
   sys_data.pSysMem = memory.get();
 
-  s_3d_vision_texture =
+  m_3d_vision_texture =
       D3DTexture2D::Create(width * 2, height + 1, D3D11_BIND_RENDER_TARGET, D3D11_USAGE_DEFAULT,
                            DXGI_FORMAT_R8G8B8A8_UNORM, 1, 1, &sys_data);
 }
 
-Renderer::Renderer() : ::Renderer(D3D::GetBackBufferWidth(), D3D::GetBackBufferHeight())
+std::unique_ptr<AbstractTexture> Renderer::CreateTexture(const TextureConfig& config)
 {
-  s_last_multisamples = g_ActiveConfig.iMultisamples;
-  s_last_stereo_mode = g_ActiveConfig.stereo_mode != StereoMode::Off;
-  s_last_fullscreen_mode = D3D::GetFullscreenState();
-
-  g_framebuffer_manager = std::make_unique<FramebufferManager>(m_target_width, m_target_height);
-  SetupDeviceObjects();
-
-  // Setup GX pipeline state
-  for (auto& sampler : s_gx_state.samplers)
-    sampler.hex = RenderState::GetPointSamplerState().hex;
-
-  s_gx_state.zmode.testenable = false;
-  s_gx_state.zmode.updateenable = false;
-  s_gx_state.zmode.func = ZMode::NEVER;
-  s_gx_state.raster.cullmode = GenMode::CULL_NONE;
-
-  // Clear EFB textures
-  constexpr std::array<float, 4> clear_color{{0.f, 0.f, 0.f, 1.f}};
-  D3D::context->ClearRenderTargetView(FramebufferManager::GetEFBColorTexture()->GetRTV(),
-                                      clear_color.data());
-  D3D::context->ClearDepthStencilView(FramebufferManager::GetEFBDepthTexture()->GetDSV(),
-                                      D3D11_CLEAR_DEPTH, 0.f, 0);
-
-  D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)m_target_width, (float)m_target_height);
-  D3D::context->RSSetViewports(1, &vp);
-  FramebufferManager::BindEFBRenderTarget();
-  D3D::BeginFrame();
+  return std::make_unique<DXTexture>(config);
 }
 
-Renderer::~Renderer()
+std::unique_ptr<AbstractStagingTexture> Renderer::CreateStagingTexture(StagingTextureType type,
+                                                                       const TextureConfig& config)
 {
-  TeardownDeviceObjects();
-  D3D::EndFrame();
-  D3D::Present();
-  D3D::Close();
+  return DXStagingTexture::Create(type, config);
 }
 
 void Renderer::RenderText(const std::string& text, int left, int top, u32 color)
@@ -443,8 +424,8 @@ void Renderer::PokeEFB(EFBAccessType type, const EfbPokeData* points, size_t num
   }
   else  // if (type == EFBAccessType::PokeZ)
   {
-    D3D::stateman->PushBlendState(s_clear_blend_states[3]);
-    D3D::stateman->PushDepthState(s_clear_depth_states[1]);
+    D3D::stateman->PushBlendState(m_clear_blend_states[3]);
+    D3D::stateman->PushDepthState(m_clear_depth_states[1]);
 
     D3D11_VIEWPORT vp =
         CD3D11_VIEWPORT(0.0f, 0.0f, (float)GetTargetWidth(), (float)GetTargetHeight());
@@ -526,21 +507,21 @@ void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaE
   ResetAPIState();
 
   if (colorEnable && alphaEnable)
-    D3D::stateman->PushBlendState(s_clear_blend_states[0]);
+    D3D::stateman->PushBlendState(m_clear_blend_states[0]);
   else if (colorEnable)
-    D3D::stateman->PushBlendState(s_clear_blend_states[1]);
+    D3D::stateman->PushBlendState(m_clear_blend_states[1]);
   else if (alphaEnable)
-    D3D::stateman->PushBlendState(s_clear_blend_states[2]);
+    D3D::stateman->PushBlendState(m_clear_blend_states[2]);
   else
-    D3D::stateman->PushBlendState(s_clear_blend_states[3]);
+    D3D::stateman->PushBlendState(m_clear_blend_states[3]);
 
   // TODO: Should we enable Z testing here?
   // if (!bpmem.zmode.testenable) D3D::stateman->PushDepthState(s_clear_depth_states[0]);
   // else
   if (zEnable)
-    D3D::stateman->PushDepthState(s_clear_depth_states[1]);
+    D3D::stateman->PushDepthState(m_clear_depth_states[1]);
   else /*if (!zEnable)*/
-    D3D::stateman->PushDepthState(s_clear_depth_states[2]);
+    D3D::stateman->PushDepthState(m_clear_depth_states[2]);
 
   // Update the view port for clearing the picture
   TargetRectangle targetRc = Renderer::ConvertEFBRectangle(rc);
@@ -600,7 +581,7 @@ void Renderer::ReinterpretPixelData(unsigned int convtype)
 
 void Renderer::SetBlendingState(const BlendingState& state)
 {
-  s_gx_state.blend.hex = state.hex;
+  m_gx_state.blend.hex = state.hex;
 }
 
 // This function has the final picture. We adjust the aspect ratio here.
@@ -633,7 +614,6 @@ void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region
   Renderer::DrawDebugText();
 
   OSD::DrawMessages();
-  D3D::EndFrame();
 
   g_texture_cache->Cleanup(frameCount);
 
@@ -646,33 +626,33 @@ void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region
 
   const bool window_resized = CheckForResize();
   const bool fullscreen = D3D::GetFullscreenState();
-  const bool fs_changed = s_last_fullscreen_mode != fullscreen;
+  const bool fs_changed = m_last_fullscreen_mode != fullscreen;
 
   // Flip/present backbuffer to frontbuffer here
   D3D::Present();
 
   // Resize the back buffers NOW to avoid flickering
   if (CalculateTargetSize() || window_resized || fs_changed ||
-      s_last_multisamples != g_ActiveConfig.iMultisamples ||
-      s_last_stereo_mode != (g_ActiveConfig.stereo_mode != StereoMode::Off))
+      m_last_multisamples != g_ActiveConfig.iMultisamples ||
+      m_last_stereo_mode != (g_ActiveConfig.stereo_mode != StereoMode::Off))
   {
-    s_last_multisamples = g_ActiveConfig.iMultisamples;
-    s_last_fullscreen_mode = fullscreen;
+    m_last_multisamples = g_ActiveConfig.iMultisamples;
+    m_last_fullscreen_mode = fullscreen;
     PixelShaderCache::InvalidateMSAAShaders();
 
     if (window_resized || fs_changed)
     {
       // TODO: Aren't we still holding a reference to the back buffer right now?
       D3D::Reset();
-      SAFE_RELEASE(s_screenshot_texture);
-      SAFE_RELEASE(s_3d_vision_texture);
+      SAFE_RELEASE(m_screenshot_texture);
+      SAFE_RELEASE(m_3d_vision_texture);
       m_backbuffer_width = D3D::GetBackBufferWidth();
       m_backbuffer_height = D3D::GetBackBufferHeight();
     }
 
     UpdateDrawRectangle();
 
-    s_last_stereo_mode = g_ActiveConfig.stereo_mode != StereoMode::Off;
+    m_last_stereo_mode = g_ActiveConfig.stereo_mode != StereoMode::Off;
 
     D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), nullptr);
 
@@ -694,7 +674,6 @@ void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region
 
   // begin next frame
   RestoreAPIState();
-  D3D::BeginFrame();
   FramebufferManager::BindEFBRenderTarget();
   SetViewport();
 }
@@ -702,9 +681,9 @@ void Renderer::SwapImpl(AbstractTexture* texture, const EFBRectangle& xfb_region
 // ALWAYS call RestoreAPIState for each ResetAPIState call you're doing
 void Renderer::ResetAPIState()
 {
-  D3D::stateman->PushBlendState(s_reset_blend_state);
-  D3D::stateman->PushDepthState(s_reset_depth_state);
-  D3D::stateman->PushRasterizerState(s_reset_rast_state);
+  D3D::stateman->PushBlendState(m_reset_blend_state);
+  D3D::stateman->PushDepthState(m_reset_depth_state);
+  D3D::stateman->PushRasterizerState(m_reset_rast_state);
 }
 
 void Renderer::RestoreAPIState()
@@ -719,15 +698,15 @@ void Renderer::RestoreAPIState()
 
 void Renderer::ApplyState()
 {
-  D3D::stateman->PushBlendState(s_gx_state_cache.Get(s_gx_state.blend));
-  D3D::stateman->PushDepthState(s_gx_state_cache.Get(s_gx_state.zmode));
-  D3D::stateman->PushRasterizerState(s_gx_state_cache.Get(s_gx_state.raster));
+  D3D::stateman->PushBlendState(m_state_cache.Get(m_gx_state.blend));
+  D3D::stateman->PushDepthState(m_state_cache.Get(m_gx_state.zmode));
+  D3D::stateman->PushRasterizerState(m_state_cache.Get(m_gx_state.raster));
   D3D::stateman->SetPrimitiveTopology(
-      StateCache::GetPrimitiveTopology(s_gx_state.raster.primitive));
-  FramebufferManager::SetIntegerEFBRenderTarget(s_gx_state.blend.logicopenable);
+      StateCache::GetPrimitiveTopology(m_gx_state.raster.primitive));
+  FramebufferManager::SetIntegerEFBRenderTarget(m_gx_state.blend.logicopenable);
 
-  for (u32 stage = 0; stage < static_cast<u32>(s_gx_state.samplers.size()); stage++)
-    D3D::stateman->SetSampler(stage, s_gx_state_cache.Get(s_gx_state.samplers[stage]));
+  for (u32 stage = 0; stage < static_cast<u32>(m_gx_state.samplers.size()); stage++)
+    D3D::stateman->SetSampler(stage, m_state_cache.Get(m_gx_state.samplers[stage]));
 
   ID3D11Buffer* vertexConstants = VertexShaderCache::GetConstantBuffer();
 
@@ -746,17 +725,17 @@ void Renderer::RestoreState()
 
 void Renderer::SetRasterizationState(const RasterizationState& state)
 {
-  s_gx_state.raster.hex = state.hex;
+  m_gx_state.raster.hex = state.hex;
 }
 
 void Renderer::SetDepthState(const DepthState& state)
 {
-  s_gx_state.zmode.hex = state.hex;
+  m_gx_state.zmode.hex = state.hex;
 }
 
 void Renderer::SetSamplerState(u32 index, const SamplerState& state)
 {
-  s_gx_state.samplers[index].hex = state.hex;
+  m_gx_state.samplers[index].hex = state.hex;
 }
 
 void Renderer::SetInterlacingMode()
@@ -831,7 +810,7 @@ void Renderer::BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D
   }
   else if (g_ActiveConfig.stereo_mode == StereoMode::Nvidia3DVision)
   {
-    if (!s_3d_vision_texture)
+    if (!m_3d_vision_texture)
       Create3DVisionTexture(m_backbuffer_width, m_backbuffer_height);
 
     D3D11_VIEWPORT leftVp = CD3D11_VIEWPORT((float)dst.left, (float)dst.top, (float)dst.GetWidth(),
@@ -840,7 +819,7 @@ void Renderer::BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D
                                              (float)dst.GetWidth(), (float)dst.GetHeight());
 
     // Render to staging texture which is double the width of the backbuffer
-    D3D::context->OMSetRenderTargets(1, &s_3d_vision_texture->GetRTV(), nullptr);
+    D3D::context->OMSetRenderTargets(1, &m_3d_vision_texture->GetRTV(), nullptr);
 
     D3D::context->RSSetViewports(1, &leftVp);
     D3D::drawShadedTexQuad(src_texture->GetSRV(), src.AsRECT(), src_width, src_height,
@@ -858,7 +837,7 @@ void Renderer::BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D
     // recognize the signature and automatically include the right eye frame.
     D3D11_BOX box = CD3D11_BOX(0, 0, 0, m_backbuffer_width, m_backbuffer_height, 1);
     D3D::context->CopySubresourceRegion(D3D::GetBackBuffer()->GetTex(), 0, 0, 0, 0,
-                                        s_3d_vision_texture->GetTex(), 0, &box);
+                                        m_3d_vision_texture->GetTex(), 0, &box);
 
     // Restore render target to backbuffer
     D3D::context->OMSetRenderTargets(1, &D3D::GetBackBuffer()->GetRTV(), nullptr);

Source/Core/VideoBackends/D3D/Render.h

@@ -4,7 +4,9 @@
 
 #pragma once
 
+#include <array>
 #include <string>
+#include "VideoBackends/D3D/D3DState.h"
 #include "VideoCommon/RenderBase.h"
 
 enum class EFBAccessType;
@@ -19,6 +21,11 @@ public:
   Renderer();
   ~Renderer() override;
 
+  StateCache& GetStateCache() { return m_state_cache; }
+  std::unique_ptr<AbstractTexture> CreateTexture(const TextureConfig& config) override;
+  std::unique_ptr<AbstractStagingTexture>
+  CreateStagingTexture(StagingTextureType type, const TextureConfig& config) override;
+
   void SetBlendingState(const BlendingState& state) override;
   void SetScissorRect(const EFBRectangle& rc) override;
   void SetRasterizationState(const RasterizationState& state) override;
@@ -56,7 +63,35 @@ public:
   bool CheckForResize();
 
 private:
+  struct GXPipelineState
+  {
+    std::array<SamplerState, 8> samplers;
+    BlendingState blend;
+    DepthState zmode;
+    RasterizationState raster;
+  };
+
+  void SetupDeviceObjects();
+  void TeardownDeviceObjects();
+  void Create3DVisionTexture(int width, int height);
+
   void BlitScreen(TargetRectangle src, TargetRectangle dst, D3DTexture2D* src_texture,
                   u32 src_width, u32 src_height, float Gamma);
+
+  StateCache m_state_cache;
+  GXPipelineState m_gx_state;
+
+  std::array<ID3D11BlendState*, 4> m_clear_blend_states{};
+  std::array<ID3D11DepthStencilState*, 3> m_clear_depth_states{};
+  ID3D11BlendState* m_reset_blend_state = nullptr;
+  ID3D11DepthStencilState* m_reset_depth_state = nullptr;
+  ID3D11RasterizerState* m_reset_rast_state = nullptr;
+
+  ID3D11Texture2D* m_screenshot_texture = nullptr;
+  D3DTexture2D* m_3d_vision_texture = nullptr;
+
+  u32 m_last_multisamples = 1;
+  bool m_last_stereo_mode = false;
+  bool m_last_fullscreen_mode = false;
 };
 }

Source/Core/VideoBackends/D3D/TextureCache.cpp

@@ -33,11 +33,6 @@ static const size_t MAX_COPY_BUFFERS = 32;
 static ID3D11Buffer* s_efbcopycbuf[MAX_COPY_BUFFERS] = {0};
 static std::unique_ptr<PSTextureEncoder> g_encoder;
 
-std::unique_ptr<AbstractTexture> TextureCache::CreateTexture(const TextureConfig& config)
-{
-  return std::make_unique<DXTexture>(config);
-}
-
 void TextureCache::CopyEFB(u8* 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)

Source/Core/VideoBackends/D3D/TextureCache.h

@@ -19,8 +19,6 @@ public:
   ~TextureCache();
 
 private:
-  std::unique_ptr<AbstractTexture> CreateTexture(const TextureConfig& config) override;
-
   u64 EncodeToRamFromTexture(u32 address, void* source_texture, u32 SourceW, u32 SourceH,
                              bool bFromZBuffer, bool bIsIntensityFmt, u32 copyfmt, int bScaleByHalf,
                              const EFBRectangle& source)

Source/Core/VideoBackends/D3D/main.cpp

@@ -181,6 +181,8 @@ void VideoBackend::Shutdown()
   g_texture_cache.reset();
   g_renderer.reset();
 
+  D3D::Close();
+
   ShutdownShared();
 }
 

Source/Core/VideoBackends/Null/NullTexture.cpp

@@ -14,9 +14,15 @@ void NullTexture::Bind(unsigned int stage)
 {
 }
 
-void NullTexture::CopyRectangleFromTexture(const AbstractTexture* source,
-                                           const MathUtil::Rectangle<int>& srcrect,
-                                           const MathUtil::Rectangle<int>& dstrect)
+void NullTexture::CopyRectangleFromTexture(const AbstractTexture* src,
+                                           const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                           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)
 {
 }
 
@@ -25,4 +31,43 @@ void NullTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u
 {
 }
 
+NullStagingTexture::NullStagingTexture(StagingTextureType type, const TextureConfig& config)
+    : AbstractStagingTexture(type, config)
+{
+  m_texture_buf.resize(m_texel_size * config.width * config.height);
+  m_map_pointer = reinterpret_cast<char*>(m_texture_buf.data());
+  m_map_stride = m_texel_size * config.width;
+}
+
+NullStagingTexture::~NullStagingTexture() = default;
+
+void NullStagingTexture::CopyFromTexture(const AbstractTexture* src,
+                                         const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                         u32 src_level, const MathUtil::Rectangle<int>& dst_rect)
+{
+  m_needs_flush = true;
+}
+
+void NullStagingTexture::CopyToTexture(const MathUtil::Rectangle<int>& src_rect,
+                                       AbstractTexture* dst,
+                                       const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer,
+                                       u32 dst_level)
+{
+  m_needs_flush = true;
+}
+
+bool NullStagingTexture::Map()
+{
+  return true;
+}
+
+void NullStagingTexture::Unmap()
+{
+}
+
+void NullStagingTexture::Flush()
+{
+  m_needs_flush = false;
+}
+
 }  // namespace Null

Source/Core/VideoBackends/Null/NullTexture.h

@@ -4,8 +4,11 @@
 
 #pragma once
 
+#include <vector>
+
 #include "Common/CommonTypes.h"
 
+#include "VideoCommon/AbstractStagingTexture.h"
 #include "VideoCommon/AbstractTexture.h"
 
 namespace Null
@@ -18,11 +21,36 @@ public:
 
   void Bind(unsigned int stage) override;
 
-  void CopyRectangleFromTexture(const AbstractTexture* source,
-                                const MathUtil::Rectangle<int>& srcrect,
-                                const MathUtil::Rectangle<int>& dstrect) override;
+  void CopyRectangleFromTexture(const AbstractTexture* src,
+                                const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                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;
 };
 
+class NullStagingTexture final : public AbstractStagingTexture
+{
+public:
+  explicit NullStagingTexture(StagingTextureType type, const TextureConfig& config);
+  ~NullStagingTexture();
+
+  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_texture_buf;
+};
+
 }  // namespace Null

Source/Core/VideoBackends/Null/Render.cpp

@@ -4,6 +4,7 @@
 
 #include "Common/Logging/Log.h"
 
+#include "VideoBackends/Null/NullTexture.h"
 #include "VideoBackends/Null/Render.h"
 
 #include "VideoCommon/VideoConfig.h"
@@ -21,6 +22,17 @@ Renderer::~Renderer()
   UpdateActiveConfig();
 }
 
+std::unique_ptr<AbstractTexture> Renderer::CreateTexture(const TextureConfig& config)
+{
+  return std::make_unique<NullTexture>(config);
+}
+
+std::unique_ptr<AbstractStagingTexture> Renderer::CreateStagingTexture(StagingTextureType type,
+                                                                       const TextureConfig& config)
+{
+  return std::make_unique<NullStagingTexture>(type, config);
+}
+
 void Renderer::RenderText(const std::string& text, int left, int top, u32 color)
 {
   NOTICE_LOG(VIDEO, "RenderText: %s", text.c_str());

Source/Core/VideoBackends/Null/Render.h

@@ -14,6 +14,10 @@ public:
   Renderer();
   ~Renderer() override;
 
+  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 { return 0; }
   void PokeEFB(EFBAccessType type, const EfbPokeData* points, size_t num_points) override {}

Source/Core/VideoBackends/Null/TextureCache.h

@@ -35,12 +35,6 @@ public:
                            bool scale_by_half, unsigned int cbuf_id, const float* colmat) override
   {
   }
-
-private:
-  std::unique_ptr<AbstractTexture> CreateTexture(const TextureConfig& config) override
-  {
-    return std::make_unique<NullTexture>(config);
-  }
 };
 
 }  // Null name space

Source/Core/VideoBackends/OGL/OGLTexture.cpp

@@ -9,7 +9,6 @@
 
 #include "VideoBackends/OGL/FramebufferManager.h"
 #include "VideoBackends/OGL/OGLTexture.h"
-#include "VideoBackends/OGL/Render.h"
 #include "VideoBackends/OGL/SamplerCache.h"
 #include "VideoBackends/OGL/TextureCache.h"
 
@@ -36,7 +35,11 @@ GLenum GetGLInternalFormatForTextureFormat(AbstractTextureFormat format, bool st
   case AbstractTextureFormat::BPTC:
     return GL_COMPRESSED_RGBA_BPTC_UNORM_ARB;
   case AbstractTextureFormat::RGBA8:
+    return storage ? GL_RGBA8 : GL_RGBA;
+  case AbstractTextureFormat::BGRA8:
+    return storage ? GL_RGBA8 : GL_BGRA;
   default:
+    PanicAlert("Unhandled texture format.");
     return storage ? GL_RGBA8 : GL_RGBA;
   }
 }
@@ -47,6 +50,8 @@ GLenum GetGLFormatForTextureFormat(AbstractTextureFormat format)
   {
   case AbstractTextureFormat::RGBA8:
     return GL_RGBA;
+  case AbstractTextureFormat::BGRA8:
+    return GL_BGRA;
   // Compressed texture formats don't use this parameter.
   default:
     return GL_UNSIGNED_BYTE;
@@ -58,12 +63,22 @@ GLenum GetGLTypeForTextureFormat(AbstractTextureFormat format)
   switch (format)
   {
   case AbstractTextureFormat::RGBA8:
+  case AbstractTextureFormat::BGRA8:
     return GL_UNSIGNED_BYTE;
   // Compressed texture formats don't use this parameter.
   default:
     return GL_UNSIGNED_BYTE;
   }
 }
+
+bool UsePersistentStagingBuffers()
+{
+  // We require ARB_buffer_storage to create the persistent mapped buffer,
+  // ARB_shader_image_load_store for glMemoryBarrier, and ARB_sync to ensure
+  // the GPU has finished the copy before reading the buffer from the CPU.
+  return g_ogl_config.bSupportsGLBufferStorage && g_ogl_config.bSupportsImageLoadStore &&
+         g_ogl_config.bSupportsGLSync;
+}
 }  // Anonymous namespace
 
 OGLTexture::OGLTexture(const TextureConfig& tex_config) : AbstractTexture(tex_config)
@@ -85,7 +100,7 @@ OGLTexture::OGLTexture(const TextureConfig& tex_config) : AbstractTexture(tex_co
   if (m_config.rendertarget)
   {
     // We can't render to compressed formats.
-    _assert_(!IsCompressedHostTextureFormat(m_config.format));
+    _assert_(!IsCompressedFormat(m_config.format));
 
     if (!g_ogl_config.bSupportsTextureStorage)
     {
@@ -100,6 +115,10 @@ OGLTexture::OGLTexture(const TextureConfig& tex_config) : AbstractTexture(tex_co
     FramebufferManager::SetFramebuffer(m_framebuffer);
     FramebufferManager::FramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                            GL_TEXTURE_2D_ARRAY, m_texId, 0);
+
+    // We broke the framebuffer binding here, and need to restore it, as the CreateTexture
+    // method is in the base renderer class and can be called by VideoCommon.
+    FramebufferManager::SetFramebuffer(0);
   }
 
   SetStage();
@@ -148,89 +167,70 @@ void OGLTexture::Bind(unsigned int stage)
   }
 }
 
-std::optional<AbstractTexture::RawTextureInfo> OGLTexture::MapFullImpl()
+void OGLTexture::CopyRectangleFromTexture(const AbstractTexture* src,
+                                          const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                          u32 src_level, const MathUtil::Rectangle<int>& dst_rect,
+                                          u32 dst_layer, u32 dst_level)
 {
-  if (GLInterface->GetMode() != GLInterfaceMode::MODE_OPENGL)
-    return {};
-
-  m_staging_data.reserve(m_config.width * m_config.height * 4);
-  glActiveTexture(GL_TEXTURE9);
-
-  glBindTexture(GL_TEXTURE_2D_ARRAY, m_texId);
-  glGetTexImage(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_staging_data.data());
-  OGLTexture::SetStage();
-  return AbstractTexture::RawTextureInfo{reinterpret_cast<u8*>(m_staging_data.data()),
-                                         m_config.width * 4, m_config.width, m_config.height};
-}
-
-std::optional<AbstractTexture::RawTextureInfo> OGLTexture::MapRegionImpl(u32 level, u32 x, u32 y,
-                                                                         u32 width, u32 height)
-{
-  if (GLInterface->GetMode() != GLInterfaceMode::MODE_OPENGL)
-    return {};
-  m_staging_data.reserve(m_config.width * m_config.height * 4);
-  glActiveTexture(GL_TEXTURE9);
-  glBindTexture(GL_TEXTURE_2D_ARRAY, m_texId);
-  if (g_ogl_config.bSupportTextureSubImage)
+  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)
   {
-    glGetTextureSubImage(GL_TEXTURE_2D_ARRAY, level, GLint(x), GLint(y), 0, GLsizei(width),
-                         GLsizei(height), 0, GL_RGBA, GL_UNSIGNED_BYTE, GLsizei(width * height * 4),
-                         m_staging_data.data());
+    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
   {
-    MapRegionSlow(level, x, y, width, height);
+    // 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);
   }
-  OGLTexture::SetStage();
-  return AbstractTexture::RawTextureInfo{m_staging_data.data(), width * 4, width, height};
 }
-
-void OGLTexture::MapRegionSlow(u32 level, u32 x, u32 y, u32 width, u32 height)
-{
-  glActiveTexture(GL_TEXTURE9);
-
-  glBindTexture(GL_TEXTURE_2D_ARRAY, m_texId);
-  glGetTexImage(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_staging_data.data());
-
-  // Now copy the region out of the staging data
-
-  const u32 partial_stride = width * 4;
-
-  std::vector<u8> partial_data;
-  partial_data.resize(partial_stride * height);
-
-  const u32 staging_stride = m_config.width * 4;
-  const u32 x_offset = x * 4;
-
-  auto staging_location = m_staging_data.begin() + staging_stride * y;
-  auto partial_location = partial_data.begin();
-
-  for (size_t i = 0; i < height; ++i)
-  {
-    auto starting_location = staging_location + x_offset;
-    std::copy(starting_location, starting_location + partial_stride, partial_location);
-    staging_location += staging_stride;
-    partial_location += partial_stride;
-  }
-
-  // Now swap the region back in for the staging data
-  m_staging_data.swap(partial_data);
-}
-
-void OGLTexture::CopyRectangleFromTexture(const AbstractTexture* source,
-                                          const MathUtil::Rectangle<int>& srcrect,
-                                          const MathUtil::Rectangle<int>& dstrect)
+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() &&
-      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)
+  if (!m_framebuffer)
   {
     glGenFramebuffers(1, &m_framebuffer);
     FramebufferManager::SetFramebuffer(m_framebuffer);
@@ -269,7 +269,7 @@ void OGLTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u8
     glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length);
 
   GLenum gl_internal_format = GetGLInternalFormatForTextureFormat(m_config.format, false);
-  if (IsCompressedHostTextureFormat(m_config.format))
+  if (IsCompressedFormat(m_config.format))
   {
     if (g_ogl_config.bSupportsTextureStorage)
     {
@@ -315,4 +315,262 @@ void OGLTexture::SetStage()
     glActiveTexture(GL_TEXTURE0 + s_ActiveTexture);
 }
 
+OGLStagingTexture::OGLStagingTexture(StagingTextureType type, const TextureConfig& config,
+                                     GLenum target, GLuint buffer_name, size_t buffer_size,
+                                     char* map_ptr, size_t map_stride)
+    : AbstractStagingTexture(type, config), m_target(target), m_buffer_name(buffer_name),
+      m_buffer_size(buffer_size)
+{
+  m_map_pointer = map_ptr;
+  m_map_stride = map_stride;
+}
+
+OGLStagingTexture::~OGLStagingTexture()
+{
+  if (m_fence != 0)
+    glDeleteSync(m_fence);
+  if (m_map_pointer)
+  {
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, m_buffer_name);
+    glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+  }
+  if (m_buffer_name != 0)
+    glDeleteBuffers(1, &m_buffer_name);
+}
+
+std::unique_ptr<OGLStagingTexture> OGLStagingTexture::Create(StagingTextureType type,
+                                                             const TextureConfig& config)
+{
+  size_t stride = config.GetStride();
+  size_t buffer_size = stride * config.height;
+  GLenum target =
+      type == StagingTextureType::Readback ? GL_PIXEL_PACK_BUFFER : GL_PIXEL_UNPACK_BUFFER;
+  GLuint buffer;
+  glGenBuffers(1, &buffer);
+  glBindBuffer(target, buffer);
+
+  // Prefer using buffer_storage where possible. This allows us to skip the map/unmap steps.
+  char* buffer_ptr;
+  if (UsePersistentStagingBuffers())
+  {
+    GLenum buffer_flags;
+    GLenum map_flags;
+    if (type == StagingTextureType::Readback)
+    {
+      buffer_flags = GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT;
+      map_flags = GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT;
+    }
+    else if (type == StagingTextureType::Upload)
+    {
+      buffer_flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT;
+      map_flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_FLUSH_EXPLICIT_BIT;
+    }
+    else
+    {
+      buffer_flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT;
+      map_flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT;
+    }
+
+    glBufferStorage(target, buffer_size, nullptr, buffer_flags);
+    buffer_ptr =
+        reinterpret_cast<char*>(glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, buffer_size, map_flags));
+    _assert_(buffer_ptr != nullptr);
+  }
+  else
+  {
+    // Otherwise, fallback to mapping the buffer each time.
+    glBufferData(target, buffer_size, nullptr,
+                 type == StagingTextureType::Readback ? GL_STREAM_READ : GL_STREAM_DRAW);
+    buffer_ptr = nullptr;
+  }
+  glBindBuffer(target, 0);
+
+  return std::unique_ptr<OGLStagingTexture>(
+      new OGLStagingTexture(type, config, target, buffer, buffer_size, buffer_ptr, stride));
+}
+
+void OGLStagingTexture::CopyFromTexture(const AbstractTexture* src,
+                                        const MathUtil::Rectangle<int>& src_rect, u32 src_layer,
+                                        u32 src_level, const MathUtil::Rectangle<int>& dst_rect)
+{
+  _assert_(m_type == StagingTextureType::Readback);
+  _assert_(src_rect.GetWidth() == dst_rect.GetWidth() &&
+           src_rect.GetHeight() == dst_rect.GetHeight());
+  _assert_(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= src->GetConfig().width &&
+           src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= src->GetConfig().height);
+  _assert_(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= m_config.width &&
+           dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= m_config.height);
+
+  // Unmap the buffer before writing when not using persistent mappings.
+  if (!UsePersistentStagingBuffers())
+    OGLStagingTexture::Unmap();
+
+  // Copy from the texture object to the staging buffer.
+  glBindBuffer(GL_PIXEL_PACK_BUFFER, m_buffer_name);
+  glPixelStorei(GL_PACK_ROW_LENGTH, m_config.width);
+
+  const OGLTexture* gltex = static_cast<const OGLTexture*>(src);
+  size_t dst_offset = dst_rect.top * m_config.GetStride() + dst_rect.left * m_texel_size;
+
+  // If we don't have a FBO associated with this texture, we need to use a slow path.
+  if (gltex->GetFramebuffer() != 0 && src_layer == 0 && src_level == 0)
+  {
+    // This texture has a framebuffer, so we can use glReadPixels().
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, gltex->GetFramebuffer());
+    glReadPixels(src_rect.left, src_rect.top, src_rect.GetWidth(), src_rect.GetHeight(),
+                 GetGLFormatForTextureFormat(m_config.format),
+                 GetGLTypeForTextureFormat(m_config.format), reinterpret_cast<void*>(dst_offset));
+
+    // Reset both read/draw framebuffers.
+    glBindFramebuffer(GL_FRAMEBUFFER, FramebufferManager::GetEFBFramebuffer());
+  }
+  else
+  {
+    glActiveTexture(GL_TEXTURE9);
+    glBindTexture(GL_TEXTURE_2D_ARRAY, gltex->GetRawTexIdentifier());
+    if (g_ogl_config.bSupportsTextureSubImage)
+    {
+      glGetTextureSubImage(
+          GL_TEXTURE_2D_ARRAY, src_level, src_rect.left, src_rect.top, src_layer,
+          src_rect.GetWidth(), src_rect.GetHeight(), 1,
+          GetGLFormatForTextureFormat(m_config.format), GetGLTypeForTextureFormat(m_config.format),
+          static_cast<GLsizei>(m_buffer_size - dst_offset), reinterpret_cast<void*>(dst_offset));
+    }
+    else
+    {
+      // TODO: Investigate whether it's faster to use glReadPixels() with a framebuffer, since we're
+      // copying the whole texture, which may waste bandwidth. So we're trading CPU work in creating
+      // the framebuffer for GPU work in copying potentially redundant texels.
+      glGetTexImage(GL_TEXTURE_2D_ARRAY, src_level, GetGLFormatForTextureFormat(m_config.format),
+                    GetGLTypeForTextureFormat(m_config.format), nullptr);
+    }
+
+    OGLTexture::SetStage();
+  }
+
+  glPixelStorei(GL_PACK_ROW_LENGTH, 0);
+  glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+  // If we support buffer storage, create a fence for synchronization.
+  if (UsePersistentStagingBuffers())
+  {
+    if (m_fence != 0)
+      glDeleteSync(m_fence);
+
+    glMemoryBarrier(GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT);
+    m_fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+  }
+
+  m_needs_flush = true;
+}
+
+void OGLStagingTexture::CopyToTexture(const MathUtil::Rectangle<int>& src_rect,
+                                      AbstractTexture* dst,
+                                      const MathUtil::Rectangle<int>& dst_rect, u32 dst_layer,
+                                      u32 dst_level)
+{
+  _assert_(m_type == StagingTextureType::Upload);
+  _assert_(src_rect.GetWidth() == dst_rect.GetWidth() &&
+           src_rect.GetHeight() == dst_rect.GetHeight());
+  _assert_(src_rect.left >= 0 && static_cast<u32>(src_rect.right) <= m_config.width &&
+           src_rect.top >= 0 && static_cast<u32>(src_rect.bottom) <= m_config.height);
+  _assert_(dst_rect.left >= 0 && static_cast<u32>(dst_rect.right) <= dst->GetConfig().width &&
+           dst_rect.top >= 0 && static_cast<u32>(dst_rect.bottom) <= dst->GetConfig().height);
+
+  size_t src_offset = src_rect.top * m_config.GetStride() + src_rect.left * m_texel_size;
+  size_t copy_size = src_rect.GetHeight() * m_config.GetStride();
+
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, m_buffer_name);
+  glPixelStorei(GL_UNPACK_ROW_LENGTH, m_config.width);
+
+  if (!UsePersistentStagingBuffers())
+  {
+    // Unmap the buffer before writing when not using persistent mappings.
+    if (m_map_pointer)
+    {
+      glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+      m_map_pointer = nullptr;
+    }
+  }
+  else
+  {
+    // Since we're not using coherent mapping, we must flush the range explicitly.
+    if (m_type == StagingTextureType::Upload)
+      glFlushMappedBufferRange(GL_PIXEL_UNPACK_BUFFER, src_offset, copy_size);
+    glMemoryBarrier(GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT);
+  }
+
+  // Copy from the staging buffer to the texture object.
+  glActiveTexture(GL_TEXTURE9);
+  glBindTexture(GL_TEXTURE_2D_ARRAY, static_cast<const OGLTexture*>(dst)->GetRawTexIdentifier());
+  glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, dst_rect.left, dst_rect.top, dst_layer,
+                  dst_rect.GetWidth(), dst_rect.GetHeight(), 1,
+                  GetGLFormatForTextureFormat(m_config.format),
+                  GetGLTypeForTextureFormat(m_config.format), reinterpret_cast<void*>(src_offset));
+  OGLTexture::SetStage();
+
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+  // If we support buffer storage, create a fence for synchronization.
+  if (UsePersistentStagingBuffers())
+  {
+    if (m_fence != 0)
+      glDeleteSync(m_fence);
+
+    m_fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+  }
+
+  m_needs_flush = true;
+}
+
+void OGLStagingTexture::Flush()
+{
+  // No-op when not using buffer storage, as the transfers happen on Map().
+  // m_fence will always be zero in this case.
+  if (m_fence == 0)
+  {
+    m_needs_flush = false;
+    return;
+  }
+
+  glClientWaitSync(m_fence, GL_SYNC_FLUSH_COMMANDS_BIT, GL_TIMEOUT_IGNORED);
+  glDeleteSync(m_fence);
+  m_fence = 0;
+  m_needs_flush = false;
+}
+
+bool OGLStagingTexture::Map()
+{
+  if (m_map_pointer)
+    return true;
+
+  // Slow path, map the texture, unmap it later.
+  GLenum flags;
+  if (m_type == StagingTextureType::Readback)
+    flags = GL_MAP_READ_BIT;
+  else if (m_type == StagingTextureType::Upload)
+    flags = GL_MAP_WRITE_BIT;
+  else
+    flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
+  glBindBuffer(m_target, m_buffer_name);
+  m_map_pointer = reinterpret_cast<char*>(glMapBufferRange(m_target, 0, m_buffer_size, flags));
+  if (!m_map_pointer)
+    return false;
+
+  return true;
+}
+
+void OGLStagingTexture::Unmap()
+{
+  // No-op with persistent mapped buffers.
+  if (!m_map_pointer || UsePersistentStagingBuffers())
+    return;
+
+  glBindBuffer(m_target, m_buffer_name);
+  glUnmapBuffer(m_target);
+  glBindBuffer(m_target, 0);
+  m_map_pointer = nullptr;
+}
+
 }  // namespace OGL