CommandQueue.h

#pragma once
 
#include "spark/render/CommandBuffer.h"
#include "spark/render/Export.h"
 
#include "spark/base/Exception.h"
#include "spark/lib/String.h"
 
#include <algorithm>
#include <memory>
#include <utility>
 
namespace spark::render
{
    enum class QueueType
    {
        None = 0x00000000,
 
        Graphics = 0x00000001,
 
        Compute = 0x00000002,
 
        Transfer = 0x00000004,
 
        Other = 0x7FFFFFFF
    };
 
    SPARK_DEFINE_ENUM_FLAGS(QueueType);
 
    enum class QueuePriority
    {
        Normal = 33,
 
        High = 66,
 
        Realtime = 100
    };
 
    class SPARK_RENDER_EXPORT ICommandQueue
    {
    public:
        virtual ~ICommandQueue() noexcept = default;
 
        [[nodiscard]] virtual bool isBound() const noexcept = 0;
 
        [[nodiscard]] virtual QueuePriority priority() const noexcept = 0;
 
        [[nodiscard]] virtual QueueType type() const noexcept = 0;
 
        virtual void bind() const noexcept = 0;
 
        virtual void release() const noexcept = 0;
 
        [[nodiscard]] std::shared_ptr<ICommandBuffer> createCommandBuffer(bool begin_recording = false, bool secondary = false) const noexcept
        {
            return genericCreateCommandBuffer(begin_recording, secondary);
        }
 
        [[nodiscard]] std::size_t submit(std::shared_ptr<ICommandBuffer> command_buffer) const noexcept { return genericSubmit(std::move(command_buffer)); }
 
        [[nodiscard]] std::size_t submit(std::shared_ptr<const ICommandBuffer> command_buffer) const noexcept { return genericSubmit(std::move(command_buffer)); }
 
        [[nodiscard]] std::size_t submit(const std::vector<std::shared_ptr<const ICommandBuffer>>& command_buffers) const noexcept { return genericSubmit(command_buffers); }
 
        [[nodiscard]] std::size_t submit(const std::vector<std::shared_ptr<ICommandBuffer>>& command_buffers) const noexcept
        {
            std::vector<std::shared_ptr<const ICommandBuffer>> command_buffers_vector;
            command_buffers_vector.reserve(command_buffers.size());
            std::ranges::transform(command_buffers,
                                   std::back_inserter(command_buffers_vector),
                                   [](auto& command_buffer) { return std::static_pointer_cast<const ICommandBuffer>(command_buffer); });
            return genericSubmit(command_buffers_vector);
        }
 
        virtual void waitFor(std::size_t fence) const noexcept = 0;
 
        [[nodiscard]] virtual std::size_t currentFence() const noexcept = 0;
 
    private:
        [[nodiscard]] virtual std::shared_ptr<ICommandBuffer> genericCreateCommandBuffer(bool begin_recording, bool secondary) const noexcept = 0;
        virtual std::size_t genericSubmit(std::shared_ptr<ICommandBuffer> command_buffer) const noexcept = 0;
        virtual std::size_t genericSubmit(std::shared_ptr<const ICommandBuffer> command_buffer) const noexcept = 0;
        virtual std::size_t genericSubmit(const std::vector<std::shared_ptr<const ICommandBuffer>>& command_buffers) const noexcept = 0;
    };
 
    template <typename CommandBufferType>
    class CommandQueue : public ICommandQueue
    {
    public:
        using command_buffer_type = CommandBufferType;
 
    public:
        [[nodiscard]] virtual std::shared_ptr<command_buffer_type> createCommandBuffer(bool begin_recording = false, bool secondary = false) const noexcept = 0;
 
        [[nodiscard]] virtual std::size_t submit(std::shared_ptr<command_buffer_type> command_buffer) const noexcept = 0;
 
        [[nodiscard]] virtual std::size_t submit(std::shared_ptr<const command_buffer_type> command_buffer) const noexcept = 0;
 
        [[nodiscard]] virtual std::size_t submit(const std::vector<std::shared_ptr<const command_buffer_type>>& command_buffers) const noexcept = 0;
 
        [[nodiscard]] virtual std::size_t submit(const std::vector<std::shared_ptr<command_buffer_type>>& command_buffers) const noexcept = 0;
 
    private:
        [[nodiscard]] std::shared_ptr<ICommandBuffer> genericCreateCommandBuffer(bool begin_recording, bool secondary) const noexcept final
        {
            return createCommandBuffer(begin_recording, secondary);
        }
 
        std::size_t genericSubmit(std::shared_ptr<ICommandBuffer> command_buffer) const noexcept final
        {
            return submit(std::dynamic_pointer_cast<command_buffer_type>(std::move(command_buffer)));
        }
 
        std::size_t genericSubmit(std::shared_ptr<const ICommandBuffer> command_buffer) const noexcept final
        {
            return submit(std::dynamic_pointer_cast<const command_buffer_type>(std::move(command_buffer)));
        }
 
        std::size_t genericSubmit(const std::vector<std::shared_ptr<const ICommandBuffer>>& command_buffers) const noexcept final
        {
            std::vector<std::shared_ptr<const command_buffer_type>> command_buffers_vector;
            std::ranges::transform(command_buffers,
                                   std::back_inserter(command_buffers_vector),
                                   [](auto& command_buffer) { return std::dynamic_pointer_cast<const command_buffer_type>(command_buffer); });
            return submit(command_buffers_vector);
        }
    };
}