PipelineGraphics.hpp

#pragma once
 
#include "PixelBullet/Filesystem/VirtualPath.hpp"
#include "PixelBullet/Graphics/Pipelines/Pipeline.hpp"
#include "PixelBullet/Graphics/RenderStage.hpp"
 
#include <array>
#include <optional>
#include <stdexcept>
#include <vector>
 
namespace PixelBullet
{
    class ImageDepth;
    class Image2D;
 
    class PipelineGraphics : public Pipeline
    {
    public:
        enum class Mode
        {
            Polygon,
            MRT
        };
 
        enum class Depth
        {
            None = 0,
            Read = 1,
            Write = 2,
            ReadWrite = Read | Write
        };
 
        PipelineGraphics(Stage stage, std::vector<VirtualPath> shaderStages,
                         std::vector<Shader::VertexInput> vertexInputs, std::vector<Shader::Define> defines = {},
                         Mode mode = Mode::Polygon, Depth depth = Depth::ReadWrite,
                         VkPrimitiveTopology topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
                         VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL,
                         VkCullModeFlags cullMode = VK_CULL_MODE_BACK_BIT,
                         VkFrontFace frontFace = VK_FRONT_FACE_CLOCKWISE, bool pushDescriptors = false);
        ~PipelineGraphics();
 
        const ImageDepth* GetDepthStencil(const std::optional<uint32_t>& stage = std::nullopt) const;
 
        const Image2D* GetImage(uint32_t index, const std::optional<uint32_t>& stage = std::nullopt) const;
 
        RenderArea GetRenderArea(const std::optional<uint32_t>& stage = std::nullopt) const;
 
        const Stage& GetStage() const
        {
            return m_Stage;
        }
        const std::vector<VirtualPath>& GetShaderStages() const
        {
            return m_ShaderStages;
        }
        const std::vector<Shader::VertexInput>& GetVertexInputs() const
        {
            return m_VertexInputs;
        }
        const std::vector<Shader::Define>& GetDefines() const
        {
            return m_Defines;
        }
        Mode GetMode() const
        {
            return m_Mode;
        }
        Depth GetDepth() const
        {
            return m_Depth;
        }
        VkPrimitiveTopology GetTopology() const
        {
            return m_Topology;
        }
        VkPolygonMode GetPolygonMode() const
        {
            return m_PolygonMode;
        }
        VkCullModeFlags GetCullMode() const
        {
            return m_CullMode;
        }
        VkFrontFace GetFrontFace() const
        {
            return m_FrontFace;
        }
        bool IsPushDescriptors() const override
        {
            return m_PushDescriptors;
        }
        const Shader* GetShader() const override
        {
            return m_Shader.get();
        }
        const VkDescriptorSetLayout& GetDescriptorSetLayout() const override
        {
            return m_DescriptorSetLayout;
        }
        const VkDescriptorPool& GetDescriptorPool() const override
        {
            return m_DescriptorPool;
        }
        const VkPipeline& GetPipeline() const override
        {
            return m_Pipeline;
        }
        const VkPipelineLayout& GetPipelineLayout() const override
        {
            return m_PipelineLayout;
        }
        const VkPipelineBindPoint& GetPipelineBindPoint() const override
        {
            return m_PipelineBindPoint;
        }
 
    private:
        void CreateShaderProgram();
        void CreateDescriptorLayout();
        void CreateDescriptorPool();
        void CreatePipelineLayout();
        void CreateAttributes();
        void CreatePipeline();
        void CreatePipelinePolygon();
        void CreatePipelineMrt();
 
    private:
        Stage m_Stage;
        std::vector<VirtualPath> m_ShaderStages;
        std::vector<Shader::VertexInput> m_VertexInputs;
        std::vector<Shader::Define> m_Defines;
        Mode m_Mode;
        Depth m_Depth;
        VkPrimitiveTopology m_Topology;
        VkPolygonMode m_PolygonMode;
        VkCullModeFlags m_CullMode;
        VkFrontFace m_FrontFace;
        bool m_PushDescriptors;
 
        std::unique_ptr<Shader> m_Shader;
 
        std::vector<VkDynamicState> m_DynamicStates;
 
        std::vector<VkShaderModule> m_Modules;
        std::vector<VkPipelineShaderStageCreateInfo> m_Stages;
 
        VkDescriptorSetLayout m_DescriptorSetLayout = VK_NULL_HANDLE;
        VkDescriptorPool m_DescriptorPool = VK_NULL_HANDLE;
 
        VkPipeline m_Pipeline = VK_NULL_HANDLE;
        VkPipelineLayout m_PipelineLayout = VK_NULL_HANDLE;
        VkPipelineBindPoint m_PipelineBindPoint;
 
