VulkanDrawing.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 "VulkanDrawing.h"
#include"VulkanContext.h"
#include"VulkanRenderPassAbstract.h"
#include "VulkanWrapper.h"
#include "VulkanHelperFunction.h"
#include<iostream>
#include"../WindowAbstract.h"
//#include"../RVSConfig/include/Config.h"
#include"InputProvider.h"
 
#ifdef __ANDROID__
static const char* kTAG = "drawing";
#define LOGI(...) \
  ((void)__android_log_print(ANDROID_LOG_INFO, kTAG, __VA_ARGS__))
#endif
 
//using rvs::detail::ColorSpace;
//using rvs::detail::g_color_space;
 
VulkanDrawing::VulkanDrawing(VulkanContext* context, VulkanRenderPassAbstract* renderPass, WindowAbstract * window, VulkanWrapper * wraps)
{
    this->context = context;
    this->renderPass = renderPass;
    this->window = window;
    this->wrapper = wraps;
    
}
 
void VulkanDrawing::init(InputProvider* inputProvider)
{
    this->inputProvider = inputProvider;
    viewNumber = window->getViewNumber(); //get the nb of sawpchain
    for(int i = 0 ; i < viewNumber; i++){
        currentFrame.push_back(0);
    }
 
  createCommandPool();
    createCommandBuffers();
    createSyncObjects();
    initialized = true;
 
 
    //streamFrameInfos.resize(inputProvider->enumerateStreamsParameters().size());
}
 
void VulkanDrawing::cleanup() {
    for (int view = 0; view < viewNumber; view++) {
        
        /*if (window->useOpenXR()) {
            for (size_t i = 0; i < window->getViewNumber(); i++) {
                //context->device.destroySemaphore(renderFinishedSemaphores[view][i]);
                context->device.destroyFence(inFlightFences[view][i]);
            }
        }
        else {*/ 
            for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
                if (i < wrapper->getAttachmentSize()) {
                    //context->device.destroySemaphore(renderFinishedSemaphores[view][i]);
                    //context->device.destroySemaphore(imageAvailableSemaphores[view][i]);
                    context->device.destroyFence(inFlightFences[view][i]);
                }
            }
        //}
    }
    //renderFinishedSemaphores.clear();
    //execFences.clear();
    //imageAvailableSemaphores.clear();
    inFlightFences.clear();
    imagesInFlight.clear();
 
 
    
 
    context->device.destroyCommandPool(commandPool); //will automaticly destroy command buffers
    commandBuffers.clear();
}
 
 
 
