SwapchainCommon.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 "SwapchainCommon.h"
#include "SourcesVulkan/VulkanWrapper.h"
#include "SourcesVulkan/VulkanHelperFunction.h"
#include "WindowAbstract.h"
 
#include<iostream>
 
SwapchainCommon::SwapchainCommon(VkSurfaceKHR & surface, WindowAbstract * window, VulkanWrapper * wrapper)
{
    assert(window != nullptr);
    assert(surface != VK_NULL_HANDLE);
    assert(wrapper != nullptr);
 
    this->wraps = wrapper;
    this->window = window;
    SwapChainSupportDetails swapChainSupport = window->querySwapChainSupport(wraps->context.physicalDevice);
 
    vk::SurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
    vk::PresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
    vk::Extent2D extent = chooseSwapExtent(swapChainSupport.capabilities);
 
    uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
    if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {
        imageCount = swapChainSupport.capabilities.maxImageCount;
    }
 
    QueueFamilyIndices indices = wraps->context.findQueueFamilies(wraps->context.physicalDevice);
    uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() };
 
    int queueFamilyIndexCount = 0;
    auto imageSharingMode = vk::SharingMode::eExclusive;
    if (indices.graphicsFamily != indices.presentFamily) {
        imageSharingMode = vk::SharingMode::eConcurrent;
        queueFamilyIndexCount = 2;
    }
#ifdef __ANDROID__
    //composite alpha flag
    vk::CompositeAlphaFlagBitsKHR compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eInherit;
#else
    vk::CompositeAlphaFlagBitsKHR compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque;
#endif
 
    auto preTransform = swapChainSupport.capabilities.currentTransform;
#ifdef __ANDROID__
    preTransform = vk::SurfaceTransformFlagBitsKHR::eIdentity;
#endif
 
    vk::SwapchainCreateInfoKHR swapChainCreateInfo(
        vk::SwapchainCreateFlagsKHR(),                              //flags
        static_cast<vk::SurfaceKHR>(surface),         //vk::surface
        imageCount,                                                 //numberOfImage
        surfaceFormat.format,                                       //format
        surfaceFormat.colorSpace,                                   //colorSpace
        extent,                                                     //vk::Extend2D
        1,                                                          //imageArrayLayers
    vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eInputAttachment | vk::ImageUsageFlagBits::eTransferDst,     //imageUsage
        imageSharingMode,                                           //imageSharingMode
        queueFamilyIndexCount,                                      //Queue family index count
        queueFamilyIndexCount > 0 ? queueFamilyIndices : nullptr,    //Queue family indices
        preTransform,             //preTransform
        compositeAlpha,                     //compositeAlpha  //TODO check Alpha
        presentMode,                                                //presentMode   
        true,                                                       //clipped
        nullptr);                                                   //oldSwapchain
 
 
    swapchainFormat = surfaceFormat.format;
    swapchainExtent = extent;
 
    //create the swapChain
    swapChain = wraps->context.device.createSwapchainKHR(swapChainCreateInfo);
    //create the images for the swapChain
    swapChainImages = wraps->context.device.getSwapchainImagesKHR(swapChain);
 
    handle = swapChain;
 
 
    createSwapchainImageView();
    createAcquireSemaphores();
}
 
std::tuple<uint32_t, std::optional<vk::Semaphore> > SwapchainCommon::acquireImage()
{
    uint32_t imageIndex;
    vk::Result acquireResult;
 
    std::tie(acquireResult, imageIndex) = wraps->context.device.acquireNextImageKHR(swapChain, std::numeric_limits<uint64_t>::max(), imageAvailableSemaphores[currentFrame], nullptr);
    if (acquireResult != vk::Result::eSuccess && acquireResult != vk::Result::eSuboptimalKHR) {
        throw std::runtime_error("failed to acquire swap chain image!");
    }
    std::optional<vk::Semaphore> sem = imageAvailableSemaphores[currentFrame];
    return std::tuple<uint32_t, std::optional<vk::Semaphore> >(imageIndex, sem );
}
 
void SwapchainCommon::presentImage(uint32_t imageIndex, vk::Semaphore & renderingFinnished)
{
    vk::PresentInfoKHR presentInfo{ 1,
        &renderingFinnished,
        1,
        &swapChain,
        &imageIndex,
        nullptr };
 
        try {
 
            vk::Result resultPresent = wraps->context.presentQueue.presentKHR(presentInfo);
            if (resultPresent == vk::Result::eSuboptimalKHR || wraps->framebufferResized) {
#ifndef __ANDROID__
                //not doing this for ANDROID for the moment TODO
                wraps->framebufferResized = false;
                wraps->recreateSwapChain();
#endif
            }
            else if (resultPresent != vk::Result::eSuccess) {
                throw std::runtime_error("failed to present swap chain image!");
            }
        }
        catch (vk::OutOfDateKHRError) {
            wraps->recreateSwapChain();
            return;
        }
 
    currentFrame= (currentFrame + 1) % swapchainImageViews.size();
}
 
