Merge pull request #5305 from iwubcode/abstract_texture

Abstract Texture

Source/Core/VideoBackends/D3D/CMakeLists.txt

@@ -13,6 +13,8 @@ set(SRCS
   D3DTexture.h
   D3DUtil.cpp
   D3DUtil.h
+  DXTexture.cpp
+  DXTexture.h
   FramebufferManager.cpp
   FramebufferManager.h
   GeometryShaderCache.cpp

Source/Core/VideoBackends/D3D/D3D.vcxproj

@@ -43,6 +43,7 @@
     <ClCompile Include="D3DState.cpp" />
     <ClCompile Include="D3DTexture.cpp" />
     <ClCompile Include="D3DUtil.cpp" />
+    <ClCompile Include="DXTexture.cpp" />
     <ClCompile Include="FramebufferManager.cpp" />
     <ClCompile Include="GeometryShaderCache.cpp" />
     <ClCompile Include="main.cpp" />
@@ -65,6 +66,7 @@
     <ClInclude Include="D3DState.h" />
     <ClInclude Include="D3DTexture.h" />
     <ClInclude Include="D3DUtil.h" />
+    <ClInclude Include="DXTexture.h" />
     <ClInclude Include="FramebufferManager.h" />
     <ClInclude Include="GeometryShaderCache.h" />
     <ClInclude Include="PerfQuery.h" />

Source/Core/VideoBackends/D3D/D3D.vcxproj.filters

@@ -67,6 +67,9 @@
     <ClCompile Include="BoundingBox.cpp">
       <Filter>Render</Filter>
     </ClCompile>
+    <ClCompile Include="DXTexture.cpp">
+      <Filter>Render</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="D3DBase.h">
@@ -124,5 +127,8 @@
     <ClInclude Include="BoundingBox.h">
       <Filter>Render</Filter>
     </ClInclude>
+    <ClInclude Include="DXTexture.h">
+      <Filter>Render</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Source/Core/VideoBackends/D3D/DXTexture.cpp

@@ -0,0 +1,196 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cstddef>
+
+#include "Common/Assert.h"
+#include "Common/CommonTypes.h"
+#include "Common/Logging/Log.h"
+
+#include "VideoBackends/D3D/D3DBase.h"
+#include "VideoBackends/D3D/D3DState.h"
+#include "VideoBackends/D3D/D3DTexture.h"
+#include "VideoBackends/D3D/D3DUtil.h"
+#include "VideoBackends/D3D/DXTexture.h"
+#include "VideoBackends/D3D/FramebufferManager.h"
+#include "VideoBackends/D3D/GeometryShaderCache.h"
+#include "VideoBackends/D3D/PixelShaderCache.h"
+#include "VideoBackends/D3D/TextureCache.h"
+#include "VideoBackends/D3D/VertexShaderCache.h"
+
+#include "VideoCommon/ImageWrite.h"
+#include "VideoCommon/TextureConfig.h"
+
+namespace DX11
+{
+namespace
+{
+DXGI_FORMAT GetDXGIFormatForHostFormat(AbstractTextureFormat format)
+{
+  switch (format)
+  {
+  case AbstractTextureFormat::DXT1:
+    return DXGI_FORMAT_BC1_UNORM;
+  case AbstractTextureFormat::DXT3:
+    return DXGI_FORMAT_BC2_UNORM;
+  case AbstractTextureFormat::DXT5:
+    return DXGI_FORMAT_BC3_UNORM;
+  case AbstractTextureFormat::RGBA8:
+  default:
+    return DXGI_FORMAT_R8G8B8A8_UNORM;
+  }
+}
+}  // Anonymous namespace
+
+DXTexture::DXTexture(const TextureConfig& tex_config) : AbstractTexture(tex_config)
+{
+  DXGI_FORMAT dxgi_format = GetDXGIFormatForHostFormat(m_config.format);
+  if (m_config.rendertarget)
+  {
+    m_texture = D3DTexture2D::Create(
+        m_config.width, m_config.height,
+        (D3D11_BIND_FLAG)((int)D3D11_BIND_RENDER_TARGET | (int)D3D11_BIND_SHADER_RESOURCE),
+        D3D11_USAGE_DEFAULT, dxgi_format, 1, m_config.layers);
+  }
+  else
+  {
+    const D3D11_TEXTURE2D_DESC texdesc =
+        CD3D11_TEXTURE2D_DESC(dxgi_format, m_config.width, m_config.height, 1, m_config.levels,
+                              D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_DEFAULT, 0);
+
+    ID3D11Texture2D* pTexture;
+    const HRESULT hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &pTexture);
+    CHECK(SUCCEEDED(hr), "Create texture of the TextureCache");
+
+    m_texture = new D3DTexture2D(pTexture, D3D11_BIND_SHADER_RESOURCE);
+
+    // TODO: better debug names
+    D3D::SetDebugObjectName((ID3D11DeviceChild*)m_texture->GetTex(),
+                            "a texture of the TextureCache");
+    D3D::SetDebugObjectName((ID3D11DeviceChild*)m_texture->GetSRV(),
+                            "shader resource view of a texture of the TextureCache");
+
+    SAFE_RELEASE(pTexture);
+  }
+}
+
+DXTexture::~DXTexture()
+{
+  m_texture->Release();
+}
+
+D3DTexture2D* DXTexture::GetRawTexIdentifier() const
+{
+  return m_texture;
+}
+
+void DXTexture::Bind(unsigned int stage)
+{
+  D3D::stateman->SetTexture(stage, m_texture->GetSRV());
+}
+
+bool DXTexture::Save(const std::string& filename, unsigned int level)
+{
+  // We can't dump compressed textures currently (it would mean drawing them to a RGBA8
+  // framebuffer, and saving that). TextureCache does not call Save for custom textures
+  // anyway, so this is fine for now.
+  _assert_(m_config.format == AbstractTextureFormat::RGBA8);
+
+  // Create a staging/readback texture with the dimensions of the specified mip level.
+  u32 mip_width = std::max(m_config.width >> level, 1u);
+  u32 mip_height = std::max(m_config.height >> level, 1u);
+  CD3D11_TEXTURE2D_DESC staging_texture_desc(DXGI_FORMAT_R8G8B8A8_UNORM, mip_width, mip_height, 1,
+                                             1, 0, D3D11_USAGE_STAGING, D3D11_CPU_ACCESS_READ);
+
+  ID3D11Texture2D* staging_texture;
+  HRESULT hr = D3D::device->CreateTexture2D(&staging_texture_desc, nullptr, &staging_texture);
+  if (FAILED(hr))
+  {
+    WARN_LOG(VIDEO, "Failed to create texture dumping readback texture: %X", static_cast<u32>(hr));
+    return false;
+  }
+
+  // Copy the selected mip level to the staging texture.
+  CD3D11_BOX src_box(0, 0, 0, mip_width, mip_height, 1);
+  D3D::context->CopySubresourceRegion(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(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));
+    staging_texture->Release();
+    return false;
+  }
+
+  bool encode_result =
+      TextureToPng(reinterpret_cast<u8*>(map.pData), map.RowPitch, filename, mip_width, mip_height);
+  D3D::context->Unmap(staging_texture, 0);
+  staging_texture->Release();
+
+  return encode_result;
+}
+
+void DXTexture::CopyRectangleFromTexture(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;
+
+    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),
+                                            float(dstrect.GetWidth()), float(dstrect.GetHeight()));
+
+  D3D::stateman->UnsetTexture(m_texture->GetSRV());
+  D3D::stateman->Apply();
+
+  D3D::context->OMSetRenderTargets(1, &m_texture->GetRTV(), nullptr);
+  D3D::context->RSSetViewports(1, &vp);
+  D3D::SetLinearCopySampler();
+  D3D11_RECT srcRC;
+  srcRC.left = srcrect.left;
+  srcRC.right = srcrect.right;
+  srcRC.top = srcrect.top;
+  srcRC.bottom = srcrect.bottom;
+  D3D::drawShadedTexQuad(srcentry->m_texture->GetSRV(), &srcRC, srcentry->m_config.width,
+                         srcentry->m_config.height, PixelShaderCache::GetColorCopyProgram(false),
+                         VertexShaderCache::GetSimpleVertexShader(),
+                         VertexShaderCache::GetSimpleInputLayout(),
+                         GeometryShaderCache::GetCopyGeometryShader(), 1.0, 0);
+
+  D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
+                                   FramebufferManager::GetEFBDepthTexture()->GetDSV());
+
+  g_renderer->RestoreAPIState();
+}
+
+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);
+  D3D::context->UpdateSubresource(m_texture->GetTex(), level, nullptr, buffer,
+                                  static_cast<UINT>(src_pitch), 0);
+}
+}  // namespace DX11

