[Chore] (MG_Backend/DirectVulkan): unifying framebuffer manager Transition* functiosn

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformDescriptorBinder.cpp

@@ -481,7 +481,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         if (m_framebufferManager &&
-            m_framebufferManager->TransitionOffscreenColorTextureToShaderRead(commandBuffer, texture->GetExternalIndex())) {
+            m_framebufferManager->Transition(commandBuffer,
+                                             VkFramebufferManager::TransitionResource::OffscreenColorTexture,
+                                             VkFramebufferManager::TransitionUsage::ShaderRead,
+                                             texture->GetExternalIndex())) {
             VkImageView offscreenView = VK_NULL_HANDLE;
             if (m_framebufferManager->GetOffscreenColorViewByTexture(texture->GetExternalIndex(), offscreenView) &&
                 offscreenView != VK_NULL_HANDLE) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VkFramebufferManager.cpp

@@ -44,164 +44,128 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return RecreateOffscreenColorTarget(target, glFbo, colorAttachment, objectVersion);
     }
 
-    Bool VkFramebufferManager::TransitionOffscreenColorToAttachment(VkCommandBuffer commandBuffer,
+    Bool VkFramebufferManager::Transition(VkCommandBuffer commandBuffer, TransitionResource resource,
-                                                                    Uint glFboExternalIndex) {
+                                          TransitionUsage usage, Uint externalIndex) {
-        auto it = m_offscreenColorTargets.find(glFboExternalIndex);
+        auto resolveDepthStencilAspectMask = [](VkFormat format) {
-        if (it == m_offscreenColorTargets.end()) {
+            VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-            MGLOG_W("VkFramebufferManager::TransitionOffscreenColorToAttachment skipped: FBO %u not found",
+            if (format == VK_FORMAT_D24_UNORM_S8_UINT || format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
-                    glFboExternalIndex);
+                aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
-            return false;
-        }
-        auto& target = it->second;
-        if (!TransitionImageLayout(commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-                                   VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0,
-                                   VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-                                   VK_IMAGE_ASPECT_COLOR_BIT)) {
-            return false;
-        }
-
-        if (target.depthStencilImage == VK_NULL_HANDLE) {
-            return true;
-        }
-
-        VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-        if (target.depthStencilFormat == VK_FORMAT_D24_UNORM_S8_UINT ||
-            target.depthStencilFormat == VK_FORMAT_D32_SFLOAT_S8_UINT) {
-            aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
-        }
-
-        return TransitionImageLayout(
-            commandBuffer, target.depthStencilImage, target.depthStencilLayout,
-            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-            VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0,
-            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, aspectMask);
-    }
-
-    Bool VkFramebufferManager::TransitionOffscreenColorToTransferSrc(VkCommandBuffer commandBuffer,
-                                                                     Uint glFboExternalIndex) {
-        auto it = m_offscreenColorTargets.find(glFboExternalIndex);
-        if (it == m_offscreenColorTargets.end()) {
-            MGLOG_W("VkFramebufferManager::TransitionOffscreenColorToTransferSrc skipped: FBO %u not found",
-                    glFboExternalIndex);
-            return false;
-        }
-        auto& target = it->second;
-        return TransitionImageLayout(commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                                     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
-                                     VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
-    }
-
-    Bool VkFramebufferManager::TransitionOffscreenColorToTransferDst(VkCommandBuffer commandBuffer,
-                                                                     Uint glFboExternalIndex) {
-        auto it = m_offscreenColorTargets.find(glFboExternalIndex);
-        if (it == m_offscreenColorTargets.end()) {
-            MGLOG_W("VkFramebufferManager::TransitionOffscreenColorToTransferDst skipped: FBO %u not found",
-                    glFboExternalIndex);
-            return false;
-        }
-        auto& target = it->second;
-        return TransitionImageLayout(commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                                     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
-                                     VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
-    }
-
-    Bool VkFramebufferManager::TransitionOffscreenColorToGeneral(VkCommandBuffer commandBuffer,
-                                                                 Uint glFboExternalIndex) {
-        auto it = m_offscreenColorTargets.find(glFboExternalIndex);
-        if (it == m_offscreenColorTargets.end()) {
-            MGLOG_W("VkFramebufferManager::TransitionOffscreenColorToGeneral skipped: FBO %u not found",
-                    glFboExternalIndex);
-            return false;
-        }
-        auto& target = it->second;
-        return TransitionImageLayout(commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_GENERAL,
-                                     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
-                                     VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
-                                     VK_IMAGE_ASPECT_COLOR_BIT);
-    }
-
-    Bool VkFramebufferManager::TransitionOffscreenDepthStencilToTransferSrc(VkCommandBuffer commandBuffer,
-                                                                            Uint glFboExternalIndex) {
-        auto it = m_offscreenColorTargets.find(glFboExternalIndex);
-        if (it == m_offscreenColorTargets.end()) {
-            MGLOG_W("VkFramebufferManager::TransitionOffscreenDepthStencilToTransferSrc skipped: FBO %u not found",
-                    glFboExternalIndex);
-            return false;
-        }
-        auto& target = it->second;
-        if (target.depthStencilImage == VK_NULL_HANDLE) {
-            return false;
-        }
-        VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-        if (target.depthStencilFormat == VK_FORMAT_D24_UNORM_S8_UINT ||
-            target.depthStencilFormat == VK_FORMAT_D32_SFLOAT_S8_UINT) {
-            aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
-        }
-        return TransitionImageLayout(commandBuffer, target.depthStencilImage, target.depthStencilLayout,
-                                     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                     VK_PIPELINE_STAGE_TRANSFER_BIT, 0, VK_ACCESS_TRANSFER_READ_BIT, aspectMask);
-    }
-
-    Bool VkFramebufferManager::TransitionOffscreenDepthStencilToTransferDst(VkCommandBuffer commandBuffer,
-                                                                            Uint glFboExternalIndex) {
-        auto it = m_offscreenColorTargets.find(glFboExternalIndex);
-        if (it == m_offscreenColorTargets.end()) {
-            MGLOG_W("VkFramebufferManager::TransitionOffscreenDepthStencilToTransferDst skipped: FBO %u not found",
-                    glFboExternalIndex);
-            return false;
-        }
-        auto& target = it->second;
-        if (target.depthStencilImage == VK_NULL_HANDLE) {
-            return false;
-        }
-        VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-        if (target.depthStencilFormat == VK_FORMAT_D24_UNORM_S8_UINT ||
-            target.depthStencilFormat == VK_FORMAT_D32_SFLOAT_S8_UINT) {
-            aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
-        }
-        return TransitionImageLayout(commandBuffer, target.depthStencilImage, target.depthStencilLayout,
-                                     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                     VK_PIPELINE_STAGE_TRANSFER_BIT, 0, VK_ACCESS_TRANSFER_WRITE_BIT, aspectMask);
-    }
-
-    Bool VkFramebufferManager::TransitionOffscreenDepthStencilToGeneral(VkCommandBuffer commandBuffer,
-                                                                        Uint glFboExternalIndex) {
-        auto it = m_offscreenColorTargets.find(glFboExternalIndex);
-        if (it == m_offscreenColorTargets.end()) {
-            MGLOG_W("VkFramebufferManager::TransitionOffscreenDepthStencilToGeneral skipped: FBO %u not found",
-                    glFboExternalIndex);
-            return false;
-        }
-        auto& target = it->second;
-        if (target.depthStencilImage == VK_NULL_HANDLE) {
-            return false;
-        }
-        VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-        if (target.depthStencilFormat == VK_FORMAT_D24_UNORM_S8_UINT ||
-            target.depthStencilFormat == VK_FORMAT_D32_SFLOAT_S8_UINT) {
-            aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
-        }
-        return TransitionImageLayout(commandBuffer, target.depthStencilImage, target.depthStencilLayout,
-                                     VK_IMAGE_LAYOUT_GENERAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                     VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
-                                     VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT, aspectMask);
-    }
-
-    Bool VkFramebufferManager::TransitionOffscreenColorTextureToShaderRead(VkCommandBuffer commandBuffer,
-                                                                           Uint textureExternalIndex) {
-        for (auto& [_, target] : m_offscreenColorTargets) {
-            if (target.colorTextureExternalIndex != textureExternalIndex || target.image == VK_NULL_HANDLE) {
-                continue;
             }
-            const Bool fromUndefined = (target.layout == VK_IMAGE_LAYOUT_UNDEFINED);
+            return aspectMask;
-            return TransitionImageLayout(
+        };
-                commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+
-                fromUndefined ? VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
+        if (resource == TransitionResource::OffscreenColorTexture) {
-                              : (VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT),
+            if (usage != TransitionUsage::ShaderRead) {
-                VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                MGLOG_W("VkFramebufferManager::Transition skipped: unsupported usage %d for texture %u",
-                fromUndefined ? 0 : (VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT),
+                        static_cast<Int>(usage), externalIndex);
-                VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
+                return false;
+            }
+
+            for (auto& [_, target] : m_offscreenColorTargets) {
+                if (target.colorTextureExternalIndex != externalIndex || target.image == VK_NULL_HANDLE) {
+                    continue;
+                }
+                const Bool fromUndefined = (target.layout == VK_IMAGE_LAYOUT_UNDEFINED);
+                return TransitionImageLayout(
+                    commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                    fromUndefined
+                        ? VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
+                        : (VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT),
+                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                    fromUndefined ? 0 : (VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT),
+                    VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
+            }
+            return false;
         }
+
+        auto it = m_offscreenColorTargets.find(externalIndex);
+        if (it == m_offscreenColorTargets.end()) {
+            MGLOG_W("VkFramebufferManager::Transition skipped: FBO %u not found", externalIndex);
+            return false;
+        }
+        auto& target = it->second;
+
+        if (resource == TransitionResource::OffscreenColor) {
+            switch (usage) {
+            case TransitionUsage::Attachment: {
+                if (!TransitionImageLayout(
+                        commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                        VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0,
+                        VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                        VK_IMAGE_ASPECT_COLOR_BIT)) {
+                    return false;
+                }
+                if (target.depthStencilImage == VK_NULL_HANDLE) {
+                    return true;
+                }
+                const VkImageAspectFlags aspectMask = resolveDepthStencilAspectMask(target.depthStencilFormat);
+                return TransitionImageLayout(
+                    commandBuffer, target.depthStencilImage, target.depthStencilLayout,
+                    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0,
+                    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                    aspectMask);
+            }
+            case TransitionUsage::TransferSrc:
+                return TransitionImageLayout(commandBuffer, target.image, target.layout,
+                                             VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+                                             VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
+            case TransitionUsage::TransferDst:
+                return TransitionImageLayout(commandBuffer, target.image, target.layout,
+                                             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+                                             VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
+            case TransitionUsage::General:
+                return TransitionImageLayout(commandBuffer, target.image, target.layout, VK_IMAGE_LAYOUT_GENERAL,
+                                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+                                             VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+                                             VK_IMAGE_ASPECT_COLOR_BIT);
+            case TransitionUsage::ShaderRead:
+                return TransitionImageLayout(commandBuffer, target.image, target.layout,
+                                             VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                                             0, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
+            default:
+                return false;
+            }
+        }
+
+        if (resource == TransitionResource::OffscreenDepthStencil) {
+            if (target.depthStencilImage == VK_NULL_HANDLE) {
+                return false;
+            }
+            const VkImageAspectFlags aspectMask = resolveDepthStencilAspectMask(target.depthStencilFormat);
+            switch (usage) {
+            case TransitionUsage::TransferSrc:
+                return TransitionImageLayout(commandBuffer, target.depthStencilImage, target.depthStencilLayout,
+                                             VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+                                             VK_ACCESS_TRANSFER_READ_BIT, aspectMask);
+            case TransitionUsage::TransferDst:
+                return TransitionImageLayout(commandBuffer, target.depthStencilImage, target.depthStencilLayout,
+                                             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+                                             VK_ACCESS_TRANSFER_WRITE_BIT, aspectMask);
+            case TransitionUsage::General:
+                return TransitionImageLayout(commandBuffer, target.depthStencilImage, target.depthStencilLayout,
+                                             VK_IMAGE_LAYOUT_GENERAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                             VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+                                             VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT, aspectMask);
+            case TransitionUsage::Attachment:
+                return TransitionImageLayout(
+                    commandBuffer, target.depthStencilImage, target.depthStencilLayout,
+                    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0,
+                    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                    aspectMask);
+            case TransitionUsage::ShaderRead:
+                return false;
+            default:
+                return false;
+            }
+        }
+
         return false;
     }
 

MobileGL/MG_Backend/DirectVulkan/Renderer/VkFramebufferManager.h

@@ -15,6 +15,20 @@
 namespace MobileGL::MG_Backend::DirectVulkan {
     class VkFramebufferManager {
     public:
+        enum class TransitionResource {
+            OffscreenColor,
+            OffscreenDepthStencil,
+            OffscreenColorTexture
+        };
+
+        enum class TransitionUsage {
+            Attachment,
+            TransferSrc,
+            TransferDst,
+            General,
+            ShaderRead
+        };
+
         struct InitInfo {
             VkDevice device = VK_NULL_HANDLE;
             VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
@@ -27,14 +41,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void Shutdown();
 
         Bool EnsureOffscreenColorTarget(Uint glFboExternalIndex, const MG_State::GLState::FramebufferObject& glFbo);
-        Bool TransitionOffscreenColorToAttachment(VkCommandBuffer commandBuffer, Uint glFboExternalIndex);
+        Bool Transition(VkCommandBuffer commandBuffer, TransitionResource resource, TransitionUsage usage,
-        Bool TransitionOffscreenColorToTransferSrc(VkCommandBuffer commandBuffer, Uint glFboExternalIndex);
+                        Uint externalIndex);
-        Bool TransitionOffscreenColorToTransferDst(VkCommandBuffer commandBuffer, Uint glFboExternalIndex);
-        Bool TransitionOffscreenColorToGeneral(VkCommandBuffer commandBuffer, Uint glFboExternalIndex);
-        Bool TransitionOffscreenDepthStencilToTransferSrc(VkCommandBuffer commandBuffer, Uint glFboExternalIndex);
-        Bool TransitionOffscreenDepthStencilToTransferDst(VkCommandBuffer commandBuffer, Uint glFboExternalIndex);
-        Bool TransitionOffscreenDepthStencilToGeneral(VkCommandBuffer commandBuffer, Uint glFboExternalIndex);
-        Bool TransitionOffscreenColorTextureToShaderRead(VkCommandBuffer commandBuffer, Uint textureExternalIndex);
         Bool GetOffscreenColorImage(Uint glFboExternalIndex, VkImage& outImage, VkExtent2D& outExtent) const;
         Bool GetOffscreenDepthStencilImage(Uint glFboExternalIndex, VkImage& outImage, VkExtent2D& outExtent,
                                            VkFormat& outFormat) const;
@@ -65,7 +73,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                           const MG_State::GLState::FramebufferAttachmentObject& colorAttachment,
                                           Uint16 glObjectVersion);
         void DestroyOffscreenColorTarget(OffscreenColorTarget& target);
-        Bool TransitionImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout& trackedLayout,
+        static Bool TransitionImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout& trackedLayout,
                                    VkImageLayout newLayout, VkPipelineStageFlags srcStageMask,
                                    VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask,
                                    VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask);

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.cpp

@@ -526,7 +526,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 return;
             }
 
-            if (!m_framebufferManager->TransitionOffscreenColorToAttachment(commandBuffer, drawFboExternalIndex)) {
+            if (!m_framebufferManager->Transition(commandBuffer, VkFramebufferManager::TransitionResource::OffscreenColor,
+                                                  VkFramebufferManager::TransitionUsage::Attachment,
+                                                  drawFboExternalIndex)) {
                 MGLOG_D("EnsureFrameRecordingStarted skipped: failed to transition offscreen FBO %u for attachment",
                         drawFboExternalIndex);
                 return;
@@ -1293,7 +1295,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 if (targetFbo &&
                     EnsureOffscreenRenderTarget(targetFboExternalIndex, *targetFbo, offscreenRenderPass,
                                                 offscreenFramebuffer, offscreenExtent, offscreenDepthStencilFormat) &&
-                    m_framebufferManager->TransitionOffscreenColorToAttachment(commandBuffer, targetFboExternalIndex)) {
+                    m_framebufferManager->Transition(commandBuffer,
+                                                    VkFramebufferManager::TransitionResource::OffscreenColor,
+                                                    VkFramebufferManager::TransitionUsage::Attachment,
+                                                    targetFboExternalIndex)) {
                     m_renderPassManager->BeginRenderPass(commandBuffer, offscreenRenderPass, offscreenFramebuffer,
                                                          offscreenExtent);
 
@@ -1452,8 +1457,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     transitionSwapchainLayout(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                               VK_ACCESS_TRANSFER_READ_BIT);
                 }
-            } else if (!m_framebufferManager->TransitionOffscreenColorToTransferSrc(commandBuffer,
+            } else if (!m_framebufferManager->Transition(commandBuffer,
-                                                                                    readFboExternalIndex)) {
+                                                         VkFramebufferManager::TransitionResource::OffscreenColor,
+                                                         VkFramebufferManager::TransitionUsage::TransferSrc,
+                                                         readFboExternalIndex)) {
                 MGLOG_W("BlitFramebuffer skipped: failed to transition read FBO %u to transfer src",
                         readFboExternalIndex);
                 return false;
@@ -1468,13 +1475,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                               VK_ACCESS_TRANSFER_WRITE_BIT);
                 }
             } else if (sameImage) {
-                if (!m_framebufferManager->TransitionOffscreenColorToGeneral(commandBuffer, drawFboExternalIndex)) {
+                if (!m_framebufferManager->Transition(commandBuffer,
+                                                      VkFramebufferManager::TransitionResource::OffscreenColor,
+                                                      VkFramebufferManager::TransitionUsage::General,
+                                                      drawFboExternalIndex)) {
                     MGLOG_W("BlitFramebuffer skipped: failed to transition draw FBO %u to general",
                             drawFboExternalIndex);
                     return false;
                 }
-            } else if (!m_framebufferManager->TransitionOffscreenColorToTransferDst(commandBuffer,
+            } else if (!m_framebufferManager->Transition(commandBuffer,
-                                                                                    drawFboExternalIndex)) {
+                                                         VkFramebufferManager::TransitionResource::OffscreenColor,
+                                                         VkFramebufferManager::TransitionUsage::TransferDst,
+                                                         drawFboExternalIndex)) {
                 MGLOG_W("BlitFramebuffer skipped: failed to transition draw FBO %u to transfer dst",
                         drawFboExternalIndex);
                 return false;
@@ -1685,8 +1697,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                               VK_PIPELINE_STAGE_TRANSFER_BIT,
                                                               VK_ACCESS_TRANSFER_READ_BIT);
                             }
-                        } else if (!m_framebufferManager->TransitionOffscreenDepthStencilToTransferSrc(
+                        } else if (!m_framebufferManager->Transition(
-                                       commandBuffer, readFboExternalIndex)) {
+                                       commandBuffer, VkFramebufferManager::TransitionResource::OffscreenDepthStencil,
+                                       VkFramebufferManager::TransitionUsage::TransferSrc, readFboExternalIndex)) {
                             MGLOG_W("BlitFramebuffer: failed to transition read depth/stencil FBO %u to transfer src",
                                     readFboExternalIndex);
                         }
@@ -1702,13 +1715,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                               VK_ACCESS_TRANSFER_WRITE_BIT);
                             }
                         } else if (sameDepthImage) {
-                            if (!m_framebufferManager->TransitionOffscreenDepthStencilToGeneral(commandBuffer,
+                            if (!m_framebufferManager->Transition(
-                                                                                                drawFboExternalIndex)) {
+                                    commandBuffer, VkFramebufferManager::TransitionResource::OffscreenDepthStencil,
+                                    VkFramebufferManager::TransitionUsage::General, drawFboExternalIndex)) {
                                 MGLOG_W("BlitFramebuffer: failed to transition draw depth/stencil FBO %u to general",
                                         drawFboExternalIndex);
                             }
-                        } else if (!m_framebufferManager->TransitionOffscreenDepthStencilToTransferDst(
+                        } else if (!m_framebufferManager->Transition(
-                                       commandBuffer, drawFboExternalIndex)) {
+                                       commandBuffer, VkFramebufferManager::TransitionResource::OffscreenDepthStencil,
+                                       VkFramebufferManager::TransitionUsage::TransferDst, drawFboExternalIndex)) {
                             MGLOG_W("BlitFramebuffer: failed to transition draw depth/stencil FBO %u to transfer dst",
                                     drawFboExternalIndex);
                         }
@@ -1865,8 +1880,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                  offscreenFramebuffer, offscreenExtent, offscreenDepthStencilFormat)) {
                     return false;
                 }
-                if (!m_framebufferManager->TransitionOffscreenColorToAttachment(commandBuffer,
+                if (!m_framebufferManager->Transition(commandBuffer,
-                                                                                targetFboExternalIndex)) {
+                                                      VkFramebufferManager::TransitionResource::OffscreenColor,
+                                                      VkFramebufferManager::TransitionUsage::Attachment,
+                                                      targetFboExternalIndex)) {
                     return false;
                 }