BuffersControllerBlending.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 "BuffersControllerBlending.h"
#include "VulkanHelperFunction.h"
#include "VulkanPipelineBlending.h"
 
#include"VulkanContext.h"
#include"VulkanRenderPass.h"
#include"VulkanWrapper.h"
 
 
BufferControllerBlending::BufferControllerBlending(VulkanContext* context, VulkanRenderPass* renderpass, VulkanPipelineBlending* pipeline, VulkanWrapper* wraps,  int inputView)
{
    this->context = context;
    this->renderpass = renderpass;
    this->pipeline = pipeline;
    this->inputView = inputView;
    this->wrapper = wraps;
 
    attachmentCount = wrapper->multiviewSetup ? wrapper->getViewNumber() : wrapper->getAttachmentSize();
}
 
void BufferControllerBlending::init()
{
    if (inputView == 0) {
        createVertexBuffer();
        createIndexBuffer();
    }
    createUniformBuffer(attachmentCount);
    createDescriptorPool();
    createDescriptorSets();
}
 
void BufferControllerBlending::createVertexBuffer()
{
    std::vector<glm::vec4> vert = {
        {-1.0f, 1.0f, 0.0f, 1.0f},
        {-1.0f, -1.0f, 0.0f, 0.0f},
        {1.0f, -1.0f, 1.0f, 0.0f},
        {1.0f, 1.0f, 1.0f, 1.0f}};
 
    vk::DeviceSize bufferSize = sizeof(glm::vec4) * vert.size();
 
    vk::Buffer stagingBuffer;
    vk::DeviceMemory stagingBufferMemory;
 
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, stagingBuffer, stagingBufferMemory, context->device, context->physicalDevice);
 
    // copy the vertex and color data into that device memory
    void* data;
    context->device.mapMemory(stagingBufferMemory, 0, bufferSize, {}, &data);
    memcpy(data, vert.data(), (size_t)bufferSize);
    context->device.unmapMemory(stagingBufferMemory);
 
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eVertexBuffer, vk::MemoryPropertyFlagBits::eDeviceLocal, vertexBuffer, vertexBufferMemory, context->device, context->physicalDevice);
 
    copyBuffer(stagingBuffer, vertexBuffer, bufferSize);
 
    context->device.destroyBuffer(stagingBuffer, nullptr);
    context->device.freeMemory(stagingBufferMemory, nullptr);
}
 
void BufferControllerBlending::createIndexBuffer()
{
    indices = std::vector<uint32_t>{
    0, 2, 1, 0, 3, 2
    };
 
    indiceCount = static_cast<uint32_t>(indices.size());
 
    vk::DeviceSize bufferSize = sizeof(indices[0]) * indices.size();
    vk::Buffer stagingBuffer;
    vk::DeviceMemory stagingBufferMemory;
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, stagingBuffer, stagingBufferMemory, context->device, context->physicalDevice);
 
    void* data;
    context->device.mapMemory(stagingBufferMemory, 0, bufferSize, {}, &data);
    memcpy(data, indices.data(), (size_t)bufferSize);
    context->device.unmapMemory(stagingBufferMemory);
 
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eIndexBuffer, vk::MemoryPropertyFlagBits::eDeviceLocal, indexBuffer, indexBufferMemory, context->device, context->physicalDevice);
 
    copyBuffer(stagingBuffer, indexBuffer, bufferSize);
 
    context->device.destroyBuffer(stagingBuffer, nullptr);
    context->device.freeMemory(stagingBufferMemory, nullptr);
}
 
void BufferControllerBlending::createUniformBuffer(int size)
{
    VkDeviceSize bufferSize = sizeof(BlendingParameters);
 
    uniformBuffers.resize(size);
    uniformBuffersMemory.resize(size);
 
    for (size_t i = 0; i < size; i++) {
        createBuffer(bufferSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, uniformBuffers[i], uniformBuffersMemory[i], context->device, context->physicalDevice);
    }
}
 
