util_shaders: Unify BGRA copy passes

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -461,7 +461,7 @@ bool TextureCacheRuntime::CanImageBeCopied(const Image& dst, const Image& src) {
     if (dst.info.type == ImageType::e3D && dst.info.format == PixelFormat::BC4_UNORM) {
         return false;
     }
-    if (IsPixelFormatBGR(dst.info.format) || IsPixelFormatBGR(src.info.format)) {
+    if (IsPixelFormatBGR(dst.info.format) != IsPixelFormatBGR(src.info.format)) {
         return false;
     }
     return true;

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -162,6 +162,14 @@ public:
         return texture.handle;
     }
 
+    GLuint GlFormat() const noexcept {
+        return gl_format;
+    }
+
+    GLuint GlType() const noexcept {
+        return gl_type;
+    }
+
 private:
     void CopyBufferToImage(const VideoCommon::BufferImageCopy& copy, size_t buffer_offset);
 

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -52,7 +52,7 @@ constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> FORMAT_TAB
     {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT},                          // BC6H_UFLOAT
     {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT},                            // BC6H_SFLOAT
     {GL_COMPRESSED_RGBA_ASTC_4x4_KHR},                                // ASTC_2D_4X4_UNORM
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},                            // B8G8R8A8_UNORM
+    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},                 // B8G8R8A8_UNORM
     {GL_RGBA32F, GL_RGBA, GL_FLOAT},                                  // R32G32B32A32_FLOAT
     {GL_RGBA32I, GL_RGBA_INTEGER, GL_INT},                            // R32G32B32A32_SINT
     {GL_RG32F, GL_RG, GL_FLOAT},                                      // R32G32_FLOAT
@@ -81,7 +81,7 @@ constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> FORMAT_TAB
     {GL_COMPRESSED_RGBA_ASTC_8x8_KHR},                                // ASTC_2D_8X8_UNORM
     {GL_COMPRESSED_RGBA_ASTC_8x5_KHR},                                // ASTC_2D_8X5_UNORM
     {GL_COMPRESSED_RGBA_ASTC_5x4_KHR},                                // ASTC_2D_5X4_UNORM
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE},                     // B8G8R8A8_SRGB
+    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},          // B8G8R8A8_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT},                         // BC1_RGBA_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT},                         // BC2_SRGB
     {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT},                         // BC3_SRGB

src/video_core/renderer_opengl/util_shaders.cpp

@@ -257,38 +257,31 @@ void UtilShaders::CopyBC4(Image& dst_image, Image& src_image, std::span<const Im
 
 void UtilShaders::CopyBGR(Image& dst_image, Image& src_image,
                           std::span<const VideoCommon::ImageCopy> copies) {
-    static constexpr GLuint BINDING_INPUT_IMAGE = 0;
-    static constexpr GLuint BINDING_OUTPUT_IMAGE = 1;
     static constexpr VideoCommon::Offset3D zero_offset{0, 0, 0};
-    const u32 bytes_per_block = BytesPerBlock(dst_image.info.format);
-    switch (bytes_per_block) {
-    case 2:
-        // BGR565 copy
     for (const ImageCopy& copy : copies) {
         ASSERT(copy.src_offset == zero_offset);
         ASSERT(copy.dst_offset == zero_offset);
-            bgr_copy_pass.Execute(dst_image, src_image, copy);
+
+        if (bgr_pbo_size < dst_image.unswizzled_size_bytes) {
+            bgr_pbo.Create();
+            bgr_pbo_size = dst_image.unswizzled_size_bytes;
+            glNamedBufferData(bgr_pbo.handle, bgr_pbo_size, nullptr, GL_STREAM_COPY);
         }
-        break;
+        // Copy from source to PBO
-    case 4: {
+        glPixelStorei(GL_PACK_ALIGNMENT, 1);
-        // BGRA8 copy
+        glPixelStorei(GL_PACK_ROW_LENGTH, copy.extent.width);
-        program_manager.BindComputeProgram(copy_bgra_program.handle);
+        glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr_pbo.handle);
-        constexpr GLenum FORMAT = GL_RGBA8;
+        glGetTextureSubImage(src_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-        for (const ImageCopy& copy : copies) {
+                             copy.src_subresource.num_layers, src_image.GlFormat(),
-            ASSERT(copy.src_offset == zero_offset);
+                             src_image.GlType(), static_cast<GLsizei>(bgr_pbo_size), nullptr);
-            ASSERT(copy.dst_offset == zero_offset);
+
-            glBindImageTexture(BINDING_INPUT_IMAGE, src_image.StorageHandle(),
+        // Copy from PBO to destination in reverse order
-                               copy.src_subresource.base_level, GL_FALSE, 0, GL_READ_ONLY, FORMAT);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-            glBindImageTexture(BINDING_OUTPUT_IMAGE, dst_image.StorageHandle(),
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, copy.extent.width);
-                               copy.dst_subresource.base_level, GL_FALSE, 0, GL_WRITE_ONLY, FORMAT);
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bgr_pbo.handle);
-            glDispatchCompute(copy.extent.width, copy.extent.height, copy.extent.depth);
+        glTextureSubImage3D(dst_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-        }
+                            copy.dst_subresource.num_layers, dst_image.GlFormat(),
-        program_manager.RestoreGuestCompute();
+                            dst_image.GlType(), nullptr);
-        break;
-    }
-    default:
-        UNREACHABLE();
-        break;
     }
 }
 
