PipelineMaterialPayload.cpp

Go to the documentation of this file.

#include "Engine/Renderer/PipelineMaterialPayload.h"
 
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Shader/Shader.h"
 
#include <array>
#include <Engine/Core/VulkanHelper.h>
#include <iostream>
#include <optional>
#include <plog/Log.h>
#include <sstream>
 
namespace EngineCore {
    std::vector<VkSpecializationMapEntry> ComputePipelineSpecializationData::getMapEntries() const {
        return {
            {
                .constantID = 1,
                .offset = offsetof(Data, localSizeX),
                .size = sizeof(uint32_t),
            }
        };
    }
 
    std::vector<VkSpecializationMapEntry> DispatcherComputePipelineSpecializationData::getMapEntries() const {
        return {
            {
                .constantID = 1,
                .offset = offsetof(Data, localSizeX),
                .size = sizeof(uint32_t),
            },
            {
                .constantID = 2,
                .offset = offsetof(Data, nextStageThreadCount),
                .size = sizeof(uint32_t),
            }
        };
    }
 
    std::vector<VkSpecializationMapEntry> MeshShaderSpecializationData::getMapEntries() const {
        return {
            {
                .constantID = 0,  // SCREEN_WIDTH
                .offset = offsetof(Data, screenWidth),
                .size = sizeof(float),
            },
            {
                .constantID = 1,  // SCREEN_HEIGHT
                .offset = offsetof(Data, screenHeight),
                .size = sizeof(float),
            }
        };
    }
 
#if !defined(HEADLESS) && !defined(COMPUTE_DEBUG)
    GraphicsPipeline::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,
                                       bool depthOnly
    )
        : device(device), multisampling(multisampling)
    {
 
        this->pipelineData = pipelineData;
        meshShaderName = meshShaderFilename;
        fragShaderName = fragmentShaderFilename;
 
        // Load the mesh shader
        MeshShader shader = MeshShader(device, meshShaderFilename, fragmentShaderFilename);
 
        // Set up mesh shader specialization info (for screen resolution)
        VkSpecializationInfo meshSpecInfo{};
        std::vector<VkSpecializationMapEntry> meshSpecEntries;
        if (meshShaderSpecialization.has_value()) {
            meshSpecEntries = meshShaderSpecialization.value()->getMapEntries();
            meshSpecInfo = {
                .mapEntryCount = static_cast<uint32_t>(meshSpecEntries.size()),
                .pMapEntries = meshSpecEntries.data(),
                .dataSize = meshShaderSpecialization.value()->getDataSize(),
                .pData = meshShaderSpecialization.value()->getData()
            };
        }
 
        VkPipelineShaderStageCreateInfo pipelineShaderStageCreateInfoMesh{
            VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
        };
        pipelineShaderStageCreateInfoMesh.module = shader.getMeshShader();
        pipelineShaderStageCreateInfoMesh.stage = VK_SHADER_STAGE_MESH_BIT_EXT;
        pipelineShaderStageCreateInfoMesh.pName = "main";
        pipelineShaderStageCreateInfoMesh.pSpecializationInfo = meshShaderSpecialization.has_value() ? &meshSpecInfo : nullptr;
 
        VkPipelineShaderStageCreateInfo pipelineShaderStageCreateInfoFragment{
          VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
        };
        pipelineShaderStageCreateInfoFragment.module = shader.getFragmentShader();
        pipelineShaderStageCreateInfoFragment.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
        pipelineShaderStageCreateInfoFragment.pName = "main";
 
        const std::array shaderStages = { pipelineShaderStageCreateInfoMesh, pipelineShaderStageCreateInfoFragment };
 
        VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo{
          VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
        };
        pipelineViewportStateCreateInfo.viewportCount = 1u;
        pipelineViewportStateCreateInfo.scissorCount = 1u;
 
        VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo{
          VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
        };
        pipelineRasterizationStateCreateInfo.polygonMode = VK_POLYGON_MODE_FILL;
        pipelineRasterizationStateCreateInfo.lineWidth = 1.0f;
        pipelineRasterizationStateCreateInfo.cullMode = pipelineData.cullMode;
 
        VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo{
          VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
        };
        pipelineMultisampleStateCreateInfo.rasterizationSamples = multisampling;
 
        VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo{
          VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
        };
        VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState{};
        pipelineColorBlendAttachmentState.colorWriteMask =
            VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
        pipelineColorBlendAttachmentState.blendEnable = VK_TRUE;
        pipelineColorBlendAttachmentState.srcColorBlendFactor = pipelineData.srcColorBlendFactor;
        pipelineColorBlendAttachmentState.dstColorBlendFactor = pipelineData.dstColorBlendFactor;
        pipelineColorBlendAttachmentState.colorBlendOp = pipelineData.colorBlendOp;
        pipelineColorBlendAttachmentState.srcAlphaBlendFactor = pipelineData.srcAlphaBlendFactor;
        pipelineColorBlendAttachmentState.dstAlphaBlendFactor = pipelineData.dstAlphaBlendFactor;
        pipelineColorBlendAttachmentState.alphaBlendOp = pipelineData.alphaBlendOp;
 
        // Depth-only mode: no color attachments (enables "Double-Speed Z" on NVIDIA/AMD)
        if (depthOnly) {
            pipelineColorBlendStateCreateInfo.attachmentCount = 0;
            pipelineColorBlendStateCreateInfo.pAttachments = nullptr;
        } else {
            pipelineColorBlendStateCreateInfo.attachmentCount = 1;
            pipelineColorBlendStateCreateInfo.pAttachments = &pipelineColorBlendAttachmentState;
        }
 
        VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo{
          VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
        };
        constexpr std::array dynamicStates = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
        pipelineDynamicStateCreateInfo.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
        pipelineDynamicStateCreateInfo.pDynamicStates = dynamicStates.data();
 
        VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo{
          VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
        };
        pipelineDepthStencilStateCreateInfo.depthTestEnable = VK_TRUE;
        pipelineDepthStencilStateCreateInfo.depthWriteEnable = VK_TRUE;
        pipelineDepthStencilStateCreateInfo.depthCompareOp = VK_COMPARE_OP_GREATER;  // Reverse-Z
 
        // Dynamic rendering support - required when using vkCmdBeginRendering
        constexpr VkFormat colorFormat = VK_FORMAT_R8G8B8A8_SRGB;
        constexpr VkFormat depthFormat = VK_FORMAT_D32_SFLOAT;
        VkPipelineRenderingCreateInfo pipelineRenderingCreateInfo{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
            .viewMask = 0b11,  // Stereo: both layers
            .colorAttachmentCount = depthOnly ? 0u : 1u,  // No color for depth-only pass
            .pColorAttachmentFormats = depthOnly ? nullptr : &colorFormat,
            .depthAttachmentFormat = depthFormat,
            .stencilAttachmentFormat = VK_FORMAT_UNDEFINED
        };
 
        VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
        graphicsPipelineCreateInfo.pNext = (renderPass == VK_NULL_HANDLE) ? &pipelineRenderingCreateInfo : nullptr;
        graphicsPipelineCreateInfo.layout = pipelineLayout;
        graphicsPipelineCreateInfo.stageCount = static_cast<uint32_t>(shaderStages.size());
        graphicsPipelineCreateInfo.pStages = shaderStages.data();
        graphicsPipelineCreateInfo.pVertexInputState = nullptr;
        graphicsPipelineCreateInfo.pInputAssemblyState = nullptr;
        graphicsPipelineCreateInfo.pViewportState = &pipelineViewportStateCreateInfo;
        graphicsPipelineCreateInfo.pRasterizationState = &pipelineRasterizationStateCreateInfo;
        graphicsPipelineCreateInfo.pMultisampleState = &pipelineMultisampleStateCreateInfo;
        graphicsPipelineCreateInfo.pColorBlendState = &pipelineColorBlendStateCreateInfo;
        graphicsPipelineCreateInfo.pDynamicState = &pipelineDynamicStateCreateInfo;
        graphicsPipelineCreateInfo.pDepthStencilState = &pipelineDepthStencilStateCreateInfo;
        graphicsPipelineCreateInfo.renderPass = renderPass;
 
        VkResult pipelineCreationResult = vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &pipeline);
        if (pipelineCreationResult != VK_SUCCESS)
        {
            throw std::runtime_error("Failed to create vk graphics pipeline");
        }
    
        // These shader modules can now be destroyed
        shader.destroyShaders(device);
        valid = true;
    }
