vk: build new descriptor set framework

filament/backend/include/backend/DriverEnums.h

@@ -226,6 +226,7 @@ enum class DescriptorType : uint8_t {
     UNIFORM_BUFFER,
     SHADER_STORAGE_BUFFER,
     SAMPLER,
+    INPUT_ATTACHMENT,
 };
 
 enum class DescriptorFlags : uint8_t {

filament/backend/src/opengl/GLDescriptorSet.cpp

@@ -105,6 +105,8 @@ GLDescriptorSet::GLDescriptorSet(OpenGLContext& gl, DescriptorSetLayoutHandle ds
                     }
                 }
                 break;
+            case DescriptorType::INPUT_ATTACHMENT:
+                break;
         }
     }
 }

filament/backend/src/opengl/OpenGLProgram.cpp

@@ -182,6 +182,8 @@ void OpenGLProgram::initializeProgramState(OpenGLContext& context, GLuint progra
                     }
                     break;
                 }
+                case DescriptorType::INPUT_ATTACHMENT:
+                    break;
             }
             CHECK_GL_ERROR(utils::slog.e)
         }

filament/backend/src/vulkan/VulkanBlitter.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "VulkanBlitter.h"
+#include "VulkanCommands.h"
 #include "VulkanContext.h"
 #include "VulkanFboCache.h"
 #include "VulkanHandles.h"