Source/Core/VideoBackends/D3D/DXTexture.h

@@ -0,0 +1,37 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "Common/CommonTypes.h"
+
+#include "VideoCommon/AbstractTexture.h"
+#include "VideoCommon/VideoCommon.h"
+
+class D3DTexture2D;
+
+namespace DX11
+{
+class DXTexture final : public AbstractTexture
+{
+public:
+  explicit DXTexture(const TextureConfig& tex_config);
+  ~DXTexture();
+
+  void Bind(unsigned int stage) override;
+  bool Save(const std::string& filename, unsigned int level) override;
+
+  void CopyRectangleFromTexture(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:
+  D3DTexture2D* m_texture;
+};
+
+}  // namespace DX11

Source/Core/VideoBackends/D3D/TextureCache.cpp

@@ -7,265 +7,35 @@
 #include <algorithm>
 #include <memory>
 
-#include "Common/Assert.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
 
 #include "VideoBackends/D3D/D3DBase.h"
 #include "VideoBackends/D3D/D3DShader.h"
 #include "VideoBackends/D3D/D3DState.h"
+#include "VideoBackends/D3D/D3DTexture.h"
 #include "VideoBackends/D3D/D3DUtil.h"
+#include "VideoBackends/D3D/DXTexture.h"
 #include "VideoBackends/D3D/FramebufferManager.h"
 #include "VideoBackends/D3D/GeometryShaderCache.h"
 #include "VideoBackends/D3D/PSTextureEncoder.h"
 #include "VideoBackends/D3D/PixelShaderCache.h"
 #include "VideoBackends/D3D/VertexShaderCache.h"
+
 #include "VideoCommon/ImageWrite.h"
 #include "VideoCommon/RenderBase.h"
+#include "VideoCommon/TextureConfig.h"
 #include "VideoCommon/VideoConfig.h"
 
 namespace DX11
 {
+static const size_t MAX_COPY_BUFFERS = 32;
+static ID3D11Buffer* s_efbcopycbuf[MAX_COPY_BUFFERS] = {0};
 static std::unique_ptr<PSTextureEncoder> g_encoder;
-const size_t MAX_COPY_BUFFERS = 32;
-ID3D11Buffer* efbcopycbuf[MAX_COPY_BUFFERS] = {0};
 
-static DXGI_FORMAT GetDXGIFormatForHostFormat(HostTextureFormat format)
+std::unique_ptr<AbstractTexture> TextureCache::CreateTexture(const TextureConfig& config)
 {
-  switch (format)
-  {
-  case HostTextureFormat::DXT1:
-    return DXGI_FORMAT_BC1_UNORM;
-
-  case HostTextureFormat::DXT3:
-    return DXGI_FORMAT_BC2_UNORM;
-
-  case HostTextureFormat::DXT5:
-    return DXGI_FORMAT_BC3_UNORM;
-
-  case HostTextureFormat::RGBA8:
-  default:
-    return DXGI_FORMAT_R8G8B8A8_UNORM;
-  }
-}
-
-TextureCache::TCacheEntry::~TCacheEntry()
-{
-  texture->Release();
-}
-
-void TextureCache::TCacheEntry::Bind(unsigned int stage)
-{
-  D3D::stateman->SetTexture(stage, texture->GetSRV());
-}
-
-bool TextureCache::TCacheEntry::Save(const std::string& filename, unsigned int level)
-{
-  // We can't dump compressed textures currently (it would mean drawing them to a RGBA8
-  // framebuffer, and saving that). TextureCache does not call Save for custom textures
-  // anyway, so this is fine for now.
-  _assert_(config.format == HostTextureFormat::RGBA8);
-
-  // Create a staging/readback texture with the dimensions of the specified mip level.
-  u32 mip_width = std::max(config.width >> level, 1u);
-  u32 mip_height = std::max(config.height >> level, 1u);
-  CD3D11_TEXTURE2D_DESC staging_texture_desc(DXGI_FORMAT_R8G8B8A8_UNORM, mip_width, mip_height, 1,
-                                             1, 0, D3D11_USAGE_STAGING, D3D11_CPU_ACCESS_READ);
-
-  ID3D11Texture2D* staging_texture;
-  HRESULT hr = D3D::device->CreateTexture2D(&staging_texture_desc, nullptr, &staging_texture);
-  if (FAILED(hr))
-  {
-    WARN_LOG(VIDEO, "Failed to create texture dumping readback texture: %X", static_cast<u32>(hr));
-    return false;
-  }
-
-  // Copy the selected mip level to the staging texture.
-  CD3D11_BOX src_box(0, 0, 0, mip_width, mip_height, 1);
-  D3D::context->CopySubresourceRegion(staging_texture, 0, 0, 0, 0, texture->GetTex(),
-                                      D3D11CalcSubresource(level, 0, 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(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));
-    staging_texture->Release();
-    return false;
-  }
-
-  bool encode_result =
-      TextureToPng(reinterpret_cast<u8*>(map.pData), map.RowPitch, filename, mip_width, mip_height);
-  D3D::context->Unmap(staging_texture, 0);
-  staging_texture->Release();
-
-  return encode_result;
-}
-
-void TextureCache::TCacheEntry::CopyRectangleFromTexture(const TCacheEntryBase* source,
-                                                         const MathUtil::Rectangle<int>& srcrect,
-                                                         const MathUtil::Rectangle<int>& dstrect)
-{
-  TCacheEntry* srcentry = (TCacheEntry*)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->config.layers;
-
-    D3D::context->CopySubresourceRegion(texture->GetTex(), 0, dstrect.left, dstrect.top, 0,
-                                        srcentry->texture->GetTex(), 0, &srcbox);
-    return;
-  }
-  else if (!config.rendertarget)
-  {
-    return;
-  }
-  g_renderer->ResetAPIState();  // reset any game specific settings
-
-  const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(float(dstrect.left), float(dstrect.top),
-                                            float(dstrect.GetWidth()), float(dstrect.GetHeight()));
-
-  D3D::stateman->UnsetTexture(texture->GetSRV());
-  D3D::stateman->Apply();
-
-  D3D::context->OMSetRenderTargets(1, &texture->GetRTV(), nullptr);
-  D3D::context->RSSetViewports(1, &vp);
-  D3D::SetLinearCopySampler();
-  D3D11_RECT srcRC;
-  srcRC.left = srcrect.left;
-  srcRC.right = srcrect.right;
-  srcRC.top = srcrect.top;
-  srcRC.bottom = srcrect.bottom;
-  D3D::drawShadedTexQuad(srcentry->texture->GetSRV(), &srcRC, srcentry->config.width,
-                         srcentry->config.height, PixelShaderCache::GetColorCopyProgram(false),
-                         VertexShaderCache::GetSimpleVertexShader(),
-                         VertexShaderCache::GetSimpleInputLayout(),
-                         GeometryShaderCache::GetCopyGeometryShader(), 1.0, 0);
-
-  D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
-                                   FramebufferManager::GetEFBDepthTexture()->GetDSV());
-
-  g_renderer->RestoreAPIState();
-}
-
-void TextureCache::TCacheEntry::Load(u32 level, u32 width, u32 height, u32 row_length,
-                                     const u8* buffer, size_t buffer_size)
-{
-  size_t src_pitch = CalculateHostTextureLevelPitch(config.format, row_length);
-  D3D::context->UpdateSubresource(texture->GetTex(), level, nullptr, buffer,
-                                  static_cast<UINT>(src_pitch), 0);
-}
-
-TextureCacheBase::TCacheEntryBase* TextureCache::CreateTexture(const TCacheEntryConfig& config)
-{
-  DXGI_FORMAT dxgi_format = GetDXGIFormatForHostFormat(config.format);
-  if (config.rendertarget)
-  {
-    return new TCacheEntry(
-        config, D3DTexture2D::Create(config.width, config.height,
-                                     (D3D11_BIND_FLAG)((int)D3D11_BIND_RENDER_TARGET |
-                                                       (int)D3D11_BIND_SHADER_RESOURCE),
-                                     D3D11_USAGE_DEFAULT, dxgi_format, 1, config.layers));
-  }
-  else
-  {
-    const D3D11_TEXTURE2D_DESC texdesc =
-        CD3D11_TEXTURE2D_DESC(dxgi_format, config.width, config.height, 1, config.levels,
-                              D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_DEFAULT, 0);
-
-    ID3D11Texture2D* pTexture;
-    const HRESULT hr = D3D::device->CreateTexture2D(&texdesc, nullptr, &pTexture);
-    CHECK(SUCCEEDED(hr), "Create texture of the TextureCache");
-
-    TCacheEntry* const entry =
-        new TCacheEntry(config, new D3DTexture2D(pTexture, D3D11_BIND_SHADER_RESOURCE));
-
-    // TODO: better debug names
-    D3D::SetDebugObjectName((ID3D11DeviceChild*)entry->texture->GetTex(),
-                            "a texture of the TextureCache");
-    D3D::SetDebugObjectName((ID3D11DeviceChild*)entry->texture->GetSRV(),
-                            "shader resource view of a texture of the TextureCache");
-
-    SAFE_RELEASE(pTexture);
-
-    return entry;
-  }
-}
-
-void TextureCache::TCacheEntry::FromRenderTarget(bool is_depth_copy, const EFBRectangle& srcRect,
-                                                 bool scaleByHalf, unsigned int cbufid,
-                                                 const float* colmat)
-{
-  // When copying at half size, in multisampled mode, resolve the color/depth buffer first.
-  // This is because multisampled texture reads go through Load, not Sample, and the linear
-  // filter is ignored.
-  bool multisampled = (g_ActiveConfig.iMultisamples > 1);
-  ID3D11ShaderResourceView* efbTexSRV = is_depth_copy ?
-                                            FramebufferManager::GetEFBDepthTexture()->GetSRV() :
-                                            FramebufferManager::GetEFBColorTexture()->GetSRV();
-  if (multisampled && scaleByHalf)
-  {
-    multisampled = false;
-    efbTexSRV = is_depth_copy ? FramebufferManager::GetResolvedEFBDepthTexture()->GetSRV() :
-                                FramebufferManager::GetResolvedEFBColorTexture()->GetSRV();
-  }
-
-  g_renderer->ResetAPIState();
-
-  // stretch picture with increased internal resolution
-  const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)config.width, (float)config.height);
-  D3D::context->RSSetViewports(1, &vp);
-
-  // set transformation
-  if (nullptr == efbcopycbuf[cbufid])
-  {
-    const D3D11_BUFFER_DESC cbdesc =
-        CD3D11_BUFFER_DESC(28 * sizeof(float), D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DEFAULT);
-    D3D11_SUBRESOURCE_DATA data;
-    data.pSysMem = colmat;
-    HRESULT hr = D3D::device->CreateBuffer(&cbdesc, &data, &efbcopycbuf[cbufid]);
-    CHECK(SUCCEEDED(hr), "Create efb copy constant buffer %d", cbufid);
-    D3D::SetDebugObjectName((ID3D11DeviceChild*)efbcopycbuf[cbufid],
-                            "a constant buffer used in TextureCache::CopyRenderTargetToTexture");
-  }
-  D3D::stateman->SetPixelConstants(efbcopycbuf[cbufid]);
-
-  const TargetRectangle targetSource = g_renderer->ConvertEFBRectangle(srcRect);
-  // TODO: try targetSource.asRECT();
-  const D3D11_RECT sourcerect =
-      CD3D11_RECT(targetSource.left, targetSource.top, targetSource.right, targetSource.bottom);
-
-  // Use linear filtering if (bScaleByHalf), use point filtering otherwise
-  if (scaleByHalf)
-    D3D::SetLinearCopySampler();
-  else
-    D3D::SetPointCopySampler();
-
-  // Make sure we don't draw with the texture set as both a source and target.
-  // (This can happen because we don't unbind textures when we free them.)
-  D3D::stateman->UnsetTexture(texture->GetSRV());
-  D3D::stateman->Apply();
-
-  D3D::context->OMSetRenderTargets(1, &texture->GetRTV(), nullptr);
-
-  // Create texture copy
-  D3D::drawShadedTexQuad(
-      efbTexSRV, &sourcerect, g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(),
-      is_depth_copy ? PixelShaderCache::GetDepthMatrixProgram(multisampled) :
-                      PixelShaderCache::GetColorMatrixProgram(multisampled),
-      VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout(),
-      GeometryShaderCache::GetCopyGeometryShader());
-
-  D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
-                                   FramebufferManager::GetEFBDepthTexture()->GetDSV());
-
-  g_renderer->RestoreAPIState();
+  return std::make_unique<DXTexture>(config);
 }
 
 void TextureCache::CopyEFB(u8* dst, const EFBCopyFormat& format, u32 native_width,
@@ -356,14 +126,16 @@ void main(
 }
 )HLSL";
 
