PipelineCompute.hpp

#pragma once
 
#include "PixelBullet/Filesystem/File.hpp"
#include "PixelBullet/Filesystem/VirtualPath.hpp"
#include "PixelBullet/Graphics/Commands/CommandBuffer.hpp"
#include "PixelBullet/Graphics/Pipelines/Pipeline.hpp"
 
#include <glm/glm.hpp>
 
#include <optional>
#include <vector>
 
namespace PixelBullet
{
    class PipelineCompute : public Pipeline
    {
    public:
        explicit PipelineCompute(const VirtualPath& shaderStage, std::vector<Shader::Define> defines = {},
                                 bool pushDescriptors = false);
        ~PipelineCompute();
 
        void CmdRender(const CommandBuffer& commandBuffer, const glm::uvec2& extent) const;
 
        const VirtualPath& GetShaderStage() const
        {
            return m_ShaderStage;
        }
        const std::vector<Shader::Define>& GetDefines() const
        {
            return m_Defines;
        }
        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 CreatePipelineCompute();
 
    private:
        VirtualPath m_ShaderStage;
        std::vector<Shader::Define> m_Defines;
        bool m_PushDescriptors;
 
        std::unique_ptr<Shader> m_Shader;
 
        VkShaderModule m_ShaderModule = VK_NULL_HANDLE;
        VkPipelineShaderStageCreateInfo m_ShaderStageCreateInfo = {};
 
        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;
    };
} // namespace PixelBullet