VulkanPipeline.h

#pragma once
 
// Standard.
#include <memory>
#include <unordered_set>
 
// Custom.
#include "render/general/pipeline/Pipeline.h"
#include "render/general/resource/frame/FrameResourceManager.h"
#include "shader/general/resource/ShaderArrayIndexManager.h"
#include "misc/StdHashes.hpp"
 
// External.
#include "vulkan/vulkan.h"
 
namespace ne {
    class VulkanRenderer;
    class GlslShader;
 
    class VulkanPipeline : public Pipeline {
    public:
        struct InternalResources {
            InternalResources() = default;
 
            VkPipelineLayout pPipelineLayout = nullptr;
 
            VkPipeline pPipeline = nullptr;
 
            VkDescriptorSetLayout pDescriptorSetLayout = nullptr;
 
            VkDescriptorPool pDescriptorPool = nullptr;
 
            std::array<VkDescriptorSet, FrameResourceManager::getFrameResourceCount()> vDescriptorSets;
 
            std::unordered_map<std::string, uint32_t, StdStringHash, std::equal_to<>> resourceBindings;
 
            std::unordered_map<std::string, std::unique_ptr<ShaderArrayIndexManager>>
                shaderArrayIndexManagers;
 
            bool bIsReadyForUsage = false;
        };
 
        VulkanPipeline() = delete;
        VulkanPipeline(const VulkanPipeline&) = delete;
        VulkanPipeline& operator=(const VulkanPipeline&) = delete;
 
        virtual ~VulkanPipeline() override;
 
        static std::variant<std::shared_ptr<VulkanPipeline>, Error> createGraphicsPipeline(
            Renderer* pRenderer,
            PipelineManager* pPipelineManager,
            std::unique_ptr<PipelineConfiguration> pPipelineConfiguration);
 
        static std::variant<std::shared_ptr<VulkanPipeline>, Error> createComputePipeline(
            Renderer* pRenderer, PipelineManager* pPipelineManager, const std::string& sComputeShaderName);
 
        [[nodiscard]] std::optional<Error> bindBuffersIfUsed(
            const std::array<GpuResource*, FrameResourceManager::getFrameResourceCount()>& vResources,
            const std::string& sShaderResourceName,
            VkDescriptorType descriptorType);
 
        [[nodiscard]] std::optional<Error> bindImageIfUsed(
            GpuResource* pImageResourceToBind,
            std::string_view sShaderResourceName,
            VkDescriptorType descriptorType,
            VkImageLayout imageLayout,
            VkSampler pSampler);
 
        inline std::pair<std::recursive_mutex, InternalResources>* getInternalResources() {
            return &mtxInternalResources;
        }
 
    protected:
        [[nodiscard]] virtual std::optional<Error> releaseInternalResources() override;
 
        [[nodiscard]] virtual std::optional<Error> restoreInternalResources() override;
 
    private:
        VulkanPipeline(
            Renderer* pRenderer,
            PipelineManager* pPipelineManager,
            std::unique_ptr<PipelineConfiguration> pPipelineConfiguration);
 
        [[nodiscard]] std::optional<Error> generateGraphicsPipeline();
 
        [[nodiscard]] std::optional<Error>
        generateComputePipelineForShader(const std::string& sComputeShaderName);
 
        [[nodiscard]] std::optional<Error> createGraphicsPipeline(
            VulkanRenderer* pVulkanRenderer,
            GlslShader* pVertexShader,
            GlslShader* pFragmentShader,
            bool bUsePixelBlending);
 
        [[nodiscard]] std::optional<Error>
        createComputePipeline(VulkanRenderer* pVulkanRenderer, GlslShader* pComputeShader);
 
        [[nodiscard]] std::optional<Error> bindFrameDataDescriptors();
 
        std::variant<VkPushConstantRange, Error> definePushConstants(
            const std::unordered_map<std::string, size_t>& pushConstantUintFieldOffsets,
            const std::unordered_map<std::string, uint32_t, StdStringHash, std::equal_to<>>&
                resourceBindings);
 
        std::pair<std::recursive_mutex, InternalResources> mtxInternalResources;
    };
} // namespace ne