#else
    GraphicsPipeline::GraphicsPipeline(
        VkDevice device,
        VkSampleCountFlagBits multisampling,
        VkPipelineLayout pipelineLayout,
        VkRenderPass renderPass,
        const std::string & vertexShaderName,
        const std::string & fragmentShaderName
    ) : device(device), multisampling(multisampling)
    {
        auto shader = VertexShader(device, vertexShaderName, fragmentShaderName);
 
        VkPipelineShaderStageCreateInfo vertexStageInfo{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage = VK_SHADER_STAGE_VERTEX_BIT,
            .module = shader.getVertexShader(),
            .pName = "main"
        };
 
        VkPipelineShaderStageCreateInfo fragmentStageInfo{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
            .module = shader.getFragmentShader(),
            .pName = "main"
        };
 
        const std::array shaderStages = { vertexStageInfo, fragmentStageInfo };
 
        VkPipelineVertexInputStateCreateInfo vertexInputState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
            .vertexBindingDescriptionCount = 0,
            .pVertexBindingDescriptions = nullptr,
            .vertexAttributeDescriptionCount = 0,
            .pVertexAttributeDescriptions = nullptr
        };
 
        VkPipelineInputAssemblyStateCreateInfo inputAssemblyState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
            .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
            .primitiveRestartEnable = VK_FALSE
        };
 
        VkPipelineViewportStateCreateInfo viewportState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
            .viewportCount = 1,
            .pViewports = nullptr,
            .scissorCount = 1,
            .pScissors = nullptr
        };
 
        VkPipelineRasterizationStateCreateInfo rasterizationState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
            .polygonMode = VK_POLYGON_MODE_FILL,
            .cullMode = VK_CULL_MODE_NONE,
            .frontFace = VK_FRONT_FACE_CLOCKWISE,
            .lineWidth = 1.0f
        };
 
        VkPipelineMultisampleStateCreateInfo multisampleState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
            .rasterizationSamples = multisampling
        };
 
        VkPipelineDepthStencilStateCreateInfo depthStencilState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
            .depthTestEnable = VK_FALSE,
            .depthWriteEnable = VK_FALSE,
            .depthCompareOp = VK_COMPARE_OP_GREATER  // Reverse-Z
        };
 
        VkPipelineColorBlendAttachmentState colorBlendAttachment{
            .blendEnable = VK_FALSE,
            .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
        };
 
        VkPipelineColorBlendStateCreateInfo colorBlendState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
            .attachmentCount = 1,
            .pAttachments = &colorBlendAttachment
        };
 
        constexpr std::array dynamicStates = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
        VkPipelineDynamicStateCreateInfo dynamicState{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
            .dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()),
            .pDynamicStates = dynamicStates.data()
        };
        
 
        // Define color format for dynamic rendering fallback
        const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_SRGB;
 
        VkPipelineRenderingCreateInfo pipelineRenderingCreateInfo{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
            .pNext = nullptr,
            .viewMask = 0,
            .colorAttachmentCount = 1,
            .pColorAttachmentFormats = &colorFormat,
            .depthAttachmentFormat = VK_FORMAT_UNDEFINED,
            .stencilAttachmentFormat = VK_FORMAT_UNDEFINED
        };
 
        VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo{
            .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
            .pNext = (renderPass == VK_NULL_HANDLE) ? &pipelineRenderingCreateInfo : nullptr,
            .flags = 0,
            .stageCount = static_cast<uint32_t>(shaderStages.size()),
            .pStages = shaderStages.data(),
            .pVertexInputState = &vertexInputState,
            .pInputAssemblyState = &inputAssemblyState,
            .pTessellationState = nullptr,
            .pViewportState = &viewportState,
            .pRasterizationState = &rasterizationState,
            .pMultisampleState = &multisampleState,
            .pDepthStencilState = &depthStencilState,
            .pColorBlendState = &colorBlendState,
            .pDynamicState = &dynamicState,
            .layout = pipelineLayout,
            .renderPass = renderPass,
            .subpass = 0,
            .basePipelineHandle = VK_NULL_HANDLE,
            .basePipelineIndex = -1
        };
 
        VkResult pipelineCreationResult = vkCreateGraphicsPipelines(device, nullptr, 1, &graphicsPipelineCreateInfo, nullptr, &pipeline);
        if (pipelineCreationResult != VK_SUCCESS)
        {
            throw std::runtime_error("Failed to create vk graphics pipeline");
        }
 
        shader.destroyShaders( device );
        valid = true;
    }
