PipelineMaterialPayload.h

Go to the documentation of this file.

#pragma once
 
#include "Engine/Core/Settings.h"
 
#include <glm/vec4.hpp>
#include <optional>
#include <string>
#include <vector>
#include <vulkan/vulkan.h>
 
class ComputeShader;
namespace EngineCore {
 
 
    class Context;
 
    // [tdbe] uniform properties to bind to a material's shader.
    // properties need to be copied to DynamicVertexUniformData
    struct DynamicMaterialUniformData {
        glm::vec4 colorMultiplier = glm::vec4(1.0f);
    };
 
    // [tdbe] pipeline configurations for this pipeline / "material"
    struct PipelineMaterialPayload {
        VkBlendFactor srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
        VkBlendFactor dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
        VkBlendOp colorBlendOp = VK_BLEND_OP_ADD;
        VkBlendFactor srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
        VkBlendFactor dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
        VkBlendOp alphaBlendOp = VK_BLEND_OP_ADD;
        VkCullModeFlagBits cullMode = VkCullModeFlagBits::VK_CULL_MODE_NONE;
        bool operator==(const PipelineMaterialPayload& other) const
        {
            return
                (srcColorBlendFactor == other.srcColorBlendFactor)
                &&
                (dstColorBlendFactor == other.dstColorBlendFactor)
                &&
                (colorBlendOp == other.colorBlendOp)
                &&
                (srcAlphaBlendFactor == other.srcAlphaBlendFactor)
                &&
                (dstAlphaBlendFactor == other.dstAlphaBlendFactor)
                &&
                (alphaBlendOp == other.alphaBlendOp)
                &&
                (cullMode == other.cullMode);
        }
    };

    class PipelineSpecializationData {
    public:
        virtual ~PipelineSpecializationData() = default;

        virtual std::vector<VkSpecializationMapEntry> getMapEntries() const = 0;
        virtual const void* getData() const = 0;
        virtual size_t getDataSize() const = 0;
    };

    class ComputePipelineSpecializationData : public PipelineSpecializationData {
        struct Data {
            uint32_t localSizeX;
        } data;
    public:
        ComputePipelineSpecializationData(uint32_t threadCount) : data{threadCount} {};

        std::vector<VkSpecializationMapEntry> getMapEntries() const override;

        const void * getData() const override { return &data; }

        size_t getDataSize() const override { return sizeof(data); }

        [[nodiscard]] virtual uint32_t getThreadCount() const { return data.localSizeX; }
    };
 
    class DispatcherComputePipelineSpecializationData : public PipelineSpecializationData {
        struct Data {
            uint32_t localSizeX;
            uint32_t nextStageThreadCount;
        } data;
    public:
        DispatcherComputePipelineSpecializationData(uint32_t threadCount, uint32_t nextStageThreadCount) : data{threadCount, nextStageThreadCount} {};
 
        std::vector<VkSpecializationMapEntry> getMapEntries() const override;
        const void * getData() const override { return &data; }
        size_t getDataSize() const override { return sizeof(data); }
 
        [[nodiscard]] uint32_t getThreadCount() const { return data.localSizeX; }
        [[nodiscard]] uint32_t getNextStageThreadCount() const { return data.nextStageThreadCount; }
    };

    class MeshShaderSpecializationData : public PipelineSpecializationData {
        struct Data {
            float screenWidth;
            float screenHeight;
        } data;
    public:
        MeshShaderSpecializationData(float screenWidth, float screenHeight)
            : data{screenWidth, screenHeight} {}
 
        std::vector<VkSpecializationMapEntry> getMapEntries() const override;
        const void* getData() const override { return &data; }
        size_t getDataSize() const override { return sizeof(data); }
 
        [[nodiscard]] float getScreenWidth() const { return data.screenWidth; }
        [[nodiscard]] float getScreenHeight() const { return data.screenHeight; }
    };
 
    /*
     * The pipeline class wraps a Vulkan pipeline for convenience. It describes the rendering technique to use, including
     * shaders, culling, scissoring (renderable area, similar to viewport (but changing the scissor rect won't affect coordinates),
     * and other aspects.
     */
    class GraphicsPipeline final
    {
    public:
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
        GraphicsPipeline(VkDevice device,
            VkSampleCountFlagBits multisampling,
            VkPipelineLayout pipelineLayout,
            VkRenderPass renderPass,
            const std::string& meshShaderFilename,
            const std::string& fragmentShaderFilename,
            const std::vector<VkVertexInputBindingDescription>& vertexInputBindingDescriptions,
            const std::vector<VkVertexInputAttributeDescription>& vertexInputAttributeDescriptions,
            PipelineMaterialPayload pipelineData,
            std::optional<const MeshShaderSpecializationData*> meshShaderSpecialization = std::nullopt,
            bool depthOnly = false  // When true, creates pipeline with no color attachments for Z-prepass
        );
#else
        GraphicsPipeline(
            VkDevice device,
            VkSampleCountFlagBits multisampling,
            VkPipelineLayout pipelineLayout,
            VkRenderPass renderPass,
            const std::string& vertexShaderName,
            const std::string& fragmentShaderName
        );
#endif
        ~GraphicsPipeline();
 
        void bind(VkCommandBuffer commandBuffer) const;

        bool isValid() const;
 
        const std::string getMeshShaderName() const;
        const std::string getFragShaderName() const;
        const PipelineMaterialPayload& getPipelineMaterialData() const;
 
        bool operator==(const GraphicsPipeline& other) const;
 
    private:
        VkDevice device;
        VkSampleCountFlagBits multisampling;
 
        std::string meshShaderName;
        std::string fragShaderName;
        bool valid = false;
 
        const Context* context = nullptr;
        VkPipeline pipeline = nullptr;
 
        PipelineMaterialPayload pipelineData;
    };

    class ComputePipeline
    {
    public:
        ComputePipeline(
            VkDevice                                          device,
            VkPipelineLayout                                  layout,
            std::string                                       shaderFilename,
            std::optional<const PipelineSpecializationData *> pSpecializationData
        );
        ~ComputePipeline();

        void bind(VkCommandBuffer commandBuffer);

        VkPipeline get() const { return pipeline; }

        void cleanup();
    private:
        VkDevice device = VK_NULL_HANDLE;
        VkPipeline pipeline = VK_NULL_HANDLE;
        ComputeShader* computeShader = nullptr;
        VkPipelineLayout layout = VK_NULL_HANDLE;
    };
 
}