VulkanPipelineAbstract.cpp

/* ----------------------
* Copyright 2023 Université Libre de Bruxelles(ULB), Universidad Politécnica de Madrid(UPM), CREAL, Deutsches Zentrum für Luft - und Raumfahrt(DLR)
 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at < http://www.apache.org/licenses/LICENSE-2.0>
 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissionsand
* limitations under the License.
---------------------- */
 
#include"VulkanPipelineAbstract.h"
#include "VulkanContext.h"
#include "VulkanRenderPass.h"
#include "Shader.h"
#include <iostream>
#include "VulkanWrapper.h"
 
vk::ShaderModule VulkanPipelineAbsract::createShaderModule(const Shader& shader)
{
    vk::ShaderModuleCreateInfo shaderModuleCreateInfo(vk::ShaderModuleCreateFlags(), shader.size, reinterpret_cast<const uint32_t*>(shader.source));
    vk::ShaderModule shaderModule = context->device.createShaderModule(shaderModuleCreateInfo);
#ifndef NDEBUG
    vk::DebugUtilsObjectNameInfoEXT debug(vk::ObjectType::eShaderModule, (uint64_t) static_cast<VkShaderModule>(shaderModule), shader.name.c_str());
    context->device.setDebugUtilsObjectNameEXT(debug);
#endif // !NDEBUG
 
    return shaderModule;
}
 
