VulkanPipelineBlending.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 "VulkanPipelineBlending.h"
#include "VulkanContext.h"
#include "Shader.h"
#include "BuffersControllerBlending.h"
//#include "../RVSConfig/include/Application.h"
#include "VulkanRenderPass.h"
#include "VulkanWrapper.h"
 
VulkanPipelineBlending::VulkanPipelineBlending(VulkanContext* context, VulkanRenderPass* renderPass, VulkanWrapper* wraps, int inputCameraId)
{
    this->context = context;
    this->renderPass = renderPass;
    this->wrapper = wraps;
    this->depthWrite = false;
 
    this->subPass = 2 * inputCameraId + 1;
    this->inputId = inputCameraId;
 
    this->bufferController = std::make_unique<BufferControllerBlending>(context, renderPass, this, wraps, inputCameraId);
 
    if (inputCameraId == this->renderPass->inputImage - 1) {
        this->colorAttachmentNb = 1;
        if (wrapper->isDepthOutputRecquired()) {
            this->depthWrite = true;
        }
    }
    else {
        if (wrapper->isDepthOutputRecquired()) {
            this->colorAttachmentNb = 3;
        }
        else {
            this->colorAttachmentNb = 2; //outputAttachement 
        }
    }
 
 
 
    this->depthTest = false;
 
}
 
void VulkanPipelineBlending::init()
{
    createDescriptorSetLayout();
    createGraphicsPipeline();
    bufferController->init();
}
 
void VulkanPipelineBlending::cleanUp()
{
    bufferController->cleanUp();
    context->device.destroy(descriptorSetLayout);
    context->device.destroyPipeline(pipeline);
    context->device.destroyPipelineLayout(pipelineLayout);
}
 
void VulkanPipelineBlending::createDescriptorSetLayout()
{
    vk::DescriptorSetLayoutBinding uboLayoutBinding(
        1,                          //binding
        vk::DescriptorType::eUniformBuffer, //descriptor type
        1,                              //descriptorCount
        vk::ShaderStageFlagBits::eFragment, //stageFlags
        nullptr             //pimmutable sampler
    );
    vk::DescriptorSetLayoutBinding accu_imageLayoutBinding(
        2,                          //binding
        vk::DescriptorType::eInputAttachment, //descriptor type
        1,                              //descriptorCount
        vk::ShaderStageFlagBits::eFragment, //stageFlags
        nullptr             //pimmutable sampler
    );
    //input AttachementDescriptor
    vk::DescriptorSetLayoutBinding new_imageLayoutBinding(
        3,                          //binding
        vk::DescriptorType::eInputAttachment, //descriptor type
        1,                              //descriptorCount
        vk::ShaderStageFlagBits::eFragment, //stageFlags
        nullptr             //pimmutable sampler
    );
    vk::DescriptorSetLayoutBinding accu_qualityLayoutBinding(
        4,                          //binding
        vk::DescriptorType::eInputAttachment, //descriptor type
        1,                              //descriptorCount
        vk::ShaderStageFlagBits::eFragment, //stageFlags
        nullptr             //pimmutable sampler
    );
    vk::DescriptorSetLayoutBinding new_triangle_qualityLayoutBinding(
        5,                          //binding
        vk::DescriptorType::eInputAttachment, //descriptor type
        1,                              //descriptorCount
        vk::ShaderStageFlagBits::eFragment, //stageFlags
        nullptr             //pimmutable sampler
    );
    vk::DescriptorSetLayoutBinding new_depthLayoutBinding(
        6,                          //binding
        vk::DescriptorType::eInputAttachment, //descriptor type
        1,                              //descriptorCount
        vk::ShaderStageFlagBits::eFragment, //stageFlags
        nullptr             //pimmutable sampler
    );
 
 
 
 
    std::vector<vk::DescriptorSetLayoutBinding> bindings = { uboLayoutBinding, new_imageLayoutBinding,new_triangle_qualityLayoutBinding, new_depthLayoutBinding,
    accu_imageLayoutBinding, accu_qualityLayoutBinding};
 
    if (wrapper->isDepthOutputRecquired()) {
        vk::DescriptorSetLayoutBinding accu_depthLayoutBinding(
            7,                          //binding
            vk::DescriptorType::eInputAttachment, //descriptor type
            1,                              //descriptorCount
            vk::ShaderStageFlagBits::eFragment, //stageFlags
            nullptr             //pimmutable sampler
        );
        bindings.push_back(accu_depthLayoutBinding);
    }
 
    vk::DescriptorSetLayoutCreateInfo layoutInfo(vk::DescriptorSetLayoutCreateFlags(), static_cast<uint32_t>(bindings.size()), bindings.data());
 
    descriptorSetLayout = context->device.createDescriptorSetLayout(layoutInfo);
}
 
void VulkanPipelineBlending::createGraphicsPipeline()
{
    vk::ShaderModule vertShaderModule = createShaderModule(ShadersList::getInstance()("blending.vert"));
    vk::ShaderModule fragShaderModule;
 
    
    if (wrapper->isDepthOutputRecquired()) {
        
        if (inputId == 0 && inputId == renderPass->inputImage - 1) {
            //use a modified shader for the first input and only input
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blendingFirstFinalD.frag"));
        }
        else if (inputId == 0) {
            //use a modified shader for the first input
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blendingFirstD.frag"));
        }
        else if (inputId == renderPass->inputImage - 1) {
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blendingFinalD.frag"));
        }
        else {
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blendingD.frag"));
        }
    }
    else {
        if (inputId == 0 && inputId == renderPass->inputImage - 1) {
            //use a modified shader for the first input and only input
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blendingFirstFinal.frag"));
        }
        else if (inputId == 0) {
            //use a modified shader for the first input
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blendingFirst.frag"));
        }
        else if (inputId == renderPass->inputImage - 1) {
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blendingFinal.frag"));
        }
        else {
            fragShaderModule = createShaderModule(ShadersList::getInstance()("blending.frag"));
        }
    }
 
    std::vector<vk::PipelineShaderStageCreateInfo> pipelineShaderStageCreateInfos = {
      vk::PipelineShaderStageCreateInfo(
        vk::PipelineShaderStageCreateFlags(), vk::ShaderStageFlagBits::eVertex, vertShaderModule, "main"), //main is entry point of the shader
      vk::PipelineShaderStageCreateInfo(
        vk::PipelineShaderStageCreateFlags(), vk::ShaderStageFlagBits::eFragment, fragShaderModule, "main")
    };
 
    this->createPipeline(pipelineShaderStageCreateInfos);
 
    context->device.destroyShaderModule(vertShaderModule);
    context->device.destroyShaderModule(fragShaderModule);
}