-void TextureCache::ConvertTexture(TCacheEntryBase* entry, TCacheEntryBase* unconverted,
-                                  void* palette, TlutFormat format)
+void TextureCache::ConvertTexture(TCacheEntry* destination, TCacheEntry* source, void* palette,
+                                  TlutFormat format)
 {
+  DXTexture* source_texture = static_cast<DXTexture*>(source->texture.get());
+  DXTexture* destination_texture = static_cast<DXTexture*>(destination->texture.get());
   g_renderer->ResetAPIState();
 
   // stretch picture with increased internal resolution
-  const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, (float)unconverted->config.width,
-                                            (float)unconverted->config.height);
+  const D3D11_VIEWPORT vp = CD3D11_VIEWPORT(0.f, 0.f, static_cast<float>(source->GetWidth()),
+                                            static_cast<float>(source->GetHeight()));
   D3D::context->RSSetViewports(1, &vp);
 
   D3D11_BOX box{0, 0, 0, 512, 1, 1};
@@ -372,29 +144,27 @@ void TextureCache::ConvertTexture(TCacheEntryBase* entry, TCacheEntryBase* uncon
   D3D::stateman->SetTexture(1, palette_buf_srv);
 
   // TODO: Add support for C14X2 format.  (Different multiplier, more palette entries.)
-  float params[4] = {(unconverted->format & 0xf) == GX_TF_I4 ? 15.f : 255.f};
+  float params[4] = {(source->format & 0xf) == GX_TF_I4 ? 15.f : 255.f};
   D3D::context->UpdateSubresource(palette_uniform, 0, nullptr, &params, 0, 0);
   D3D::stateman->SetPixelConstants(palette_uniform);
 
-  const D3D11_RECT sourcerect =
-      CD3D11_RECT(0, 0, unconverted->config.width, unconverted->config.height);
+  const D3D11_RECT sourcerect = CD3D11_RECT(0, 0, source->GetWidth(), source->GetHeight());
 
   D3D::SetPointCopySampler();
 
   // Make sure we don't draw with the texture set as both a source and target.
   // (This can happen because we don't unbind textures when we free them.)
-  D3D::stateman->UnsetTexture(static_cast<TCacheEntry*>(entry)->texture->GetSRV());
+  D3D::stateman->UnsetTexture(destination_texture->GetRawTexIdentifier()->GetSRV());
   D3D::stateman->Apply();
 
-  D3D::context->OMSetRenderTargets(1, &static_cast<TCacheEntry*>(entry)->texture->GetRTV(),
+  D3D::context->OMSetRenderTargets(1, &destination_texture->GetRawTexIdentifier()->GetRTV(),
                                    nullptr);
 
   // Create texture copy
-  D3D::drawShadedTexQuad(static_cast<TCacheEntry*>(unconverted)->texture->GetSRV(), &sourcerect,
-                         unconverted->config.width, unconverted->config.height,
-                         palette_pixel_shader[format], VertexShaderCache::GetSimpleVertexShader(),
-                         VertexShaderCache::GetSimpleInputLayout(),
-                         GeometryShaderCache::GetCopyGeometryShader());
+  D3D::drawShadedTexQuad(
+      source_texture->GetRawTexIdentifier()->GetSRV(), &sourcerect, source->GetWidth(),
+      source->GetHeight(), palette_pixel_shader[format], VertexShaderCache::GetSimpleVertexShader(),
+      VertexShaderCache::GetSimpleInputLayout(), GeometryShaderCache::GetCopyGeometryShader());
 
   D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
                                    FramebufferManager::GetEFBDepthTexture()->GetDSV());
@@ -444,7 +214,7 @@ TextureCache::TextureCache()
 TextureCache::~TextureCache()
 {
   for (unsigned int k = 0; k < MAX_COPY_BUFFERS; ++k)
-    SAFE_RELEASE(efbcopycbuf[k]);
+    SAFE_RELEASE(s_efbcopycbuf[k]);
 
   g_encoder->Shutdown();
   g_encoder.reset();
@@ -455,4 +225,79 @@ TextureCache::~TextureCache()
   for (ID3D11PixelShader*& shader : palette_pixel_shader)
     SAFE_RELEASE(shader);
 }
+
+void TextureCache::CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy,
+                                       const EFBRectangle& src_rect, bool scale_by_half,
+                                       unsigned int cbuf_id, const float* colmat)
+{
+  auto* destination_texture = static_cast<DXTexture*>(entry->texture.get());
+
+  // When copying at half size, in multisampled mode, resolve the color/depth buffer first.
+  // This is because multisampled texture reads go through Load, not Sample, and the linear
+  // filter is ignored.
+  bool multisampled = (g_ActiveConfig.iMultisamples > 1);
+  ID3D11ShaderResourceView* efbTexSRV = is_depth_copy ?
+                                            FramebufferManager::GetEFBDepthTexture()->GetSRV() :
+                                            FramebufferManager::GetEFBColorTexture()->GetSRV();
+  if (multisampled && scale_by_half)
+  {
+    multisampled = false;
+    efbTexSRV = is_depth_copy ? FramebufferManager::GetResolvedEFBDepthTexture()->GetSRV() :
+                                FramebufferManager::GetResolvedEFBColorTexture()->GetSRV();
+  }
+
+  g_renderer->ResetAPIState();
+
+  // stretch picture with increased internal resolution
+  const D3D11_VIEWPORT vp =
+      CD3D11_VIEWPORT(0.f, 0.f, static_cast<float>(destination_texture->GetConfig().width),
+                      static_cast<float>(destination_texture->GetConfig().height));
+  D3D::context->RSSetViewports(1, &vp);
+
+  // set transformation
+  if (nullptr == s_efbcopycbuf[cbuf_id])
+  {
+    const D3D11_BUFFER_DESC cbdesc =
+        CD3D11_BUFFER_DESC(28 * sizeof(float), D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DEFAULT);
+    D3D11_SUBRESOURCE_DATA data;
+    data.pSysMem = colmat;
+    HRESULT hr = D3D::device->CreateBuffer(&cbdesc, &data, &s_efbcopycbuf[cbuf_id]);
+    CHECK(SUCCEEDED(hr), "Create efb copy constant buffer %d", cbuf_id);
+    D3D::SetDebugObjectName((ID3D11DeviceChild*)s_efbcopycbuf[cbuf_id],
+                            "a constant buffer used in TextureCache::CopyRenderTargetToTexture");
+  }
+  D3D::stateman->SetPixelConstants(s_efbcopycbuf[cbuf_id]);
+
+  const TargetRectangle targetSource = g_renderer->ConvertEFBRectangle(src_rect);
+  // TODO: try targetSource.asRECT();
+  const D3D11_RECT sourcerect =
+      CD3D11_RECT(targetSource.left, targetSource.top, targetSource.right, targetSource.bottom);
+
+  // Use linear filtering if (bScaleByHalf), use point filtering otherwise
+  if (scale_by_half)
+    D3D::SetLinearCopySampler();
+  else
+    D3D::SetPointCopySampler();
+
+  // Make sure we don't draw with the texture set as both a source and target.
+  // (This can happen because we don't unbind textures when we free them.)
+  D3D::stateman->UnsetTexture(destination_texture->GetRawTexIdentifier()->GetSRV());
+  D3D::stateman->Apply();
+
+  D3D::context->OMSetRenderTargets(1, &destination_texture->GetRawTexIdentifier()->GetRTV(),
+                                   nullptr);
+
+  // Create texture copy
+  D3D::drawShadedTexQuad(
+      efbTexSRV, &sourcerect, g_renderer->GetTargetWidth(), g_renderer->GetTargetHeight(),
+      is_depth_copy ? PixelShaderCache::GetDepthMatrixProgram(multisampled) :
+                      PixelShaderCache::GetColorMatrixProgram(multisampled),
+      VertexShaderCache::GetSimpleVertexShader(), VertexShaderCache::GetSimpleInputLayout(),
+      GeometryShaderCache::GetCopyGeometryShader());
+
+  D3D::context->OMSetRenderTargets(1, &FramebufferManager::GetEFBColorTexture()->GetRTV(),
+                                   FramebufferManager::GetEFBDepthTexture()->GetDSV());
+
+  g_renderer->RestoreAPIState();
+}
 }