void SwapchainCommon::presentImage(uint32_t imageIndex, vk::Fence & fence)
{
    assert(fence != (vk::Fence) VK_NULL_HANDLE);
    const uint32_t timeoutNs = 1 * 1000 * 1000 * 1000;
    for (int i = 0; i < 5; ++i) {
        auto res = wraps->context.device.waitForFences(1, &fence, VK_TRUE, timeoutNs);
        if (res == vk::Result::eSuccess) {
            // Buffer can be executed multiple times...
            break;
        }
        PRINT("%s", "Waiting for CmdBuffer fence timed out, retrying...");
    }
 
    vk::PresentInfoKHR presentInfo{ 0,
        nullptr,
        1,
        &swapChain,
        &imageIndex,
        nullptr };
 
    try {
        vk::Result resultPresent = wraps->context.presentQueue.presentKHR(presentInfo);
        if (resultPresent == vk::Result::eSuboptimalKHR || wraps->framebufferResized) {
#ifndef __ANDROID__
            //not doing this for ANDROID for the moment TODO
            wraps->framebufferResized = false;
            wraps->recreateSwapChain();
#endif
        }
        else if (resultPresent != vk::Result::eSuccess) {
            throw std::runtime_error("failed to present swap chain image!");
        }
    }
    catch (vk::OutOfDateKHRError) {
        wraps->recreateSwapChain();
        return;
    }
 
 
    currentFrame = (currentFrame + 1) % swapchainImageViews.size();
}
 
void SwapchainCommon::createSwapchainImageView()
{
    int swapSize = swapChainImages.size();
    swapchainImageViews.resize(swapSize);
    for (uint32_t i = 0; i < swapSize; i++) {
        swapchainImageViews[i] = createImageView(wraps->context.device, swapChainImages[i], swapchainFormat, vk::ImageAspectFlagBits::eColor);
 
    }
    
}
 
void SwapchainCommon::createAcquireSemaphores()
{
    imageAvailableSemaphores.resize(swapchainImageViews.size());
    vk::SemaphoreCreateInfo semaphoreInfo;
    for (auto& sem : imageAvailableSemaphores) {
        sem = wraps->context.device.createSemaphore(semaphoreInfo);
    }
}
 
vk::ImageView SwapchainCommon::getSwapchainImageView(int elem)
{
    assert(elem < swapchainImageViews.size());
    return swapchainImageViews[elem];
}
 
vk::Image SwapchainCommon::getSwapchainImage(int index)
{
    assert(index < swapChainImages.size());
    return swapChainImages[index];
}
 
void SwapchainCommon::cleanup()
{
    PRINT("test clean");
    for (auto & imageView : swapchainImageViews) {
        wraps->context.device.destroyImageView(imageView);
    }
    swapchainImageViews.clear();
 
    for (auto & sem : imageAvailableSemaphores) {
        wraps->context.device.destroySemaphore(sem);
    }
    imageAvailableSemaphores.clear();
    
    wraps->context.device.destroySwapchainKHR(swapChain);
    
}
 
int SwapchainCommon::getAttachmentSize()
{
    return swapchainImageViews.size();
}
 
vk::Image SwapchainCommon::getCurrentImage()
{
    return swapChainImages[currentFrame];
}
 
/*
#ifdef USE_OPENXR
std::variant<XrSwapchain, vk::SwapchainKHR> SwapchainCommon::getSwapchainHandle()
#else
vk::SwapchainKHR SwapchainCommon::getSwapchainHandle()
#endif
{
    assert(swapChain != (vk::SwapchainKHR) VK_NULL_HANDLE);
    return swapChain;
}*/
 
vk::SurfaceFormatKHR SwapchainCommon::chooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& availableFormats)
{
    for (const auto& availableFormat : availableFormats) {
 
        //if (availableFormat.format == vk::Format::eB8G8R8A8Srgb && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
        //  return availableFormat;
        //}
 
        if (availableFormat.format == vk::Format::eB8G8R8Unorm && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
            return availableFormat;
        }
        else if (availableFormat.format == vk::Format::eB8G8R8A8Unorm && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
            return availableFormat;
        }
    }
    return availableFormats[0];
}
 
vk::PresentModeKHR SwapchainCommon::chooseSwapPresentMode(const std::vector<vk::PresentModeKHR>& availablePresentModes)
{
#ifndef __ANDROID__
    for (const auto& availablePresentMode : availablePresentModes) {
        if (availablePresentMode == vk::PresentModeKHR::eMailbox) {
            return availablePresentMode;
        }
    }
#endif
    return vk::PresentModeKHR::eFifo;
}
 
vk::Extent2D SwapchainCommon::chooseSwapExtent(const vk::SurfaceCapabilitiesKHR& capabilities)
{
    if (capabilities.currentExtent.width != UINT32_MAX) {
        return capabilities.currentExtent;
    }
    else {
        int width, height;
 
 
        window->getFrameBufferSize(&width, &height, wraps->context.physicalDevice);
#ifdef __ANDROID__
        PRINT("swap size w= %d, h = %d", width, height);
#endif
 
        vk::Extent2D actualExtent = {
            static_cast<uint32_t>(width),
            static_cast<uint32_t>(height)
        };
 
 
        actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
        actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
 
        return actualExtent;
    }
}