@@ -33,9 +34,10 @@ namespace filament::backend {
 
 namespace {
 
-inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect, VkFilter filter,
+inline void blitFast(VulkanCommandBuffer* commands, VkImageAspectFlags aspect, VkFilter filter,
         VulkanAttachment src, VulkanAttachment dst,
         const VkOffset3D srcRect[2], const VkOffset3D dstRect[2]) {
+    VkCommandBuffer const cmdbuf = commands->buffer();
     if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
         utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                       << " layout=" << src.getLayout()
@@ -49,16 +51,16 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
     VulkanLayout oldSrcLayout = src.getLayout();
     VulkanLayout oldDstLayout = dst.getLayout();
 
-    src.texture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::TRANSFER_SRC);
-    dst.texture->transitionLayout(cmdbuffer, dstRange, VulkanLayout::TRANSFER_DST);
+    src.texture->transitionLayout(commands, srcRange, VulkanLayout::TRANSFER_SRC);
+    dst.texture->transitionLayout(commands, dstRange, VulkanLayout::TRANSFER_DST);
 
     const VkImageBlit blitRegions[1] = {{
             .srcSubresource = { aspect, src.level, src.layer, 1 },
             .srcOffsets = { srcRect[0], srcRect[1] },
             .dstSubresource = { aspect, dst.level, dst.layer, 1 },
             .dstOffsets = { dstRect[0], dstRect[1] },
     }};
-    vkCmdBlitImage(cmdbuffer,
+    vkCmdBlitImage(cmdbuf,
             src.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_SRC),
             dst.getImage(), imgutil::getVkLayout(VulkanLayout::TRANSFER_DST),
             1, blitRegions, filter);
@@ -69,12 +71,13 @@ inline void blitFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
     if (oldDstLayout == VulkanLayout::UNDEFINED) {
         oldDstLayout = imgutil::getDefaultLayout(dst.texture->usage);
     }
-    src.texture->transitionLayout(cmdbuffer, srcRange, oldSrcLayout);
-    dst.texture->transitionLayout(cmdbuffer, dstRange, oldDstLayout);
+    src.texture->transitionLayout(commands, srcRange, oldSrcLayout);
+    dst.texture->transitionLayout(commands, dstRange, oldDstLayout);
 }
 
-inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspect,
+inline void resolveFast(VulkanCommandBuffer* commands, VkImageAspectFlags aspect,
         VulkanAttachment src, VulkanAttachment dst) {
+    VkCommandBuffer const cmdbuffer = commands->buffer();
     if constexpr (FVK_ENABLED(FVK_DEBUG_BLITTER)) {
         utils::slog.d << "Fast blit from=" << src.texture->getVkImage() << ",level=" << (int) src.level
                       << " layout=" << src.getLayout()
@@ -88,8 +91,8 @@ inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspe
     VulkanLayout oldSrcLayout = src.getLayout();
     VulkanLayout oldDstLayout = dst.getLayout();
 
-    src.texture->transitionLayout(cmdbuffer, srcRange, VulkanLayout::TRANSFER_SRC);
-    dst.texture->transitionLayout(cmdbuffer, dstRange, VulkanLayout::TRANSFER_DST);
+    src.texture->transitionLayout(commands, srcRange, VulkanLayout::TRANSFER_SRC);
+    dst.texture->transitionLayout(commands, dstRange, VulkanLayout::TRANSFER_DST);
 
     assert_invariant(
             aspect != VK_IMAGE_ASPECT_DEPTH_BIT && "Resolve with depth is not yet supported.");
@@ -111,8 +114,8 @@ inline void resolveFast(const VkCommandBuffer cmdbuffer, VkImageAspectFlags aspe
     if (oldDstLayout == VulkanLayout::UNDEFINED) {
         oldDstLayout = imgutil::getDefaultLayout(dst.texture->usage);
     }
-    src.texture->transitionLayout(cmdbuffer, srcRange, oldSrcLayout);
-    dst.texture->transitionLayout(cmdbuffer, dstRange, oldDstLayout);
+    src.texture->transitionLayout(commands, srcRange, oldSrcLayout);
+    dst.texture->transitionLayout(commands, dstRange, oldDstLayout);
 }
 
 struct BlitterUniforms {
@@ -149,10 +152,9 @@ void VulkanBlitter::resolve(VulkanAttachment dst, VulkanAttachment src) {
 #endif
 
     VulkanCommandBuffer& commands = mCommands->get();
-    VkCommandBuffer const cmdbuffer = commands.buffer();
     commands.acquire(src.texture);
     commands.acquire(dst.texture);
-    resolveFast(cmdbuffer, aspect, src, dst);
+    resolveFast(&commands, aspect, src, dst);
 }
 
 void VulkanBlitter::blit(VkFilter filter,
@@ -175,10 +177,9 @@ void VulkanBlitter::blit(VkFilter filter,
     // src and dst should have the same aspect here
     VkImageAspectFlags const aspect = src.texture->getImageAspect();
     VulkanCommandBuffer& commands = mCommands->get();
-    VkCommandBuffer const cmdbuffer = commands.buffer();
     commands.acquire(src.texture);
     commands.acquire(dst.texture);
-    blitFast(cmdbuffer, aspect, filter, src, dst, srcRectPair, dstRectPair);
+    blitFast(&commands, aspect, filter, src, dst, srcRectPair, dstRectPair);
 }
 
 void VulkanBlitter::terminate() noexcept {

filament/backend/src/vulkan/VulkanCommands.cpp

@@ -297,11 +297,11 @@ bool VulkanCommands::flush() {
 #endif
 
     auto& cmdfence = currentbuf->fence;
-    std::unique_lock<utils::Mutex> lock(cmdfence->mutex);
-    cmdfence->status.store(VK_NOT_READY);
-    UTILS_UNUSED_IN_RELEASE VkResult result = vkQueueSubmit(mQueue, 1, &submitInfo, cmdfence->fence);
-    cmdfence->condition.notify_all();
-    lock.unlock();
+    UTILS_UNUSED_IN_RELEASE VkResult result = VK_SUCCESS;
+    {
+        auto scope = cmdfence->setValue(VK_NOT_READY);
+        result = vkQueueSubmit(mQueue, 1, &submitInfo, cmdfence->getFence());
+    }
 
 #if FVK_ENABLED(FVK_DEBUG_COMMAND_BUFFER)
     if (result != VK_SUCCESS) {
@@ -340,7 +340,7 @@ void VulkanCommands::wait() {
         auto wrapper = mStorage[i].get();
         if (wrapper->buffer() != VK_NULL_HANDLE
                 && mCurrentCommandBufferIndex != static_cast<int8_t>(i)) {
-            fences[count++] = wrapper->fence->fence;
+            fences[count++] = wrapper->fence->getFence();
         }
     }
     if (count > 0) {
@@ -361,12 +361,13 @@ void VulkanCommands::gc() {
         if (wrapper->buffer() == VK_NULL_HANDLE) {
             continue;
         }
-        VkResult const result = vkGetFenceStatus(mDevice, wrapper->fence->fence);
+        auto const vkfence = wrapper->fence->getFence();
+        VkResult const result = vkGetFenceStatus(mDevice, vkfence);
         if (result != VK_SUCCESS) {
             continue;
         }
-        fences[count++] = wrapper->fence->fence;
-        wrapper->fence->status.store(VK_SUCCESS);
+        fences[count++] = vkfence;
+        wrapper->fence->setValue(VK_SUCCESS);
         wrapper->reset();
         mAvailableBufferCount++;
     }
@@ -383,9 +384,9 @@ void VulkanCommands::updateFences() {
         if (wrapper->buffer() != VK_NULL_HANDLE) {
             VulkanCmdFence* fence = wrapper->fence.get();
             if (fence) {
-                VkResult status = vkGetFenceStatus(mDevice, fence->fence);
+                VkResult status = vkGetFenceStatus(mDevice, fence->getFence());
                 // This is either VK_SUCCESS, VK_NOT_READY, or VK_ERROR_DEVICE_LOST.
-                fence->status.store(status, std::memory_order_relaxed);
+                fence->setValue(status);
             }
         }
     }

filament/backend/src/vulkan/VulkanCommands.h

@@ -61,8 +61,40 @@ class VulkanGroupMarkers {
 
 // Wrapper to enable use of shared_ptr for implementing shared ownership of low-level Vulkan fences.
 struct VulkanCmdFence {
+    struct SetValueScope {
+    public:
+        ~SetValueScope() {
+            mHolder->mutex.unlock();
+            mHolder->condition.notify_all();
+        }
+
+    private:
+        SetValueScope(VulkanCmdFence* fenceHolder, VkResult result) :
+            mHolder(fenceHolder) {
+            mHolder->mutex.lock();
+            mHolder->status.store(result);
+        }
+        VulkanCmdFence* mHolder;
+        friend struct VulkanCmdFence;
+    };
+
     VulkanCmdFence(VkFence ifence);
     ~VulkanCmdFence() = default;
+
+    SetValueScope setValue(VkResult value) {
+        return {this, value};
+    }
+
+    VkFence& getFence() {
+        return fence;
+    }
+
+    VkResult getStatus() {
+        std::unique_lock<utils::Mutex> lock(mutex);
+        return status.load(std::memory_order_acquire);
+    }
+
+private:
     VkFence fence;
     utils::Condition condition;
     utils::Mutex mutex;