void BufferControllerBlending::createDescriptorPool()
{
    std::array<vk::DescriptorPoolSize, 6> poolSizes{};
    poolSizes[0] = vk::DescriptorPoolSize(vk::DescriptorType::eUniformBuffer, static_cast<uint32_t> (attachmentCount));
    poolSizes[1] = vk::DescriptorPoolSize(vk::DescriptorType::eInputAttachment, static_cast<uint32_t> (attachmentCount));
    poolSizes[2] = vk::DescriptorPoolSize(vk::DescriptorType::eInputAttachment, static_cast<uint32_t> (attachmentCount));
    poolSizes[3] = vk::DescriptorPoolSize(vk::DescriptorType::eInputAttachment, static_cast<uint32_t> (attachmentCount));
    poolSizes[4] = vk::DescriptorPoolSize(vk::DescriptorType::eInputAttachment, static_cast<uint32_t> (attachmentCount));
    poolSizes[5] = vk::DescriptorPoolSize(vk::DescriptorType::eInputAttachment, static_cast<uint32_t> (attachmentCount));
 
    vk::DescriptorPoolCreateInfo poolInfo(
        vk::DescriptorPoolCreateFlags(),    //flags
        static_cast<uint32_t>(attachmentCount), // max sets
        static_cast<uint32_t>(poolSizes.size()),    //pool size
        poolSizes.data()    //pPoolSize
    );
 
    descriptorPool = context->device.createDescriptorPool(poolInfo);
}
 
