ICommandList.h

#pragma once
#include <UnCompute/Backend/BaseTypes.h>
#include <UnCompute/Backend/IDeviceObject.h>
#include <UnCompute/Memory/Ptr.h>
 
namespace UN
{
    enum class CommandListState
    {
        Initial,
        Recording,
        Executable,
        Pending,
        Invalid
    };
 
    inline const char* CommandListStateToString(CommandListState state)
    {
        switch (state)
        {
            // clang-format off
        case CommandListState::Initial: return "CommandListState::Initial";
        case CommandListState::Recording: return "CommandListState::Recording";
        case CommandListState::Executable: return "CommandListState::Executable";
        case CommandListState::Pending: return "CommandListState::Pending";
        case CommandListState::Invalid: return "CommandListState::Invalid";
            // clang-format on
        default:
            assert(false && "CommandListState was unknown");
            return "CommandListState::<Unknown>";
        }
    }
 
    enum class CommandListFlags
    {
        None          = 0,
        OneTimeSubmit = UN_BIT(1) 
    };
 
    UN_ENUM_OPERATORS(CommandListFlags);
 
    struct CommandListDesc
    {
        const char* Name                      = nullptr;                         
        HardwareQueueKindFlags QueueKindFlags = HardwareQueueKindFlags::Compute; 
        CommandListFlags Flags                = CommandListFlags::None;          
 
        inline CommandListDesc() = default;
 
        inline CommandListDesc(const char* name, HardwareQueueKindFlags queueKindFlags,
                               CommandListFlags flags = CommandListFlags::None)
            : Name(name)
            , QueueKindFlags(queueKindFlags)
            , Flags(flags)
        {
        }
    };
 
    struct BufferCopyRegion
    {
        UInt64 Size         = 0; 
        UInt32 SourceOffset = 0; 
        UInt32 DestOffset   = 0; 
 
        inline BufferCopyRegion() = default;
 
        inline explicit BufferCopyRegion(UInt64 size)
            : Size(size)
            , SourceOffset(0)
            , DestOffset(0)
        {
        }
 
        inline BufferCopyRegion(UInt32 sourceOffset, UInt32 destOffset, UInt64 size)
            : Size(size)
            , SourceOffset(sourceOffset)
            , DestOffset(destOffset)
        {
        }
    };
 
    enum class AccessFlags
    {
        None          = UN_BIT(0),
        KernelRead    = UN_BIT(1),
        KernelWrite   = UN_BIT(2),
        TransferRead  = UN_BIT(3),
        TransferWrite = UN_BIT(4),
        HostRead      = UN_BIT(5),
        HostWrite     = UN_BIT(6)
    };
 
    UN_ENUM_OPERATORS(AccessFlags);
 
    class IBuffer;
 
    struct MemoryBarrierDesc
    {
        AccessFlags SourceAccess = AccessFlags::None; 
        AccessFlags DestAccess   = AccessFlags::None; 
 
        HardwareQueueKindFlags SourceQueueKind = HardwareQueueKindFlags::None; 
        HardwareQueueKindFlags DestQueueKind   = HardwareQueueKindFlags::None; 
 
        inline MemoryBarrierDesc() = default;
 
        inline MemoryBarrierDesc(AccessFlags sourceAccess, AccessFlags destAccess,
                                 HardwareQueueKindFlags sourceQueueKind = HardwareQueueKindFlags::None,
                                 HardwareQueueKindFlags destQueueKind   = HardwareQueueKindFlags::None)
            : SourceAccess(sourceAccess)
            , DestAccess(destAccess)
            , SourceQueueKind(sourceQueueKind)
            , DestQueueKind(destQueueKind)
        {
        }
    };
 
    class IFence;
    class ICommandList;
    class IKernel;
 
    class CommandListBuilder
    {
        ICommandList* m_pCommandList;
 
    public:
        explicit CommandListBuilder(ICommandList* pCommandList);
        ~CommandListBuilder();
 
        inline CommandListBuilder(CommandListBuilder&& other) noexcept
            : m_pCommandList(other.m_pCommandList)
        {
            other.m_pCommandList = nullptr;
        }
 
        inline CommandListBuilder& operator=(CommandListBuilder&& other)
        {
            m_pCommandList       = other.m_pCommandList;
            other.m_pCommandList = nullptr;
            return *this;
        }
 
        void End();
 
        void MemoryBarrier(IBuffer* pBuffer, const MemoryBarrierDesc& barrierDesc);
 
        void Copy(IBuffer* pSource, IBuffer* pDestination, const BufferCopyRegion& region);
 
        void Dispatch(IKernel* pKernel, Int32 x, Int32 y, Int32 z);
 
        explicit operator bool();
    };
 
    class ICommandList : public IDeviceObject
    {
        friend class CommandListBuilder;
 
    protected:
        virtual void End() = 0;
 
        virtual void CmdMemoryBarrier(IBuffer* pBuffer, const MemoryBarrierDesc& barrierDesc)         = 0;
        virtual void CmdCopy(IBuffer* pSource, IBuffer* pDestination, const BufferCopyRegion& region) = 0;
        virtual void CmdDispatch(IKernel* pKernel, Int32 x, Int32 y, Int32 z)                         = 0;
 
    public:
        using DescriptorType = CommandListDesc;
 
        [[nodiscard]] virtual const DescriptorType& GetDesc() const = 0;
 
        virtual ResultCode Init(const DescriptorType& desc) = 0;
 
        virtual IFence* GetFence() = 0;
 
        [[nodiscard]] virtual CommandListState GetState() = 0;
 
        virtual CommandListBuilder Begin() = 0;
 
        virtual void ResetState() = 0;
 
        virtual ResultCode Submit() = 0;
    };
 
    inline CommandListBuilder::CommandListBuilder(ICommandList* pCommandList)
        : m_pCommandList(pCommandList)
    {
    }
 
    inline void CommandListBuilder::End()
    {
        if (m_pCommandList)
        {
            m_pCommandList->End();
            m_pCommandList = nullptr;
        }
    }
 
    inline void CommandListBuilder::MemoryBarrier(IBuffer* pBuffer, const MemoryBarrierDesc& barrierDesc)
    {
        m_pCommandList->CmdMemoryBarrier(pBuffer, barrierDesc);
    }
 
    inline void CommandListBuilder::Copy(IBuffer* pSource, IBuffer* pDestination, const BufferCopyRegion& region)
    {
        m_pCommandList->CmdCopy(pSource, pDestination, region);
    }
 
    inline void CommandListBuilder::Dispatch(IKernel* pKernel, Int32 x, Int32 y, Int32 z)
    {
        m_pCommandList->CmdDispatch(pKernel, x, y, z);
    }
 
    inline CommandListBuilder::operator bool()
    {
        return m_pCommandList != nullptr;
    }
 
    inline CommandListBuilder::~CommandListBuilder()
    {
        End();
    }
} // namespace UN
 
template<>
struct fmt::formatter<UN::CommandListState> : fmt::formatter<std::string_view>
{
    template<typename FormatContext>
    auto format(const UN::CommandListState& state, FormatContext& ctx) const -> decltype(ctx.out())
    {
        return fmt::format_to(ctx.out(), "{}", UN::CommandListStateToString(state));
    }
};