Source/Core/VideoBackends/D3D/TextureCache.h

@@ -7,6 +7,9 @@
 #include "VideoBackends/D3D/D3DTexture.h"
 #include "VideoCommon/TextureCacheBase.h"
 
+class AbstractTexture;
+struct TextureConfig;
+
 namespace DX11
 {
 class TextureCache : public TextureCacheBase
@@ -16,31 +19,7 @@ public:
   ~TextureCache();
 
 private:
-  struct TCacheEntry : TCacheEntryBase
-  {
-    D3DTexture2D* const texture;
-
-    TCacheEntry(const TCacheEntryConfig& config, D3DTexture2D* _tex)
-        : TCacheEntryBase(config), texture(_tex)
-    {
-    }
-    ~TCacheEntry();
-
-    void CopyRectangleFromTexture(const TCacheEntryBase* 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;
-
-    void FromRenderTarget(bool is_depth_copy, const EFBRectangle& srcRect, bool scaleByHalf,
-                          unsigned int cbufid, const float* colmat) override;
-
-    void Bind(unsigned int stage) override;
-    bool Save(const std::string& filename, unsigned int level) override;
-  };
-
-  TCacheEntryBase* CreateTexture(const TCacheEntryConfig& config) override;
+  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,
@@ -49,13 +28,16 @@ private:
     return 0;
   };
 
-  void ConvertTexture(TCacheEntryBase* entry, TCacheEntryBase* unconverted, void* palette,
+  void ConvertTexture(TCacheEntry* destination, TCacheEntry* source, void* palette,
                       TlutFormat format) override;
 
   void CopyEFB(u8* dst, const EFBCopyFormat& format, u32 native_width, u32 bytes_per_row,
                u32 num_blocks_y, u32 memory_stride, bool is_depth_copy,
                const EFBRectangle& src_rect, bool scale_by_half) override;
 
+  void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
+                           bool scale_by_half, unsigned int cbuf_id, const float* colmat) override;
+
   bool CompileShaders() override { return true; }
   void DeleteShaders() override {}
   ID3D11Buffer* palette_buf;

Source/Core/VideoBackends/Null/CMakeLists.txt

@@ -1,5 +1,6 @@
 set(SRCS
   NullBackend.cpp
+  NullTexture.cpp
   Render.cpp
   VertexManager.cpp
   ShaderCache.cpp

Source/Core/VideoBackends/Null/Null.vcxproj

@@ -37,12 +37,14 @@
   <PropertyGroup Label="UserMacros" />
   <ItemGroup>
     <ClCompile Include="NullBackend.cpp" />
+    <ClCompile Include="NullTexture.cpp" />
     <ClCompile Include="Render.cpp" />
     <ClCompile Include="ShaderCache.cpp" />
     <ClCompile Include="VertexManager.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="FramebufferManager.h" />
+    <ClInclude Include="NullTexture.h" />
     <ClInclude Include="PerfQuery.h" />
     <ClInclude Include="Render.h" />
     <ClInclude Include="ShaderCache.h" />

Source/Core/VideoBackends/Null/NullTexture.cpp

@@ -0,0 +1,28 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "VideoBackends/Null/NullTexture.h"
+
+namespace Null
+{
+NullTexture::NullTexture(const TextureConfig& tex_config) : AbstractTexture(tex_config)
+{
+}
+
+void NullTexture::Bind(unsigned int stage)
+{
+}
+
+void NullTexture::CopyRectangleFromTexture(const AbstractTexture* source,
+                                           const MathUtil::Rectangle<int>& srcrect,
+                                           const MathUtil::Rectangle<int>& dstrect)
+{
+}
+
+void NullTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
+                       size_t buffer_size)
+{
+}
+
+}  // namespace Null

Source/Core/VideoBackends/Null/NullTexture.h

@@ -0,0 +1,29 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "Common/CommonTypes.h"
+
+#include "VideoCommon/AbstractTexture.h"
+#include "VideoCommon/VideoCommon.h"
+
+namespace Null
+{
+class NullTexture final : public AbstractTexture
+{
+public:
+  explicit NullTexture(const TextureConfig& config);
+  ~NullTexture() = default;
+
+  void Bind(unsigned int stage) override;
+
+  void CopyRectangleFromTexture(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;
+};
+
+}  // namespace Null

Source/Core/VideoBackends/Null/TextureCache.h

@@ -4,7 +4,12 @@
 
 #pragma once
 
+#include <memory>
+
+#include "VideoBackends/Null/NullTexture.h"
+
 #include "VideoCommon/TextureCacheBase.h"
+#include "VideoCommon/TextureConfig.h"
 
 namespace Null
 {
@@ -15,7 +20,7 @@ public:
   ~TextureCache() {}
   bool CompileShaders() override { return true; }
   void DeleteShaders() override {}
-  void ConvertTexture(TCacheEntryBase* entry, TCacheEntryBase* unconverted, void* palette,
+  void ConvertTexture(TCacheEntry* entry, TCacheEntry* unconverted, void* palette,
                       TlutFormat format) override
   {
   }
@@ -26,33 +31,15 @@ public:
   {
   }
 
+  void CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_copy, const EFBRectangle& src_rect,
+                           bool scale_by_half, unsigned int cbuf_id, const float* colmat) override
+  {
+  }
+
 private:
-  struct TCacheEntry : TCacheEntryBase
+  std::unique_ptr<AbstractTexture> CreateTexture(const TextureConfig& config) override
   {
-    TCacheEntry(const TCacheEntryConfig& _config) : TCacheEntryBase(_config) {}
-    ~TCacheEntry() {}
-    void Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
-              size_t buffer_size) override
-    {
-    }
-    void FromRenderTarget(bool is_depth_copy, const EFBRectangle& src_rect, bool scale_by_half,
-                          unsigned int cbufid, const float* colmat) override
-    {
-    }
-
-    void CopyRectangleFromTexture(const TCacheEntryBase* source,
-                                  const MathUtil::Rectangle<int>& srcrect,
-                                  const MathUtil::Rectangle<int>& dstrect) override
-    {
-    }
-
-    void Bind(unsigned int stage) override {}
-    bool Save(const std::string& filename, unsigned int level) override { return false; }
-  };
-
-  TCacheEntryBase* CreateTexture(const TCacheEntryConfig& config) override
-  {
-    return new TCacheEntry(config);
+    return std::make_unique<NullTexture>(config);
   }
 };
 

Source/Core/VideoBackends/OGL/CMakeLists.txt

@@ -3,6 +3,7 @@ set(SRCS
   FramebufferManager.cpp
   main.cpp
   NativeVertexFormat.cpp
+  OGLTexture.cpp
   PerfQuery.cpp
   PostProcessing.cpp
   ProgramShaderCache.cpp

Source/Core/VideoBackends/OGL/OGL.vcxproj

@@ -36,6 +36,7 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <ItemGroup>
+    <ClCompile Include="OGLTexture.cpp" />
     <ClCompile Include="BoundingBox.cpp" />
     <ClCompile Include="FramebufferManager.cpp" />
     <ClCompile Include="main.cpp" />
@@ -52,6 +53,7 @@
     <ClCompile Include="VertexManager.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="OGLTexture.h" />
     <ClInclude Include="BoundingBox.h" />
     <ClInclude Include="FramebufferManager.h" />
     <ClInclude Include="GPUTimer.h" />

Source/Core/VideoBackends/OGL/OGL.vcxproj.filters

@@ -53,6 +53,9 @@
     </ClCompile>
     <ClCompile Include="main.cpp" />
     <ClCompile Include="SamplerCache.cpp" />
+    <ClCompile Include="OGLTexture.cpp">
+      <Filter>Render</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="VertexManager.h">
@@ -93,6 +96,9 @@
     <ClInclude Include="GPUTimer.h">
       <Filter>GLUtil</Filter>
     </ClInclude>
+    <ClInclude Include="OGLTexture.h">
+      <Filter>Render</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Text Include="CMakeLists.txt" />

Source/Core/VideoBackends/OGL/OGLTexture.cpp

@@ -0,0 +1,274 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "Common/Assert.h"
+#include "Common/CommonTypes.h"
+#include "Common/GL/GLInterfaceBase.h"
+#include "Common/MsgHandler.h"
+
+#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"
+
+#include "VideoCommon/ImageWrite.h"
+#include "VideoCommon/TextureConfig.h"
+
+namespace OGL
+{
+namespace
+{
+std::array<u32, 8> s_Textures;
+u32 s_ActiveTexture;
+
+GLenum GetGLInternalFormatForTextureFormat(AbstractTextureFormat format, bool storage)
+{
+  switch (format)
+  {
+  case AbstractTextureFormat::DXT1:
+    return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+  case AbstractTextureFormat::DXT3:
+    return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+  case AbstractTextureFormat::DXT5:
+    return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+  case AbstractTextureFormat::RGBA8:
+  default:
+    return storage ? GL_RGBA8 : GL_RGBA;
+  }
+}
+
+GLenum GetGLFormatForTextureFormat(AbstractTextureFormat format)
+{
+  switch (format)
+  {
+  case AbstractTextureFormat::RGBA8:
+    return GL_RGBA;
+  // Compressed texture formats don't use this parameter.
+  default:
+    return GL_UNSIGNED_BYTE;
+  }
+}
+
+GLenum GetGLTypeForTextureFormat(AbstractTextureFormat format)
+{
+  switch (format)
+  {
+  case AbstractTextureFormat::RGBA8:
+    return GL_UNSIGNED_BYTE;
+  // Compressed texture formats don't use this parameter.
+  default:
+    return GL_UNSIGNED_BYTE;
+  }
+}
+}  // Anonymous namespace
+
+bool SaveTexture(const std::string& filename, u32 textarget, u32 tex, int virtual_width,
+                 int virtual_height, unsigned int level)
+{
+  if (GLInterface->GetMode() != GLInterfaceMode::MODE_OPENGL)
+    return false;
+  int width = std::max(virtual_width >> level, 1);
+  int height = std::max(virtual_height >> level, 1);
+  std::vector<u8> data(width * height * 4);
+  glActiveTexture(GL_TEXTURE9);
+  glBindTexture(textarget, tex);
+  glGetTexImage(textarget, level, GL_RGBA, GL_UNSIGNED_BYTE, data.data());
+  OGLTexture::SetStage();
+
+  return TextureToPng(data.data(), width * 4, filename, width, height, true);
+}
+
+OGLTexture::OGLTexture(const TextureConfig& tex_config) : AbstractTexture(tex_config)
+{
+  glGenTextures(1, &m_texId);
+
+  glActiveTexture(GL_TEXTURE9);
+  glBindTexture(GL_TEXTURE_2D_ARRAY, m_texId);
+
+  glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, m_config.levels - 1);
+
+  if (g_ogl_config.bSupportsTextureStorage)
+  {
+    GLenum gl_internal_format = GetGLInternalFormatForTextureFormat(m_config.format, true);
+    glTexStorage3D(GL_TEXTURE_2D_ARRAY, m_config.levels, gl_internal_format, m_config.width,
+                   m_config.height, m_config.layers);
+  }
+
+  if (m_config.rendertarget)
+  {
+    // We can't render to compressed formats.
+    _assert_(!IsCompressedHostTextureFormat(m_config.format));
+
+    if (!g_ogl_config.bSupportsTextureStorage)
+    {
+      for (u32 level = 0; level < m_config.levels; level++)
+      {
+        glTexImage3D(GL_TEXTURE_2D_ARRAY, level, GL_RGBA, std::max(m_config.width >> level, 1u),
+                     std::max(m_config.height >> level, 1u), m_config.layers, 0, GL_RGBA,
+                     GL_UNSIGNED_BYTE, nullptr);
+      }
+    }
+    glGenFramebuffers(1, &m_framebuffer);
+    FramebufferManager::SetFramebuffer(m_framebuffer);
+    FramebufferManager::FramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                           GL_TEXTURE_2D_ARRAY, m_texId, 0);
+  }
+
+  SetStage();
+}
+
+OGLTexture::~OGLTexture()
+{
+  if (m_texId)
+  {
+    for (auto& gtex : s_Textures)
+      if (gtex == m_texId)
+        gtex = 0;
+    glDeleteTextures(1, &m_texId);
+    m_texId = 0;
+  }
+
+  if (m_framebuffer)
+  {
+    glDeleteFramebuffers(1, &m_framebuffer);
+    m_framebuffer = 0;
+  }
+}
+
+GLuint OGLTexture::GetRawTexIdentifier() const
+{
+  return m_texId;
+}
+
+GLuint OGLTexture::GetFramebuffer() const
+{
+  return m_framebuffer;
+}
+
+void OGLTexture::Bind(unsigned int stage)
+{
+  if (s_Textures[stage] != m_texId)
+  {
+    if (s_ActiveTexture != stage)
+    {
+      glActiveTexture(GL_TEXTURE0 + stage);
+      s_ActiveTexture = stage;
+    }
+
+    glBindTexture(GL_TEXTURE_2D_ARRAY, m_texId);
+    s_Textures[stage] = m_texId;
+  }
+}
+
+bool OGLTexture::Save(const std::string& filename, unsigned int level)
+{
+  // We can't dump compressed textures currently (it would mean drawing them to a RGBA8
+  // framebuffer, and saving that). TextureCache does not call Save for custom textures
+  // anyway, so this is fine for now.
+  _assert_(m_config.format == AbstractTextureFormat::RGBA8);
+
+  return SaveTexture(filename, GL_TEXTURE_2D_ARRAY, m_texId, m_config.width, m_config.height,
+                     level);
+}
+
+void OGLTexture::CopyRectangleFromTexture(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)
+  {
+    glGenFramebuffers(1, &m_framebuffer);
+    FramebufferManager::SetFramebuffer(m_framebuffer);
+    FramebufferManager::FramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                           GL_TEXTURE_2D_ARRAY, m_texId, 0);
+  }
+  g_renderer->ResetAPIState();
+  FramebufferManager::SetFramebuffer(m_framebuffer);
+  glActiveTexture(GL_TEXTURE9);
+  glBindTexture(GL_TEXTURE_2D_ARRAY, srcentry->m_texId);
+  g_sampler_cache->BindLinearSampler(9);
+  glViewport(dstrect.left, dstrect.top, dstrect.GetWidth(), dstrect.GetHeight());
+  TextureCache::GetInstance()->GetColorCopyProgram().Bind();
+  glUniform4f(TextureCache::GetInstance()->GetColorCopyPositionUniform(), float(srcrect.left),
+              float(srcrect.top), float(srcrect.GetWidth()), float(srcrect.GetHeight()));
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  FramebufferManager::SetFramebuffer(0);
+  g_renderer->RestoreAPIState();
+}
+
+void OGLTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u8* buffer,
+                      size_t buffer_size)
+{
+  if (level >= m_config.levels)
+    PanicAlert("Texture only has %d levels, can't update level %d", m_config.levels, level);
+  if (width != std::max(1u, m_config.width >> level) ||
+      height != std::max(1u, m_config.height >> level))
+    PanicAlert("size of level %d must be %dx%d, but %dx%d requested", level,
+               std::max(1u, m_config.width >> level), std::max(1u, m_config.height >> level), width,
+               height);
+
+  glActiveTexture(GL_TEXTURE9);
+  glBindTexture(GL_TEXTURE_2D_ARRAY, m_texId);
+
+  if (row_length != width)
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, row_length);
+
+  GLenum gl_internal_format = GetGLInternalFormatForTextureFormat(m_config.format, false);
+  if (IsCompressedHostTextureFormat(m_config.format))
+  {
+    if (g_ogl_config.bSupportsTextureStorage)
+    {
+      glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, level, 0, 0, 0, width, height, 1,
+                                gl_internal_format, static_cast<GLsizei>(buffer_size), buffer);
+    }
+    else
+    {
+      glCompressedTexImage3D(GL_TEXTURE_2D_ARRAY, level, gl_internal_format, width, height, 1, 0,
+                             static_cast<GLsizei>(buffer_size), buffer);
+    }
+  }
+  else
+  {
+    GLenum gl_format = GetGLFormatForTextureFormat(m_config.format);
+    GLenum gl_type = GetGLTypeForTextureFormat(m_config.format);
+    if (g_ogl_config.bSupportsTextureStorage)
+    {
+      glTexSubImage3D(GL_TEXTURE_2D_ARRAY, level, 0, 0, 0, width, height, 1, gl_format, gl_type,
+                      buffer);
+    }
+    else
+    {
+      glTexImage3D(GL_TEXTURE_2D_ARRAY, level, gl_internal_format, width, height, 1, 0, gl_format,
+                   gl_type, buffer);
+    }
+  }
+
+  if (row_length != width)
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+
+  SetStage();
+}
+
+void OGLTexture::DisableStage(unsigned int stage)
+{
+}
+
+void OGLTexture::SetStage()
+{
+  // -1 is the initial value as we don't know which texture should be bound
+  if (s_ActiveTexture != (u32)-1)
+    glActiveTexture(GL_TEXTURE0 + s_ActiveTexture);
+}
+
+}  // namespace OGL

