gl_texture_cache: Implement fermi copies

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -738,8 +738,9 @@ bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs
                                              const Common::Rectangle<u32>& src_rect,
                                              const Common::Rectangle<u32>& dst_rect) {
     MICROPROFILE_SCOPE(OpenGL_Blits);
-    UNIMPLEMENTED();
-    // texture_cache.FermiCopySurface(src, dst, src_rect, dst_rect);
+    const auto src_surface{texture_cache.GetFermiSurface(src)};
+    const auto dst_surface{texture_cache.GetFermiSurface(dst)};
+    blitter.Blit(src_surface, dst_surface, src_rect, dst_rect);
     return true;
 }
 

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -202,6 +202,7 @@ private:
     static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
     OGLBufferCache buffer_cache;
 
+    SurfaceBlitter blitter;
     BindBuffersRangePushBuffer bind_ubo_pushbuffer{GL_UNIFORM_BUFFER};
     BindBuffersRangePushBuffer bind_ssbo_pushbuffer{GL_SHADER_STORAGE_BUFFER};
 

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -13,6 +13,7 @@
 
 #include "common/common_types.h"
 #include "video_core/engines/shader_bytecode.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/texture_cache/texture_cache_contextless.h"
 
 namespace OpenGL {

src/video_core/renderer_opengl/utils.cpp

@@ -5,12 +5,21 @@
 #include <string>
 #include <fmt/format.h>
 #include <glad/glad.h>
+
 #include "common/assert.h"
 #include "common/common_types.h"
+#include "common/scope_exit.h"
+#include "video_core/renderer_opengl/gl_state.h"
+#include "video_core/renderer_opengl/gl_texture_cache.h"
 #include "video_core/renderer_opengl/utils.h"
+#include "video_core/surface.h"
 
 namespace OpenGL {
 
+using Tegra::Shader::TextureType;
+using Tegra::Texture::SwizzleSource;
+using VideoCore::Surface::SurfaceTarget;
+
 BindBuffersRangePushBuffer::BindBuffersRangePushBuffer(GLenum target) : target{target} {}
 
 BindBuffersRangePushBuffer::~BindBuffersRangePushBuffer() = default;
@@ -38,6 +47,80 @@ void BindBuffersRangePushBuffer::Bind() const {
                        sizes.data());
 }
 
+SurfaceBlitter::SurfaceBlitter() {
+    src_framebuffer.Create();
+    dst_framebuffer.Create();
+}
+
+SurfaceBlitter::~SurfaceBlitter() = default;
+
+void SurfaceBlitter::Blit(CachedSurfaceView* src, CachedSurfaceView* dst,
+                          const Common::Rectangle<u32>& src_rect,
+                          const Common::Rectangle<u32>& dst_rect) const {
+    const auto& src_params{src->GetSurfaceParams()};
+    const auto& dst_params{dst->GetSurfaceParams()};
+
+    OpenGLState prev_state{OpenGLState::GetCurState()};
+    SCOPE_EXIT({ prev_state.Apply(); });
+
+    OpenGLState state;
+    state.draw.read_framebuffer = src_framebuffer.handle;
+    state.draw.draw_framebuffer = dst_framebuffer.handle;
+    state.ApplyFramebufferState();
+
+    u32 buffers{};
+
+    UNIMPLEMENTED_IF(src_params.GetTarget() != SurfaceTarget::Texture2D);
+    UNIMPLEMENTED_IF(dst_params.GetTarget() != SurfaceTarget::Texture2D);
+
+    const auto GetTexture = [](CachedSurfaceView* view) {
+        return view->GetTexture(TextureType::Texture2D, false, SwizzleSource::R, SwizzleSource::G,
+                                SwizzleSource::B, SwizzleSource::A);
+    };
+    const GLuint src_texture{GetTexture(src)};
+    const GLuint dst_texture{GetTexture(dst)};
+
+    if (src_params.GetType() == SurfaceType::ColorTexture) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                               src_texture, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
+                               0);
+
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                               dst_texture, 0);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
+                               0);
+
+        buffers = GL_COLOR_BUFFER_BIT;
+    } else if (src_params.GetType() == SurfaceType::Depth) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, src_texture,
+                               0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, dst_texture,
+                               0);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+
+        buffers = GL_DEPTH_BUFFER_BIT;
+    } else if (src_params.GetType() == SurfaceType::DepthStencil) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                               src_texture, 0);
+
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                               dst_texture, 0);
+
+        buffers = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+    }
+
+    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, buffers,
+                      buffers == GL_COLOR_BUFFER_BIT ? GL_LINEAR : GL_NEAREST);
+}
+
 void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string_view extra_info) {
     if (!GLAD_GL_KHR_debug) {
         // We don't need to throw an error as this is just for debugging

src/video_core/renderer_opengl/utils.h

@@ -8,9 +8,13 @@
 #include <vector>
 #include <glad/glad.h>
 #include "common/common_types.h"
+#include "common/math_util.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
 
 namespace OpenGL {
 
+class CachedSurfaceView;
+
 class BindBuffersRangePushBuffer {
 public:
     BindBuffersRangePushBuffer(GLenum target);
@@ -30,6 +34,19 @@ private:
     std::vector<GLsizeiptr> sizes;
 };
 
+class SurfaceBlitter {
+public:
+    explicit SurfaceBlitter();
+    ~SurfaceBlitter();
+
+    void Blit(CachedSurfaceView* src, CachedSurfaceView* dst,
+              const Common::Rectangle<u32>& src_rect, const Common::Rectangle<u32>& dst_rect) const;
+
+private:
+    OGLFramebuffer src_framebuffer;
+    OGLFramebuffer dst_framebuffer;
+};
+
 void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr, std::string_view extra_info = {});
 
 } // namespace OpenGL