void BufferControllerBlending::createDescriptorSets()
{
    std::vector<vk::DescriptorSetLayout> layouts(attachmentCount, pipeline->descriptorSetLayout);
 
    vk::DescriptorSetAllocateInfo allocInfo(descriptorPool, static_cast<uint32_t>(attachmentCount), layouts.data());
 
    descriptorSets = context->device.allocateDescriptorSets(allocInfo);
 
    for (size_t i = 0; i < attachmentCount; i++) {
        vk::DescriptorBufferInfo bufferInfo(uniformBuffers[i], 0, sizeof(BlendingParameters));
 
        vk::DescriptorImageInfo imageInfo(nullptr, renderpass->attachementColor[i].imageView, vk::ImageLayout::eShaderReadOnlyOptimal);
        vk::DescriptorImageInfo qualityInfo(nullptr, renderpass->attachementQualityFloat[i].imageView, vk::ImageLayout::eShaderReadOnlyOptimal);
        vk::DescriptorImageInfo depthInfo(nullptr, renderpass->attachementDepthFloat[i].imageView, vk::ImageLayout::eShaderReadOnlyOptimal);
 
        vk::DescriptorImageInfo accuImageInfo(nullptr, renderpass->attachementAccuColor[i].imageView, vk::ImageLayout::eShaderReadOnlyOptimal);
        vk::DescriptorImageInfo accuQualityInfo(nullptr, renderpass->attachementAccuQuality[i].imageView, vk::ImageLayout::eShaderReadOnlyOptimal);
        
        vk::DescriptorImageInfo accuDepthInfo;
 
        if(inputView % 2 == 1){
            accuImageInfo.imageView = renderpass->attachementAccuColor2[i].imageView;
            accuImageInfo.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
 
            accuQualityInfo.imageView = renderpass->attachementAccuQuality2[i].imageView;
            accuQualityInfo.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
        }
 
        
        if (wrapper->isDepthOutputRecquired()) {
            if (inputView % 2 == 1) {
                accuDepthInfo = vk::DescriptorImageInfo(nullptr, renderpass->attachementAccuDepth2[i].imageView, vk::ImageLayout::eShaderReadOnlyOptimal);
            }
            else {
                accuDepthInfo = vk::DescriptorImageInfo(nullptr, renderpass->attachementAccuDepth[i].imageView, vk::ImageLayout::eShaderReadOnlyOptimal);
            }
        }
 
        std::vector<vk::WriteDescriptorSet> descriptorWrites{};
        
 
        if (wrapper->isDepthOutputRecquired()) {
            descriptorWrites.resize(7);
        }
        else {
            descriptorWrites.resize(6);
        }
        descriptorWrites[0] = vk::WriteDescriptorSet(
            descriptorSets[i],
            1, //dstBinding
            0, //dstArrayElement
            1, //descriptorCount
            vk::DescriptorType::eUniformBuffer, //descriptorType
            nullptr,        //pImageInfo
            &bufferInfo, // pBufferInfo
            nullptr         //pTexelBufferView
        );
        descriptorWrites[1] = vk::WriteDescriptorSet(
            descriptorSets[i],
            3, //dstBinding
            0, //dstArrayElement
            1, //descriptorCount
            vk::DescriptorType::eInputAttachment, //descriptorType
            &imageInfo,     //pImageInfo
            nullptr,        // pBufferInfo
            nullptr         //pTexelBufferView
        );
        descriptorWrites[2] = vk::WriteDescriptorSet(
            descriptorSets[i],
            5, //dstBinding
            0, //dstArrayElement
            1, //descriptorCount
            vk::DescriptorType::eInputAttachment, //descriptorType
            &qualityInfo,       //pImageInfo
            nullptr,        // pBufferInfo
            nullptr         //pTexelBufferView
        );
        descriptorWrites[3] = vk::WriteDescriptorSet(
            descriptorSets[i],
            6, //dstBinding
            0, //dstArrayElement
            1, //descriptorCount
            vk::DescriptorType::eInputAttachment, //descriptorType
            &depthInfo,     //pImageInfo
            nullptr,        // pBufferInfo
            nullptr         //pTexelBufferView
        );
        descriptorWrites[4] = vk::WriteDescriptorSet(
            descriptorSets[i],
            2, //dstBinding
            0, //dstArrayElement
            1, //descriptorCount
            vk::DescriptorType::eInputAttachment, //descriptorType
            &accuImageInfo,     //pImageInfo
            nullptr,        // pBufferInfo
            nullptr         //pTexelBufferView
        );
        descriptorWrites[5] = vk::WriteDescriptorSet(
            descriptorSets[i],
            4, //dstBinding
            0, //dstArrayElement
            1, //descriptorCount
            vk::DescriptorType::eInputAttachment, //descriptorType
            &accuQualityInfo,       //pImageInfo
            nullptr,        // pBufferInfo
            nullptr         //pTexelBufferView
        );
 
        if (wrapper->isDepthOutputRecquired()) {
            descriptorWrites[6] = vk::WriteDescriptorSet(
                descriptorSets[i],
                7, //dstBinding
                0, //dstArrayElement
                1, //descriptorCount
                vk::DescriptorType::eInputAttachment, //descriptorType
                &accuDepthInfo,     //pImageInfo
                nullptr,        // pBufferInfo
                nullptr         //pTexelBufferView
            );
        }
        context->device.updateDescriptorSets(static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
 
    }
}
 
void BufferControllerBlending::bindBuffers(vk::CommandBuffer& commandBuffer, int currentSwapIndex, InputProvider::StreamFrameInfo & frameInfos, int view)
{
    int index = wrapper->multiviewSetup ? view : currentSwapIndex ;
    vk::Buffer vertexBuffers[] = { vertexBuffer };
    vk::DeviceSize offsets[] = { 0 };
    commandBuffer.bindVertexBuffers(0, 1, vertexBuffers, offsets);
    commandBuffer.bindIndexBuffer(indexBuffer, 0, vk::IndexType::eUint32);
 
    commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline->pipelineLayout, 0, 1, &descriptorSets[index], 0, nullptr);
}
 