Source/Core/VideoBackends/OGL/OGLTexture.h

@@ -0,0 +1,40 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "Common/GL/GLUtil.h"
+
+#include "VideoCommon/AbstractTexture.h"
+#include "VideoCommon/VideoCommon.h"
+
+namespace OGL
+{
+class OGLTexture final : public AbstractTexture
+{
+public:
+  explicit OGLTexture(const TextureConfig& tex_config);
+  ~OGLTexture();
+
+  void Bind(unsigned int stage) override;
+  bool Save(const std::string& filename, unsigned int level) override;
+
+  void CopyRectangleFromTexture(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;
+
+  GLuint GetRawTexIdentifier() const;
+  GLuint GetFramebuffer() const;
+
+  static void DisableStage(unsigned int stage);
+  static void SetStage();
+
+private:
+  GLuint m_texId;
+  GLuint m_framebuffer = 0;
+};
+
+}  // namespace OGL

Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp

@@ -138,7 +138,7 @@ void SHADER::SetProgramBindings(bool is_compute)
   }
 }
 
-void SHADER::Bind()
+void SHADER::Bind() const
 {
   if (CurrentProgram != glprogid)
   {

Source/Core/VideoBackends/OGL/ProgramShaderCache.h

@@ -47,7 +47,7 @@ struct SHADER
 
   void SetProgramVariables();
   void SetProgramBindings(bool is_compute);
-  void Bind();
+  void Bind() const;
 };
 
 class ProgramShaderCache

Source/Core/VideoBackends/OGL/Render.cpp

@@ -27,6 +27,7 @@
 
 #include "VideoBackends/OGL/BoundingBox.h"
 #include "VideoBackends/OGL/FramebufferManager.h"
+#include "VideoBackends/OGL/OGLTexture.h"
 #include "VideoBackends/OGL/PostProcessing.h"
 #include "VideoBackends/OGL/ProgramShaderCache.h"
 #include "VideoBackends/OGL/RasterFont.h"
@@ -1691,7 +1692,7 @@ void Renderer::PrepareFrameDumpRenderTexture(u32 width, u32 height)
 
   m_frame_dump_render_texture_width = width;
   m_frame_dump_render_texture_height = height;
-  TextureCache::SetStage();
+  OGLTexture::SetStage();
 }
 
 void Renderer::DestroyFrameDumpResources()
@@ -1744,7 +1745,7 @@ void Renderer::RestoreAPIState()
   if (vm->m_last_vao)
     glBindVertexArray(vm->m_last_vao);
 
-  TextureCache::SetStage();
+  OGLTexture::SetStage();
 }
 
 void Renderer::SetGenerationMode()