vk::Fence VulkanDrawing::submitDrawCall(std::tuple<int , uint32_t> idImage, const std::vector<vk::Semaphore> & imageAvailableSemaphores, std::vector<vk::Semaphore> & signalSemaphore, uint32_t depthIndex) {
    
    int view;
    uint32_t imageIndex;
    std::tie(view, imageIndex) = idImage;
    currentFrame[view] = imageIndex;
 
    D(if (wrapper->isDepthOutputRecquired()) { assert(imageIndex == depthIndex); })
 
    context->device.waitForFences(1, &inFlightFences[view][currentFrame[view]], true, UINT64_MAX);
 
 
 
    auto streamFrameInfos = wrapper->getFramesInfo(view);
 
    renderPass->updateBuffer(imageIndex, true, streamFrameInfos,view);
 
    //if (resetCommandBuffer) {
        commandBuffers[view][imageIndex].reset(vk::CommandBufferResetFlagBits::eReleaseResources);
        recordCommandBuffers(commandBuffers[view][imageIndex], view, imageIndex, streamFrameInfos);
    //}
 
    if (imagesInFlight[view][imageIndex].has_value()) {
        context->device.waitForFences(1, &imagesInFlight[view][imageIndex].value(), true, UINT64_MAX);
    }
 
    imagesInFlight[view][imageIndex] = inFlightFences[view][currentFrame[view]];
 
 
    vk::PipelineStageFlags waitDestinationStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput);
    context->device.resetFences(1, &inFlightFences[view][currentFrame[view]]);
    if (window->isSwapChainNeeded() ) {
        uint32_t semSize = imageAvailableSemaphores.size();
        vk::SubmitInfo         submitInfo(
            semSize,
            semSize > 0 ? imageAvailableSemaphores.data() : nullptr,//&imageAvailableSemaphores[view][currentFrame[view]],
            semSize > 0 ? &waitDestinationStageMask : nullptr,
            1,
            &commandBuffers[view][imageIndex],
            static_cast<uint32_t>(signalSemaphore.size()),
            signalSemaphore.size() == 0 ? nullptr : signalSemaphore.data()//&renderFinishedSemaphores[view][currentFrame[view]]
        );
        context->graphicsQueue.submit(submitInfo, inFlightFences[view][currentFrame[view]]);
     }
    else {
        vk::SubmitInfo         submitInfo(
            0,
            {},
            nullptr,
            1,
            &commandBuffers[view][imageIndex],
            0,
            nullptr
        );
        context->graphicsQueue.submit(submitInfo, inFlightFences[view][currentFrame[view]]);
 
        const uint32_t timeoutNs = 1 * 1000 * 1000 * 1000;
        for (int i = 0; i < 5; ++i) {
            auto res = context->device.waitForFences(1, &inFlightFences[view][currentFrame[view]], VK_TRUE, timeoutNs);
            if (res == vk::Result::eSuccess) {
                // Buffer can be executed multiple times...
                break;
            }
            std::cout << "Waiting for CmdBuffer fence timed out, retrying..." << std::endl;
        }
    }
    
    
    inputProvider->releaseStreamsFrames();
    /*
    std::variant<vk::Semaphore,vk::Fence> res;
    if (!window->useOpenXR()) {
        res = renderFinishedSemaphores[view][currentFrame[view]];
    }
    else {
        res = 
    }*/
    
    //currentFrame[view] = (currentFrame[view] + 1) % MAX_FRAMES_IN_FLIGHT;
    return inFlightFences[view][currentFrame[view]];
}
 
 
 
 
 
 
 
void VulkanDrawing::createCommandPool()
{
    QueueFamilyIndices queueFamilyIndices = context->findQueueFamilies(context->physicalDevice);
 
    // create a CommandPool to allocate a CommandBuffer from
    vk::CommandPoolCreateFlags flags = vk::CommandPoolCreateFlags();
    //if (resetCommandBuffer) {
        flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
    //}
    vk::CommandPoolCreateInfo commandPoolInfo(flags, queueFamilyIndices.graphicsFamily.value());
    commandPool = context->device.createCommandPool(commandPoolInfo);
}
 
void VulkanDrawing::createCommandBuffers()
{
    commandBuffers.resize(viewNumber);
    // allocate a CommandBuffer from the CommandPool
    for(int view = 0; view < viewNumber; view++) {
        vk::CommandBufferAllocateInfo commandBufferInfo(commandPool,
                                                        vk::CommandBufferLevel::ePrimary,
                                                        (uint32_t) wrapper->getAttachmentSize());
 
        commandBuffers[view] = context->device.allocateCommandBuffers(commandBufferInfo);
 
#ifndef NDEBUG
        for (int i = 0; i < commandBuffers[view].size(); i++) {
            auto name = "cmdBuff Draw v: " + std::to_string(view) + " " + std::to_string(i);
            vk::DebugUtilsObjectNameInfoEXT debug(vk::ObjectType::eCommandBuffer, (uint64_t) static_cast<VkCommandBuffer>(commandBuffers[view][i]), name.c_str());
            context->device.setDebugUtilsObjectNameEXT(debug);
        }
#endif 
 
    }
    
}
 
