foray_commandbuffer.hpp

Go to the documentation of this file.

#pragma once
#include "foray_context.hpp"
#include "foray_managedresource.hpp"
#include <vulkan/vulkan.h>
 
namespace foray::core {
 
    class CommandBuffer : public VulkanResource<VkObjectType::VK_OBJECT_TYPE_COMMAND_BUFFER>
    {
      public:
        CommandBuffer() = default;
        inline virtual ~CommandBuffer() { Destroy(); }
 
        virtual VkCommandBuffer Create(Context* context, VkCommandBufferLevel cmdBufferLvl = VK_COMMAND_BUFFER_LEVEL_PRIMARY, bool begin = false);
        virtual void Begin();
        virtual void End();
        virtual void Reset(VkCommandBufferResetFlags flags = 0);
 
        virtual void Destroy() override;
        virtual bool Exists() const override { return mCommandBuffer; }
        virtual void SetName(std::string_view name) override;
 
        inline operator VkCommandBuffer() const { return mCommandBuffer; }
 
        FORAY_GETTER_V(CommandBuffer)
      protected:
        core::Context* mContext = nullptr;
 
        VkCommandBuffer mCommandBuffer{};
        bool            mIsRecording = false;
    };
 
    class HostSyncCommandBuffer : public CommandBuffer
    {
      public:
        virtual VkCommandBuffer Create(Context* context, VkCommandBufferLevel cmdBufferLvl = VK_COMMAND_BUFFER_LEVEL_PRIMARY, bool begin = false) override;
 
        void Submit();
        void SubmitAndWait();
        bool HasCompleted();
        void WaitForCompletion();
 
        virtual void Destroy() override;
 
        inline virtual ~HostSyncCommandBuffer() { Destroy(); }
 
      protected:
        VkFence mFence = nullptr;
    };
 
    struct SemaphoreReference
    {
        VkSemaphoreType SemaphoreType = VkSemaphoreType::VK_SEMAPHORE_TYPE_BINARY;
        uint64_t TimelineValue = 0;
        VkSemaphore Semaphore = nullptr;
        VkPipelineStageFlags2 WaitStage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
 
        static SemaphoreReference Binary(VkSemaphore semaphore, VkPipelineStageFlags2 waitStage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT);
        static SemaphoreReference Timeline(VkSemaphore semaphore, uint64_t value, VkPipelineStageFlags2 waitStage = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT);
 
        operator VkSemaphoreSubmitInfo() const;
    };
 
    class DeviceSyncCommandBuffer : public CommandBuffer
    {
      public:
        virtual DeviceSyncCommandBuffer& AddWaitSemaphore(const SemaphoreReference& semaphore);
        virtual DeviceSyncCommandBuffer& AddSignalSemaphore(const SemaphoreReference& semaphore);
 
        FORAY_PROPERTY_R(WaitSemaphores)
        FORAY_PROPERTY_R(SignalSemaphores)
        FORAY_PROPERTY_V(Fence)
 
        
        virtual void Submit();
 
        virtual void WriteToSubmitInfo(std::vector<VkSubmitInfo2>& submitInfos);
 
      protected:
        std::vector<SemaphoreReference> mWaitSemaphores;
        std::vector<SemaphoreReference> mSignalSemaphores;
        VkFence                         mFence = nullptr;
    };
 
}  // namespace foray::core