Pipeline.h

#pragma once
 
#include "spark/render/DescriptorSet.h"
#include "spark/render/Export.h"
#include "spark/render/PushConstantsLayout.h"
#include "spark/render/StateResource.h"
 
namespace spark::render
{
    class IShaderProgram;
 
    class SPARK_RENDER_EXPORT IPipelineLayout
    {
    public:
        virtual ~IPipelineLayout() noexcept = default;
 
        [[nodiscard]] virtual const IDescriptorSetLayout& descriptorSet(unsigned int space) const = 0;
 
        [[nodiscard]] std::vector<const IDescriptorSetLayout*> descriptorSets() const noexcept { return genericDescriptorSets(); }
 
        [[nodiscard]] virtual const IPushConstantsLayout* pushConstants() const noexcept = 0;
 
    private:
        [[nodiscard]] virtual std::vector<const IDescriptorSetLayout*> genericDescriptorSets() const noexcept = 0;
    };
 
    template <typename DescriptorSetLayoutType, typename PushConstantsLayoutType>
    class PipelineLayout : public IPipelineLayout
    {
    public:
        using descriptor_set_layout_type = DescriptorSetLayoutType;
        using push_constants_layout_type = PushConstantsLayoutType;
 
    public:
        [[nodiscard]] const descriptor_set_layout_type& descriptorSet(unsigned int space) const override = 0;
 
        [[nodiscard]] virtual std::vector<const descriptor_set_layout_type*> descriptorSets() const noexcept = 0;
 
        [[nodiscard]] const push_constants_layout_type* pushConstants() const noexcept override = 0;
 
    private:
        [[nodiscard]] std::vector<const IDescriptorSetLayout*> genericDescriptorSets() const noexcept override
        {
            std::vector<const IDescriptorSetLayout*> descriptor_sets_vector;
            descriptor_sets_vector.reserve(descriptorSets().size());
            std::ranges::transform(descriptorSets(),
                                   std::back_inserter(descriptor_sets_vector),
                                   [](const auto& descriptor_set) { return static_cast<const IDescriptorSetLayout*>(descriptor_set); });
            return descriptor_sets_vector;
        }
    };
 
    class SPARK_RENDER_EXPORT IPipeline : public virtual IStateResource
    {
    public:
        ~IPipeline() noexcept override = default;
 
        [[nodiscard]] std::shared_ptr<const IShaderProgram> program() const noexcept { return genericProgram(); }
 
        [[nodiscard]] std::shared_ptr<IPipelineLayout> layout() const noexcept { return genericLayout(); }
 
    private:
        [[nodiscard]] virtual std::shared_ptr<const IShaderProgram> genericProgram() const noexcept = 0;
        [[nodiscard]] virtual std::shared_ptr<IPipelineLayout> genericLayout() const noexcept = 0;
    };
 
    template <typename PipelineLayoutType, typename ShaderProgramType>
    class Pipeline : virtual public IPipeline
    {
    public:
        using shader_program_type = ShaderProgramType;
        using pipeline_layout_type = PipelineLayoutType;
 
    public:
        [[nodiscard]] virtual std::shared_ptr<const shader_program_type> program() const noexcept = 0;
 
        [[nodiscard]] virtual std::shared_ptr<pipeline_layout_type> layout() const noexcept = 0;
 
    private:
        [[nodiscard]] std::shared_ptr<IPipelineLayout> genericLayout() const noexcept final { return std::static_pointer_cast<IPipelineLayout>(layout()); }
        [[nodiscard]] std::shared_ptr<const IShaderProgram> genericProgram() const noexcept final { return std::static_pointer_cast<const IShaderProgram>(program()); }
    };
}