void VulkanDrawing::recordCommandBuffers(vk::CommandBuffer& buff, int view , int i, std::span<InputProvider::StreamFrameInfo> frameInfos)
{
    const bool renderDirectlyToSwapchain = !context->isIndepFromWindowDimension();
    buff.begin(vk::CommandBufferBeginInfo(vk::CommandBufferUsageFlags()));
 
    renderPass->recordCommandBuffer(buff, i, frameInfos, view);
    //Followings lines are here to blit/copy the image if needed
 
    vk::ImageAspectFlags aspectMask = vk::ImageAspectFlagBits::eColor;
    vk::ImageSubresourceRange subRessources(
        aspectMask, //aspectMask
        0,    //baseMipLevel
        1, //levelCount
        0,    //baseArrayLayer
        1    //layerCount
    );
 
    vk::ImageSubresourceLayers srcRes(vk::ImageAspectFlagBits::eColor, 0, 0, 1);
    vk::ImageSubresourceLayers dstRes(vk::ImageAspectFlagBits::eColor, 0, 0, 1);
 
    uint32_t sourceWidth = wrapper->getSwapchainExtend(view).width;
    uint32_t sourceHeight = wrapper->getSwapchainExtend(view).height;
    std::array<vk::Offset3D, 2> offsetSrc = { vk::Offset3D(0, 0, 0),
                                     //vk::Offset3D(renderPass->renderingExtent.width,
                                    //            renderPass->renderingExtent.height,
        vk::Offset3D(sourceWidth,sourceHeight,1) };
 
    
    if (!renderDirectlyToSwapchain) {
        //for the case where the swapchains images are not in the framebuffer
        //calculation for ratio
        
        
        double wRatio = (double)(window->getSwapchainExtent(view).width) /
            sourceWidth;
            //renderPass->renderingExtent.width;
        double hRatio = (double)(window->getSwapchainExtent(view).height) /
            sourceHeight;
            //renderPass->renderingExtent.height;
        double minRatio = std::min(wRatio, hRatio);
        uint32_t newH = minRatio * sourceHeight;
        uint32_t newW = minRatio * sourceWidth;
 
        if (window->useOpenXR()) {
            wRatio = window->getSwapchainExtent(view).width;
            hRatio = window->getSwapchainExtent(view).height;
        }
        
 
        std::array<vk::Offset3D, 2> offsetDst = { vk::Offset3D(0, 0, 0),
                                                 vk::Offset3D(newW, newH, 1) };
 
 
        if (wrapper->getAttachmentSize() || window->useOpenXR()) {
            //use of Blit Command
 
            //vk::Image dstImage = presentation->swapChainImages[view][i].image;
            vk::Image dstImage = window->getSwapchainImage(view, i);
 
            vk::ImageMemoryBarrier barrierBeforeBlit(
                {},        // srcAccessMask //TODO
                vk::AccessFlagBits::eTransferWrite,        //dstAccesMask   //TODO
                vk::ImageLayout::eUndefined,            //oldLayout
                vk::ImageLayout::eTransferDstOptimal,    //newLayout
                VK_QUEUE_FAMILY_IGNORED, // srcqueueFamily
                VK_QUEUE_FAMILY_IGNORED,    //dstQueueFamily
                dstImage,    //image
                subRessources //subressourcesRange
            );
            buff.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
                vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr,
                0, nullptr, 1, &barrierBeforeBlit);
            //test
            vk::ImageBlit region(srcRes, offsetSrc, dstRes, offsetDst);
            vk::ImageLayout newLayout = window->useOpenXR() ? vk::ImageLayout::eColorAttachmentOptimal : vk::ImageLayout::ePresentSrcKHR;
      /*if (renderPass->inputImage % 2 == 1) {
                //copy attachment 6
                buff.blitImage(renderPass->attachementAccuColor2[i].image,
                    vk::ImageLayout::eTransferSrcOptimal,
                    dstImage,
                    vk::ImageLayout::eTransferDstOptimal, region,
                    vk::Filter::eNearest);
            }
            else {
                //copy attachment 4
                buff.blitImage(renderPass->attachementAccuColor[i].image,
                    vk::ImageLayout::eTransferSrcOptimal,
                    dstImage,
                    vk::ImageLayout::eTransferDstOptimal, region,
                    vk::Filter::eNearest);
      }*/
      buff.blitImage(renderPass->getImageToBlit(i),
        vk::ImageLayout::eTransferSrcOptimal,
        dstImage,
        vk::ImageLayout::eTransferDstOptimal, region,
        vk::Filter::eNearest);
            vk::ImageMemoryBarrier barrier(
                vk::AccessFlagBits::eTransferWrite,        // srcAccessMask //TODO
                vk::AccessFlagBits::eMemoryRead,        //dstAccesMask  //TODO
                vk::ImageLayout::eTransferDstOptimal,    //oldLayout
                newLayout,    //newLayout
                VK_QUEUE_FAMILY_IGNORED, // srcqueueFamily
                VK_QUEUE_FAMILY_IGNORED,    //dstQueueFamily
                dstImage,    //image
                subRessources //subressourcesRange
            );
            buff.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                vk::PipelineStageFlagBits::eTopOfPipe, {}, 0, nullptr,
                0, nullptr, 1, &barrier);
        }
        else {
            //This part concern the mode without window
            //no blit Command for image memory
            vk::ImageSubresourceLayers subRessources(
                vk::ImageAspectFlagBits::eColor, //aspectMask
                0,  //mipLevel
                0, //baseArrayLayer
                1   //layerCount
            );
            vk::BufferImageCopy region(
                0,  //bufferOffset
                0,  //bufferRowLength
                0,  //bufferImageHeight
                subRessources,  //imageSubresource
                { 0,0,0 },  //imageOffset
                { sourceWidth,sourceHeight,1 }  //imageextent
            );
 
      auto buf = window->getRenderingDestination();
      buff.copyImageToBuffer(renderPass->getImageToBlit(i), vk::ImageLayout::eTransferSrcOptimal, buf, 1, &region);
        }
    }
    
    //Ask the windows if there is additional images to blit to
    //Example for the mirror in debug (openxr window) 
    auto destinations = window->getBlitDestinations(view, i);
    auto destinationsExtents = window->getBlitExtentDestinations(view, i);
    if (destinations.size() > 0) {
 
 
        //vk::Image srcImage = presentation->swapChainImages[view][i].image;
 
        vk::Image srcImage = window->getSwapchainImage(view, i);
 
        vk::ImageMemoryBarrier barrierSrcBeforeBlit(
            {},        // srcAccessMask //TODO
            vk::AccessFlagBits::eTransferWrite,        //dstAccesMask   
            vk::ImageLayout::eUndefined,    //oldLayout
            vk::ImageLayout::eTransferSrcOptimal,    //newLayout
            VK_QUEUE_FAMILY_IGNORED, // srcqueueFamily
            VK_QUEUE_FAMILY_IGNORED,    //dstQueueFamily
            srcImage,    //image
            subRessources //subressourcesRange
        );
        for (int d = 0; d < destinations.size(); d++) {
            vk::ImageMemoryBarrier barrierDstBeforeBlit(
                {},        // srcAccessMask 
                vk::AccessFlagBits::eTransferWrite,        //dstAccesMask   
                vk::ImageLayout::eUndefined,    //oldLayout
                vk::ImageLayout::eTransferDstOptimal,    //newLayout
                VK_QUEUE_FAMILY_IGNORED, // srcqueueFamily
                VK_QUEUE_FAMILY_IGNORED,    //dstQueueFamily
                destinations[d],    //image
                subRessources //subressourcesRange
            );
            std::array<vk::ImageMemoryBarrier, 2> barriers = { barrierSrcBeforeBlit,barrierDstBeforeBlit };
            buff.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
                vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr,
                0, nullptr, static_cast<uint32_t>(barriers.size()), barriers.data());
 
            double wRatio = (double)(destinationsExtents[d].width) / (sourceWidth);
            double hRatio = (double)(destinationsExtents[d].height) / (sourceHeight);
            double minRatio = std::min(wRatio, hRatio);
            uint32_t newH = minRatio * sourceHeight;
            uint32_t newW = minRatio * sourceWidth;
            std::array<vk::Offset3D, 2> offsetDst = { vk::Offset3D(0, 0, 0),
                                                 vk::Offset3D(newW, newH , 1) };
            vk::ImageBlit region(srcRes, offsetSrc, dstRes, offsetDst);
            buff.blitImage(srcImage,
                vk::ImageLayout::eTransferSrcOptimal,
                destinations[d],
                vk::ImageLayout::eTransferDstOptimal, region,
                vk::Filter::eNearest);
 
            vk::ImageMemoryBarrier barrierDest(
                vk::AccessFlagBits::eTransferWrite,        // srcAccessMask //TODO
                vk::AccessFlagBits::eMemoryRead,        //dstAccesMask  //TODO
                vk::ImageLayout::eTransferDstOptimal,    //oldLayout
                vk::ImageLayout::ePresentSrcKHR,    //newLayout
                VK_QUEUE_FAMILY_IGNORED, // srcqueueFamily
                VK_QUEUE_FAMILY_IGNORED,    //dstQueueFamily
                destinations[d],    //image
                subRessources //subressourcesRange
            );
            buff.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                vk::PipelineStageFlagBits::eTopOfPipe, {}, 0, nullptr,
                0, nullptr, 1, &barrierDest);
 
        }
 
        vk::ImageMemoryBarrier barrier(
            vk::AccessFlagBits::eTransferWrite,        // srcAccessMask //TODO
            vk::AccessFlagBits::eMemoryRead,        //dstAccesMask  //TODO
            vk::ImageLayout::eTransferSrcOptimal,    //oldLayout
            vk::ImageLayout::eColorAttachmentOptimal,    //newLayout
            VK_QUEUE_FAMILY_IGNORED, // srcqueueFamily
            VK_QUEUE_FAMILY_IGNORED,    //dstQueueFamily
            srcImage,    //image
            subRessources //subressourcesRange
        );
        buff.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
            vk::PipelineStageFlagBits::eTopOfPipe, {}, 0, nullptr,
            0, nullptr, 1, &barrier);
    }
    buff.end();
}
 