@@ -309,36 +302,4 @@ GLenum StoreFormat(u32 bytes_per_block) {
     return GL_R8UI;
 }
 
-void Bgr565CopyPass::Execute(const Image& dst_image, const Image& src_image,
-                             const ImageCopy& copy) {
-    if (CopyBufferCreationNeeded(copy)) {
-        CreateNewCopyBuffer(copy, GL_TEXTURE_2D_ARRAY, GL_RGB565);
-    }
-    // Copy from source to PBO
-    glPixelStorei(GL_PACK_ALIGNMENT, 1);
-    glPixelStorei(GL_PACK_ROW_LENGTH, copy.extent.width);
-    glBindBuffer(GL_PIXEL_PACK_BUFFER, bgr16_pbo.handle);
-    glGetTextureSubImage(src_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-                         copy.src_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
-                         static_cast<GLsizei>(bgr16_pbo_size), nullptr);
-
-    // Copy from PBO to destination in reverse order
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, copy.extent.width);
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bgr16_pbo.handle);
-    glTextureSubImage3D(dst_image.Handle(), 0, 0, 0, 0, copy.extent.width, copy.extent.height,
-                        copy.dst_subresource.num_layers, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV,
-                        nullptr);
-}
-
-bool Bgr565CopyPass::CopyBufferCreationNeeded(const ImageCopy& copy) {
-    return bgr16_pbo_size < NumPixelsInCopy(copy) * sizeof(u16);
-}
-
-void Bgr565CopyPass::CreateNewCopyBuffer(const ImageCopy& copy, GLenum target, GLuint format) {
-    bgr16_pbo.Create();
-    bgr16_pbo_size = NumPixelsInCopy(copy) * sizeof(u16);
-    glNamedBufferData(bgr16_pbo.handle, bgr16_pbo_size, nullptr, GL_STREAM_COPY);
-}
-
 } // namespace OpenGL

src/video_core/renderer_opengl/util_shaders.h

@@ -19,22 +19,6 @@ class ProgramManager;
 
 struct ImageBufferMap;
 
-class Bgr565CopyPass {
-public:
-    Bgr565CopyPass() = default;
-    ~Bgr565CopyPass() = default;
-
-    void Execute(const Image& dst_image, const Image& src_image,
-                 const VideoCommon::ImageCopy& copy);
-
-private:
-    [[nodiscard]] bool CopyBufferCreationNeeded(const VideoCommon::ImageCopy& copy);
-    void CreateNewCopyBuffer(const VideoCommon::ImageCopy& copy, GLenum target, GLuint format);
-
-    OGLBuffer bgr16_pbo;
-    size_t bgr16_pbo_size{};
-};
-
 class UtilShaders {
 public:
     explicit UtilShaders(ProgramManager& program_manager);
@@ -70,7 +54,8 @@ private:
     OGLProgram copy_bgra_program;
     OGLProgram copy_bc4_program;
 
-    Bgr565CopyPass bgr_copy_pass;
+    OGLBuffer bgr_pbo;
+    size_t bgr_pbo_size{};
 };
 
 GLenum StoreFormat(u32 bytes_per_block);