ComputePass.cpp

Go to the documentation of this file.

#include "Engine/Core/ComputePass.h"
 
#include <stdexcept>
 
#include "Engine/Core/ApplicationContext.h"
#include "Engine/Core/VulkanHelper.h"
#include "Engine/Renderer/PipelineMaterialPayload.h"
 
namespace EngineCore {
    ComputePass::ComputePass(const std::string &name ) : name( name ) {}
 
    void ComputePass::create(
        VkDevice                                                device,
        const VkPipelineLayoutCreateInfo *                      pPipelineLayoutCreateInfo,
        const VkDescriptorSetLayoutCreateInfo *                 pDescriptorSetLayoutCreateInfo,
        std::string                                             shaderName,
        const std::optional<const PipelineSpecializationData *> pSpecializationData
    )
    {
        assert(pDescriptorSetLayoutCreateInfo != nullptr);
        VulkanHelper::createDescriptorSetLayout(device, pDescriptorSetLayoutCreateInfo, nullptr, &descriptorSetLayout, name.append(" Descriptor Set Layout"));
 
        assert(pPipelineLayoutCreateInfo != nullptr);
 
        // Validate inputs before creation
        if (device == VK_NULL_HANDLE) {
            throw std::runtime_error("Invalid device handle in ComputePass::create");
        }
        if (descriptorSetLayout == VK_NULL_HANDLE) {
            throw std::runtime_error("Descriptor set layout creation failed in ComputePass::create");
        }
 
        // Create a local copy of the pipeline layout create info and update it to use the newly created descriptor set layout
        VkPipelineLayoutCreateInfo localPipelineLayoutCreateInfo = *pPipelineLayoutCreateInfo;
        localPipelineLayoutCreateInfo.setLayoutCount = 1;
        localPipelineLayoutCreateInfo.pSetLayouts = &descriptorSetLayout;
 
        PLOGD << "Creating pipeline layout for ComputePass: " << name;
        VulkanHelper::createPipelineLayout(device, &localPipelineLayoutCreateInfo, nullptr, &pipelineLayout, name.append(" Pipeline Layout"));
 
        // Validate the result
        if (pipelineLayout == VK_NULL_HANDLE) {
            throw std::runtime_error("Pipeline layout creation failed - returned null handle in ComputePass::create");
        }
 
        // Log the handle value for debugging
        PLOGD << "Created pipeline layout with handle: 0x" << std::hex << pipelineLayout;
 
        computePipeline = new ComputePipeline(device, pipelineLayout, shaderName, pSpecializationData);
 
        if (pSpecializationData)
            extractSpecializationData(pSpecializationData);
 
        PLOGI << "Created ComputePass " << name;
    }
 
    uint32_t ComputePass::getThreadCount() const {
        return threadCount;
    }
 
    DispatcherComputePass::DispatcherComputePass(const std::string &name) : ComputePass(name) {
    }
 
    uint32_t DispatcherComputePass::getTargetThreadCount() const {
        return targetThreadCount;
    }
 
    void DispatcherComputePass::extractSpecializationData(
        std::optional<const PipelineSpecializationData *> pSpecializationData
    ) {
        if (!pSpecializationData.has_value())
        {
            PLOGE << "Specialization Data is empty! This will cause the Dispatcher Compute Pass for " << getName() << " to have a thread count of 1. This applies for both this compute pass as well as for the assumed size of the next pass. Fix this as this will cause performance problems!";
            threadCount = 1;
            targetThreadCount = 1;
            return;
        }
        const auto specializationData = dynamic_cast<const DispatcherComputePipelineSpecializationData*>(pSpecializationData.value());
        threadCount = specializationData->getThreadCount();
        targetThreadCount = specializationData->getThreadCount();
    }
 
    VkPipelineLayout& ComputePass::getPipelineLayout() {
        return pipelineLayout;
    }
 
    ComputePipeline * ComputePass::getComputePipeline() {
        return computePipeline;
    }
 
    VkDescriptorSetLayout& ComputePass::getDescriptorSetLayout()
    {
        return descriptorSetLayout;
    }
 
    VkPushConstantsInfo ComputePass::createPushConstantsInfo(uint32_t size, const void* pValues) const
    {
        assert(pipelineLayout);
        return {
            .sType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO,
            .pNext = nullptr,
            .layout = pipelineLayout,
            .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
            .offset = 0,
            .size = size,
            .pValues = pValues
        };
    }
 
    void ComputePass::createDescriptorSet(VkDevice device, uint32_t frameInFlightIndex, VkDescriptorPool descriptorPool) {
        assert(descriptorPool != VK_NULL_HANDLE);
        VkDescriptorSetAllocateInfo descriptorSetAllocateInfo{
            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
            .descriptorPool = descriptorPool,
            .descriptorSetCount = 1u,
            .pSetLayouts = &descriptorSetLayout
        };
        VulkanHelper::allocateDescriptorSets(device, &descriptorSetAllocateInfo, &descriptorSet[frameInFlightIndex], getName());
        PLOGI << "Created descriptor set: " << VulkanHelper::getDebugName( descriptorSet[frameInFlightIndex] );
    }
 
    DescriptorSetUpdater & ComputePass::updateDescriptorSet(uint32_t frameInFlightIndex) {
        PLOGI << "Creating descriptor set " << VulkanHelper::getDebugName( computePipeline ) << " for eye " << frameInFlightIndex;
        descriptorSetBuilder = DescriptorSetUpdater(getDescriptorSet(frameInFlightIndex));
        return descriptorSetBuilder;
    }
 
    VkDescriptorSet ComputePass::getDescriptorSet(uint32_t frameInFlightIndex) const {
        assert(descriptorSet.size() > frameInFlightIndex);
        return descriptorSet[frameInFlightIndex];
    }
 
    void ComputePass::bindDescriptorSets(VkCommandBuffer commandBuffer, uint32_t frameInFlightIndex) {
        vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1u, &descriptorSet[frameInFlightIndex], 0u, nullptr);
    }
 
    void ComputePass::cleanup(VkDevice device) {
        // Guard against multiple cleanup calls
        if (cleanedUp) {
            PLOGW << "ComputePass::cleanup() called multiple times for " << name << ". Ignoring subsequent calls.";
            return;
        }
        cleanedUp = true;
        
        if (computePipeline != nullptr) {
            computePipeline->cleanup();
            delete computePipeline;
            computePipeline = nullptr;
        }
        
        if (pipelineLayout != VK_NULL_HANDLE) {
            vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
            pipelineLayout = VK_NULL_HANDLE;
        }
        
        if (descriptorSetLayout != VK_NULL_HANDLE) {
            vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
            descriptorSetLayout = VK_NULL_HANDLE;
        }
    }
 
    void ComputePass::cleanup(ApplicationContext *context) {
        cleanup(context->getVkDevice());
    }
 
    void ComputePass::extractSpecializationData(std::optional<const PipelineSpecializationData*> pSpecializationData) {
        if ( !pSpecializationData.has_value() )
            return;
 
        const auto specializationPtr = dynamic_cast<const ComputePipelineSpecializationData*>(pSpecializationData.value());
        threadCount = specializationPtr->getThreadCount();
    }
}