void VulkanDrawing::createSyncObjects()
{
    
    /*if (window->useOpenXR()) {
        inFlightFences.resize(viewNumber);
        for (int view = 0; view < viewNumber; view++) {
            int swapSize = wrapper->getAttachmentSize();
            inFlightFences[view].resize(swapSize);
            vk::FenceCreateInfo fenceInfo = {};
            for (size_t i = 0; i < swapSize; i++) {
                inFlightFences[view][i] = context->device.createFence(fenceInfo);
            }
        }
    }
    else {*/
        //imageAvailableSemaphores.resize(viewNumber);
        //renderFinishedSemaphores.resize(viewNumber);
        inFlightFences.resize(viewNumber);
        imagesInFlight.resize(viewNumber);
 
        for (int view = 0; view < viewNumber; view++) {
            //imageAvailableSemaphores[view].resize(MAX_FRAMES_IN_FLIGHT);
            //renderFinishedSemaphores[view].resize(MAX_FRAMES_IN_FLIGHT);
            inFlightFences[view].resize(MAX_FRAMES_IN_FLIGHT);
            imagesInFlight[view].resize(MAX_FRAMES_IN_FLIGHT, std::nullopt);
 
            vk::FenceCreateInfo fenceInfo(vk::FenceCreateFlagBits::eSignaled);
 
            for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
                //renderFinishedSemaphores[view][i] = context->device.createSemaphore(semaphoreInfo);
                //imageAvailableSemaphores[view][i] = context->device.createSemaphore(semaphoreInfo);
                inFlightFences[view][i] = context->device.createFence(fenceInfo);
 
            }
        //}
    }
}
 
bool VulkanDrawing::isInitialized() {
    return initialized;
}