void BufferControllerBlending::updateUniformBuffer(uint32_t currentImage, int view)
{
    //nothing to update for the moment
};
void BufferControllerBlending::updateAllUniformBuffer(uint32_t currentImage, int view)
{
    int index = wrapper->multiviewSetup ? view : currentImage;
 
    this->blendingParam.blendingFactor = wrapper->params.blendingFactor;
    this->blendingParam.ZNearHeadset = wrapper->params.nearPlaneHeadset;
    this->blendingParam.ZFarHeadset = wrapper->params.farPlaneHeadset;
    this->blendingParam.ZFar = wrapper->params.max_depth;
    this->blendingParam.maxMul = wrapper->params.maxMult;
    this->blendingParam.scaleFactor = wrapper->params.scaleFactor;
    
    //float alphaBlend = blendingFactor;
    void* data;
    context->device.mapMemory(uniformBuffersMemory[index], 0, sizeof(BlendingParameters), {}, &data);
    memcpy(data, &this->blendingParam, sizeof(BlendingParameters));
    context->device.unmapMemory(uniformBuffersMemory[index]);
}
 
void BufferControllerBlending::cleanUp()
{
    for (size_t i = 0; i < uniformBuffers.size(); i++) {
        context->device.destroyBuffer(uniformBuffers[i], nullptr);
        context->device.freeMemory(uniformBuffersMemory[i], nullptr);
    }
 
    if (inputView == 0) {
        context->device.destroyBuffer(vertexBuffer);
        context->device.freeMemory(vertexBufferMemory, nullptr);
 
        context->device.destroyBuffer(indexBuffer);
        context->device.freeMemory(indexBufferMemory, nullptr);
    }
 
    context->device.destroyDescriptorPool(descriptorPool);
}
 
vk::VertexInputBindingDescription BufferControllerBlending::getBindingDescription()
{
    vk::VertexInputBindingDescription bindingDescription{
            0,  //binding
            sizeof(glm::vec4), // stride
            vk::VertexInputRate::eVertex //inputRate
    };
    return bindingDescription;
}
 
std::vector<vk::VertexInputAttributeDescription> BufferControllerBlending::getAttributeDescription()
{
    std::vector<vk::VertexInputAttributeDescription> attributeDescriptions{
     vk::VertexInputAttributeDescription(
        0,  //location
        0,  //binding
        vk::Format::eR32G32B32A32Sfloat,        //format
        0   //offset
    ) };
    return attributeDescriptions;
}
 
void BufferControllerBlending::update(std::span<InputProvider::StreamFrameInfo> frameInfo, int view)
{
    //Does nothing for blending
 
    //in OMAF rotation vector is rotation against z axis, y axis, and x axis
    auto R_from = glmEulerAnglesDegreeToRotationMatrix(frameInfo[view].extrinsics.rotation);
    //------------ Virtual camera parameter may not be in OMAF but can be converted to it using the conversion at wrapper->params.conversionToOMAF
    // (in general it would be openxr coordinate system)
    // and the rotation is defined as rotation against x axis, y axis, z axis
    auto R_start = glmEulerAnglesDegreeToRotationMatrixNotOMAF(wrapper->params.getStartingRotation());
    auto R_to = glmEulerAnglesDegreeToRotationMatrixNotOMAF(wrapper->params.getVirtualExtrinsics(view).rotation);
    R_to = (R_start * R_to * glm::transpose(R_start)) * R_start;
    R_to = wrapper->params.conversionToOMAF * R_to * glm::transpose(wrapper->params.conversionToOMAF);
 
    auto R = glm::transpose(R_to) * R_from;
 
    auto t_from = frameInfo[view].extrinsics.position;
    auto t_start = wrapper->params.getStartingPosition();
    auto t_to = wrapper->params.getVirtualExtrinsics(view).position;
    t_to = t_start + R_start * t_to;// *glm::transpose(R_start); // 
 
    t_to = wrapper->params.conversionToOMAF * t_to;
    glm::vec3 T = -glm::transpose(R_to) * (t_to - t_from);
    this->blendingParam.inputDistance = std::max(0.01f, glm::length(T));
}
 
uint32_t BufferControllerBlending::getIndiceCount()
{
    return indiceCount;
}