void VulkanPipelineAbsract::createPipeline(std::vector<vk::PipelineShaderStageCreateInfo>& pipelineShaderStageCreateInfos)
{
    auto descr = bufferController->getAttributeDescription();
    D(std::cout << "pipeline attribute descrp: " << descr.size() << std::endl;)
 
    auto descrBinding = bufferController->getBindingDescription();
 
    vk::PipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo(
        vk::PipelineVertexInputStateCreateFlags(),  // flags
        1,                                          // vertexBindingDescriptions Count
        &(descrBinding),              // vertexBindingDescriptions
        static_cast<uint32_t>((descr).size()), // vertexAttributeDescriptionsCount
        (descr.data())         // vertexAttributeDescriptions
    );
 
    vk::PipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateCreateInfo(
        vk::PipelineInputAssemblyStateCreateFlags(), // Flags
        vk::PrimitiveTopology::eTriangleList, // Topology
        0 // Primitive restart enable
    );
 
    
    //vk::Rect2D scissor{ {0,0},renderPass->renderingExtent };
 
    //viewport state
    vk::PipelineViewportStateCreateInfo pipelineViewportStateCreateInfo(
        vk::PipelineViewportStateCreateFlags(),
        1, &renderPass->viewport, 1, &renderPass->scissor);
 
    //rasterizer
    vk::PipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo(
        vk::PipelineRasterizationStateCreateFlags(),  // flags
        false,                                        // depthClampEnable
        false,                                        // rasterizerDiscardEnable
        vk::PolygonMode::eFill,                       // polygonMode
        vk::CullModeFlagBits::eNone,                  // cullMode
        vk::FrontFace::eClockwise,                    // frontFace
        false,                                        // depthBiasEnable
        0.0f,                                         // depthBiasConstantFactor
        0.0f,                                         // depthBiasClamp
        0.0f,                                         // depthBiasSlopeFactor
        1.0f                                          // lineWidth
    );
 
    vk::PipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo(
        vk::PipelineMultisampleStateCreateFlags(),  // flags
        vk::SampleCountFlagBits::e1                 // rasterizationSamples
                                                    // other values can be default
    );
 
    //depthStencil ?
 
    vk::PipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo(
        vk::PipelineDepthStencilStateCreateFlags(),  // flags
        true,                                        // depthTestEnable
        true,                                        // depthWriteEnable
        (! this->depthTest && depthWrite) ? vk::CompareOp::eAlways : vk::CompareOp::eLess,                 // depthCompareOp
        false,                                       // depthBoundTestEnable
        false,                                       // stencilTestEnable
        {},                              // front
        {},                               // back
        0.0f,                           //minDepthBounds
        1.0f                            //maxDepthBounds
    );
 
    //color blending
    vk::ColorComponentFlags colorComponentFlags(vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG |
        vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA);
    vk::PipelineColorBlendAttachmentState pipelineColorBlendAttachmentState(
        false,                   // blendEnable
        vk::BlendFactor::eOne,  // srcColorBlendFactor //change this for alpha blending
        vk::BlendFactor::eZero,  // dstColorBlendFactor //change this for alpha blending
        vk::BlendOp::eAdd,       // colorBlendOp
        vk::BlendFactor::eOne,  // srcAlphaBlendFactor
        vk::BlendFactor::eZero,  // dstAlphaBlendFactor
        vk::BlendOp::eAdd,       // alphaBlendOp
        colorComponentFlags      // colorWriteMask
    );
 
    //std::array<vk::PipelineColorBlendAttachmentState, 3> pipelineColorBlendAttachementArray = { pipelineColorBlendAttachmentState,pipelineColorBlendAttachmentState,pipelineColorBlendAttachmentState };
    std::vector<vk::PipelineColorBlendAttachmentState> pipelineColorBlendAttachementArray(colorAttachmentNb, pipelineColorBlendAttachmentState);
 
    vk::PipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo(
        vk::PipelineColorBlendStateCreateFlags(),  // flags
        false,                                     // logicOpEnable
        vk::LogicOp::eCopy,                        // logicOp  //TODO check this
        static_cast<uint32_t>(pipelineColorBlendAttachementArray.size()),
        pipelineColorBlendAttachementArray.data(),         // attachments
        { { 0.0f, 0.0f, 0.0f, 0.0f } }             // blendConstants
    );
 
    //dynamic state
    //std::array<vk::DynamicState, 2>    dynamicStates = { vk::DynamicState::eViewport, vk::DynamicState::eScissor };
    //vk::PipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo(vk::PipelineDynamicStateCreateFlags(), dynamicStates.size(), dynamicStates.data());
 
    //pipeline Layout
    vk::PipelineLayoutCreateInfo pipelineLayoutInfo(
        vk::PipelineLayoutCreateFlags(),     //flags
        1,              //layoutCount
        &descriptorSetLayout,       //pSetLayout
        0,              //pushConstantRangeCount
        nullptr);       //pushConstantRange
    pipelineLayout = context->device.createPipelineLayout(pipelineLayoutInfo);
 
    //pipelineInfo
    vk::GraphicsPipelineCreateInfo graphicsPipelineCreateInfo(
        vk::PipelineCreateFlags(),              // flags
        pipelineShaderStageCreateInfos.size(),  //stageCount
        pipelineShaderStageCreateInfos.data(),         // stages
        &pipelineVertexInputStateCreateInfo,    // pVertexInputState
        &pipelineInputAssemblyStateCreateInfo,  // pInputAssemblyState
        nullptr,                                // pTessellationState
        &pipelineViewportStateCreateInfo,       // pViewportState
        &pipelineRasterizationStateCreateInfo,  // pRasterizationState
        &pipelineMultisampleStateCreateInfo,    // pMultisampleState
        depthTest || depthWrite ? &pipelineDepthStencilStateCreateInfo : nullptr,   // pDepthStencilState
        &pipelineColorBlendStateCreateInfo,     // pColorBlendState
        nullptr,                                // pDynamicState
        pipelineLayout,                         // layout
        renderPass->renderPass,                              // renderPass
        subPass                                 //subPass
    );
 
    std::array<vk::DynamicState, 2> dynamicStates = { vk::DynamicState::eViewport, vk::DynamicState::eScissor };
    vk::PipelineDynamicStateCreateInfo dynamicInfo(
        vk::PipelineDynamicStateCreateFlags(),
        static_cast<uint32_t> (dynamicStates.size()),
        dynamicStates.data()
    );
 
    if (wrapper->isUsingDifferentViewSize() && wrapper->multiviewSetup) {
        //vk::DynamicState::eViewport
        graphicsPipelineCreateInfo.pDynamicState = &dynamicInfo;
 
    }
 
#ifdef __ANDROID__
    pipeline = context->device.createGraphicsPipeline(nullptr, graphicsPipelineCreateInfo);
#else
    vk::Result   result;
    std::tie(result, pipeline) = context->device.createGraphicsPipeline(nullptr, graphicsPipelineCreateInfo);
 
    switch (result)
    {
    case vk::Result::eSuccess: break;
    case vk::Result::ePipelineCompileRequiredEXT:
        // something meaningfull here
        throw std::runtime_error("failed to create graphics pipeline! result was ePipelineCompileRequiredEXT");
        break;
    default: throw std::runtime_error("failed to create graphics pipeline!");;  // should never happen
    }
#endif
}
 
uint32_t VulkanPipelineAbsract::getIndexNumber()
{
    return bufferController->getIndiceCount();
}
 
 
void VulkanPipelineAbsract::cmdBufferBindBuffer(vk::CommandBuffer& cmdBuffer, int index, InputProvider::StreamFrameInfo& frameInfo, int view)
{
    bufferController->bindBuffers(cmdBuffer, index, frameInfo,  view);
}
 
 
void VulkanPipelineAbsract::updateAllBuffer(uint32_t currentImage, int view)
{
    bufferController->updateAllUniformBuffer(currentImage, view);
}
 
void VulkanPipelineAbsract::updateBuffer(uint32_t currentImage, int view)
{
    bufferController->updateUniformBuffer(currentImage, view);
}