ComputePass.h

Go to the documentation of this file.

#pragma once
#include <array>
#include <optional>
#include "Engine/Renderer/PipelineMaterialPayload.h"
#include "Engine/Renderer/DescriptorSetUpdater.h"
 
namespace EngineCore {
    class ApplicationContext;
}
 
namespace EngineCore {
    class ComputePipeline;
 
    class RenderingPass
    {
    public:
    private:
    };

    class ComputePass : public RenderingPass {
    public:
        virtual ~ComputePass() = default;
 
        ComputePass(
            const std::string& name
        );

        void create(
            VkDevice                                          device,
            const VkPipelineLayoutCreateInfo *                pPipelineLayoutCreateInfo,
            const VkDescriptorSetLayoutCreateInfo *           pDescriptorSetLayoutCreateInfo,
            std::string                                       shaderName,
            std::optional<const PipelineSpecializationData *> pSpecializationData
        );

        [[nodiscard]] uint32_t getThreadCount() const;

        VkPipelineLayout & getPipelineLayout();

        ComputePipeline *getComputePipeline();

        VkDescriptorSetLayout & getDescriptorSetLayout();

        VkPushConstantsInfo createPushConstantsInfo(uint32_t size, const void* pValues) const;

        void createDescriptorSet(VkDevice device, uint32_t frameInFlightIndex, VkDescriptorPool descriptorPool);

        DescriptorSetUpdater & updateDescriptorSet(uint32_t frameInFlightIndex);

        [[nodiscard]] VkDescriptorSet getDescriptorSet(uint32_t frameInFlightIndex) const;

        void bindDescriptorSets(VkCommandBuffer commandBuffer, uint32_t frameInFlightIndex);

        void cleanup(VkDevice device);

        void cleanup(ApplicationContext *context);
 
    protected:
        virtual void extractSpecializationData( std::optional<const PipelineSpecializationData *> pSpecializationData
            );
 
    private:
        DescriptorSetUpdater descriptorSetBuilder{VK_NULL_HANDLE};
 
        std::string name = "Generic Compute";
        VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
        VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
        ComputePipeline* computePipeline = nullptr;
        bool cleanedUp = false;  // Guard to prevent double-cleanup
 
        std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> descriptorSet {VK_NULL_HANDLE};
 
    protected:
        [[nodiscard]] std::string getName() const { return name; }
 
        uint32_t threadCount = 32;
    };
 
    class DispatcherComputePass : public ComputePass{
    public:
        DispatcherComputePass(const std::string &name);
 
        [[nodiscard]] uint32_t getTargetThreadCount() const;
 
    protected:
        void extractSpecializationData( std::optional<const PipelineSpecializationData *> pSpecializationData
        ) override;
        uint32_t targetThreadCount = 32;
 
    };
}