        VkPipelineVertexInputStateCreateInfo m_VertexInputStateCreateInfo = {};
        VkPipelineInputAssemblyStateCreateInfo m_InputAssemblyState = {};
        VkPipelineRasterizationStateCreateInfo m_RasterizationState = {};
        std::array<VkPipelineColorBlendAttachmentState, 1> m_BlendAttachmentStates;
        VkPipelineColorBlendStateCreateInfo m_ColorBlendState = {};
        VkPipelineDepthStencilStateCreateInfo m_DepthStencilState = {};
        VkPipelineViewportStateCreateInfo m_ViewportState = {};
        VkPipelineMultisampleStateCreateInfo m_MultisampleState = {};
        VkPipelineDynamicStateCreateInfo m_DynamicState = {};
        VkPipelineTessellationStateCreateInfo m_TessellationState = {};
    };
 
    class PipelineGraphicsCreate
    {
    public:
        PipelineGraphicsCreate(std::vector<VirtualPath> shaderStages = {},
                               std::vector<Shader::VertexInput> vertexInputs = {},
                               std::vector<Shader::Define> defines = {},
                               PipelineGraphics::Mode mode = PipelineGraphics::Mode::Polygon,
                               PipelineGraphics::Depth depth = PipelineGraphics::Depth::ReadWrite,
                               VkPrimitiveTopology topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
                               VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL,
                               VkCullModeFlags cullMode = VK_CULL_MODE_BACK_BIT,
                               VkFrontFace frontFace = VK_FRONT_FACE_CLOCKWISE, bool pushDescriptors = false)
            : m_ShaderStages(std::move(shaderStages))
            , m_VertexInputs(std::move(vertexInputs))
            , m_Defines(std::move(defines))
            , m_Mode(mode)
            , m_Depth(depth)
            , m_Topology(topology)
            , m_PolygonMode(polygonMode)
            , m_CullMode(cullMode)
            , m_FrontFace(frontFace)
            , m_PushDescriptors(pushDescriptors)
        {
        }
 
        PipelineGraphics* Create(const Pipeline::Stage& pipelineStage) const
        {
            return new PipelineGraphics(pipelineStage, m_ShaderStages, m_VertexInputs, m_Defines, m_Mode, m_Depth,
                                        m_Topology, m_PolygonMode, m_CullMode, m_FrontFace, m_PushDescriptors);
        }
 
        friend const Node& operator>>(const Node& node, PipelineGraphicsCreate& pipelineCreate)
        {
            node["shaderStages"] >> pipelineCreate.m_ShaderStages;
            node["vertexInputs"] >> pipelineCreate.m_VertexInputs;
            node["defines"] >> pipelineCreate.m_Defines;
            node["mode"] >> pipelineCreate.m_Mode;
            node["depth"] >> pipelineCreate.m_Depth;
            node["polygonMode"] >> pipelineCreate.m_PolygonMode;
            node["cullMode"] >> pipelineCreate.m_CullMode;
            node["frontFace"] >> pipelineCreate.m_FrontFace;
            node["pushDescriptors"] >> pipelineCreate.m_PushDescriptors;
            return node;
        }
 
        friend Node& operator<<(Node& node, const PipelineGraphicsCreate& pipelineCreate)
        {
            node["shaderStages"] << pipelineCreate.m_ShaderStages;
            node["vertexInputs"] << pipelineCreate.m_VertexInputs;
            node["defines"] << pipelineCreate.m_Defines;
            node["mode"] << pipelineCreate.m_Mode;
            node["depth"] << pipelineCreate.m_Depth;
            node["polygonMode"] << pipelineCreate.m_PolygonMode;
            node["cullMode"] << pipelineCreate.m_CullMode;
            node["frontFace"] << pipelineCreate.m_FrontFace;
            node["pushDescriptors"] << pipelineCreate.m_PushDescriptors;
            return node;
        }
 
        const std::vector<VirtualPath>& GetShaderStages() const
        {
            return m_ShaderStages;
        }
 
        const std::vector<Shader::VertexInput>& GetVertexInputs() const
        {
            return m_VertexInputs;
        }
        const std::vector<Shader::Define>& GetDefines() const
        {
            return m_Defines;
        }
        PipelineGraphics::Mode GetMode() const
        {
            return m_Mode;
        }
        PipelineGraphics::Depth GetDepth() const
        {
            return m_Depth;
        }
        VkPrimitiveTopology GetTopology() const
        {
            return m_Topology;
        }
        VkPolygonMode GetPolygonMode() const
        {
            return m_PolygonMode;
        }
        VkCullModeFlags GetCullMode() const
        {
            return m_CullMode;
        }
        VkFrontFace GetFrontFace() const
        {
            return m_FrontFace;
        }
        bool GetPushDescriptors() const
        {
            return m_PushDescriptors;
        }
 
    private:
        std::vector<VirtualPath> m_ShaderStages;
        std::vector<Shader::VertexInput> m_VertexInputs;
        std::vector<Shader::Define> m_Defines;
 
        PipelineGraphics::Mode m_Mode;
        PipelineGraphics::Depth m_Depth;
        VkPrimitiveTopology m_Topology;
        VkPolygonMode m_PolygonMode;
        VkCullModeFlags m_CullMode;
        VkFrontFace m_FrontFace;
        bool m_PushDescriptors;
    };
} // namespace PixelBullet