#endif
 
    GraphicsPipeline::~GraphicsPipeline()
    {
        if (device && pipeline)
        {
            vkDestroyPipeline(device, pipeline, nullptr);
        }
    }
 
    void GraphicsPipeline::bind(VkCommandBuffer commandBuffer) const
    {
        TRACY_ZONE_SCOPED_NAMED("Bind pipeline");
        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
    }
 
    bool GraphicsPipeline::isValid() const
    {
        return valid;
    }
 
    const std::string GraphicsPipeline::getMeshShaderName() const
    {
        return meshShaderName;
    }
 
    const std::string GraphicsPipeline::getFragShaderName() const
    {
        return fragShaderName;
    }
 
    const PipelineMaterialPayload& GraphicsPipeline::getPipelineMaterialData() const
    {
        return pipelineData;
    }
    bool GraphicsPipeline::operator==(const GraphicsPipeline& other) const
    {
        return getMeshShaderName() == other.getMeshShaderName() &&
               getFragShaderName() == other.getFragShaderName();
    }
}
 
namespace EngineCore
{
    ComputePipeline::ComputePipeline(VkDevice device, VkPipelineLayout layout, std::string shaderFilename, std::optional<const PipelineSpecializationData *> pSpecializationData) : device(device), layout(layout)
    {
        computeShader = new ComputeShader(device, shaderFilename);
 
        VkPipelineShaderStageCreateInfo computeShaderStageInfo{
            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage = VK_SHADER_STAGE_COMPUTE_BIT,
            .module = computeShader->getComputeShaderModule(),
            .pName = "main",
            .pSpecializationInfo = nullptr
        };
 
        VkSpecializationInfo specializationInfo{};
        std::vector<VkSpecializationMapEntry> specializationData;
        if (pSpecializationData.has_value()) {
            specializationData = pSpecializationData.value()->getMapEntries();
            specializationInfo = {
                .mapEntryCount = static_cast<uint32_t>(specializationData.size()),
                .pMapEntries = specializationData.data(),
                .dataSize = pSpecializationData.value()->getDataSize(),
                .pData = pSpecializationData.value()->getData()
            };
            computeShaderStageInfo.pSpecializationInfo = &specializationInfo;
        }
        else
        {
             specializationData = std::vector<VkSpecializationMapEntry>();
        }
 
        VkComputePipelineCreateInfo computePipelineCreateInfo{
            .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .stage = computeShaderStageInfo,
            .layout = layout,
        };
 
        PLOG_FN_VK(vkCreateComputePipelines(device, VK_NULL_HANDLE, 1, &computePipelineCreateInfo, nullptr, &pipeline));
        VulkanHelper::setObjectName(device, pipeline, "ComputePipeline");
    }
 
    ComputePipeline::~ComputePipeline()
    {
        // Only call cleanup if resources haven't been cleaned up yet
        // This is safe because cleanup() properly nullifies handles
        if (pipeline != VK_NULL_HANDLE || computeShader != nullptr) {
            cleanup();
        }
    }
 
    void ComputePipeline::cleanup() {
        if (pipeline != VK_NULL_HANDLE) {
            vkDestroyPipeline(device, pipeline, nullptr);
            pipeline = VK_NULL_HANDLE;  // Zero out the handle to prevent double-destruction
        }
        if (computeShader != nullptr) {
            computeShader->destroyShaders(device);
            delete computeShader;
            computeShader = nullptr;
        }
    }
 
    void ComputePipeline::bind(VkCommandBuffer commandBuffer)
    {
        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
    }
}