SwapchainOpenXR.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 "SwapchainOpenXR.h"
#include "SourcesVulkan/VulkanHelperFunction.h"
#include "SourcesVulkan/VulkanWrapper.h"
 
void SwapchainOpenXR::createSwapchainImageViews()
{
    int swapSize = swapChainImagesXr.size();
 
    auto aspect = vk::ImageAspectFlagBits::eColor;
    if (isDepth) {
        aspect = vk::ImageAspectFlagBits::eDepth;
    }
    swapchainImageViews.resize(swapSize);
    for (uint32_t i = 0; i < swapSize; i++) {
        swapchainImageViews[i] = createImageView(wraps->context.device,
            swapChainImagesXr[i].image,
            swapchainFormat,
            aspect);
 
    }
    
}
 
SwapchainOpenXR::SwapchainOpenXR(int64_t format, const XrViewConfigurationView& vp, WindowAbstract* window, VulkanWrapper* wrapper, XrSession* session)
{
    this->wraps = wrapper;
    this->window = window;
      switch(format) {
        case VK_FORMAT_D16_UNORM:
        case VK_FORMAT_D24_UNORM_S8_UINT:
        case VK_FORMAT_D32_SFLOAT:
          isDepth = true;
          break;
        default:
          isDepth = false;
      }
 
    createSwapchain(vp,session, format);
    createSwapchainImageViews();
}
 
std::tuple<uint32_t, std::optional<vk::Semaphore>> SwapchainOpenXR::acquireImage()
{
    XrSwapchainImageAcquireInfo acquireInfo{ XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO };
 
    uint32_t swapchainImageIndex;
    CHECK_XRCMD(xrAcquireSwapchainImage(xrswapchain.handle, &acquireInfo, &swapchainImageIndex));
 
    XrSwapchainImageWaitInfo waitInfo{ XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO };
    waitInfo.timeout = XR_INFINITE_DURATION;
    CHECK_XRCMD(xrWaitSwapchainImage(xrswapchain.handle, &waitInfo));
 
    currentImage = swapchainImageIndex;
    std::optional<vk::Semaphore> sem;
    return std::tuple<uint32_t, std::optional<vk::Semaphore>>(swapchainImageIndex,sem);
}
 
void SwapchainOpenXR::presentImage(uint32_t imageIndex, vk::Semaphore & renderingFinnished)
{
    throw std::runtime_error("Synchronization with Semaphore is not supported with openxr swapchains");
}
 
void SwapchainOpenXR::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...");
    }
 
    XrSwapchainImageReleaseInfo releaseInfo{ XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO };
    CHECK_XRCMD(xrReleaseSwapchainImage(xrswapchain.handle, &releaseInfo));
}
 
vk::ImageView SwapchainOpenXR::getSwapchainImageView(int elem)
{
    assert(elem < swapchainImageViews.size());
    return swapchainImageViews[elem];
}
 
vk::Image SwapchainOpenXR::getSwapchainImage(int index)
{
    assert(index < swapChainImagesXr.size());
    assert(index < xrSwapchainImagesBase.size());
    return swapChainImagesXr[index].image;
}
 
/*
const Swapchain SwapchainOpenXR::getSwapchainStruct()
{
    return xrswapchain;
}*/
 
void SwapchainOpenXR::cleanup()
{
    xrDestroySwapchain(xrswapchain.handle);
}
 
int SwapchainOpenXR::getAttachmentSize()
{
    assert(swapChainImagesXr.size() == xrSwapchainImagesBase.size());
    return swapChainImagesXr.size();
}
 
vk::Image SwapchainOpenXR::getCurrentImage()
{
    return swapChainImagesXr[currentImage].image;
}
 
void SwapchainOpenXR::createSwapchain( const XrViewConfigurationView & vp, XrSession* xrSession, int64_t format) {
    if (isDepth) {
        D(PRINT("%s",
            Fmt("Creating depth swapchain with dimensions Width=%d Height=%d SampleCount=%d",
                vp.recommendedImageRectWidth, vp.recommendedImageRectHeight, vp.recommendedSwapchainSampleCount).c_str());)
    }else {
        D(PRINT("%s",
            Fmt("Creating swapchain with dimensions Width=%d Height=%d SampleCount=%d",
                vp.recommendedImageRectWidth, vp.recommendedImageRectHeight, vp.recommendedSwapchainSampleCount).c_str());)
    }
 
    // Create the swapchain.
    XrSwapchainCreateInfo swapchainCreateInfo{ XR_TYPE_SWAPCHAIN_CREATE_INFO };
    swapchainCreateInfo.arraySize = 1;
    swapchainCreateInfo.format =  format;
    swapchainCreateInfo.width = vp.recommendedImageRectWidth;
    swapchainCreateInfo.height = vp.recommendedImageRectHeight;
    swapchainCreateInfo.mipCount = 1;
    swapchainCreateInfo.faceCount = 1;
    swapchainCreateInfo.sampleCount = VK_SAMPLE_COUNT_1_BIT;
    auto usages = XR_SWAPCHAIN_USAGE_SAMPLED_BIT | XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT | XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT ;
    if (isDepth) {
        usages |= XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
    }
    else {
        usages |= XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT;
    }
    swapchainCreateInfo.usageFlags = usages;
    
    //Swapchain swapchain;
    xrswapchain.width = swapchainCreateInfo.width;
    xrswapchain.height = swapchainCreateInfo.height;
    swapchainExtent.width = swapchainCreateInfo.width;
    swapchainExtent.height = swapchainCreateInfo.height;
 
    CHECK_XRCMD(xrCreateSwapchain(*xrSession, &swapchainCreateInfo, &xrswapchain.handle));
 
    //xrSwapchains.push_back(swapchain);
    handle = xrswapchain.handle;
 
    uint32_t imageCount;
    CHECK_XRCMD(xrEnumerateSwapchainImages(xrswapchain.handle, 0, &imageCount, nullptr));
 
    std::vector<XrSwapchainImageBaseHeader*> swapchainImages = initPresentation(imageCount, swapchainCreateInfo);
 
    CHECK_XRCMD(xrEnumerateSwapchainImages(xrswapchain.handle, imageCount, &imageCount, swapchainImages[0]));
 
    xrSwapchainImagesBase = swapchainImages;
 
#ifndef NDEBUG
    for (int i = 0; i < swapChainImagesXr.size(); i++) {
        auto name = "image id i: " + std::to_string(i) ;
        name += isDepth ? "depth" : "color";
        vk::DebugUtilsObjectNameInfoEXT debug(vk::ObjectType::eImage, (uint64_t) static_cast<VkImage>(swapChainImagesXr[i].image), name.c_str());
        wraps->context.device.setDebugUtilsObjectNameEXT(debug);
    }
#endif
}
 
std::vector<XrSwapchainImageBaseHeader*> SwapchainOpenXR::initPresentation(uint32_t count, XrSwapchainCreateInfo swapchainInfo) {
    vk::Format format = static_cast<vk::Format>((VkFormat)swapchainInfo.format);
 
 
    if (format == vk::Format::eR8G8B8A8Srgb) {
        format = vk::Format::eR8G8B8A8Unorm;
    }
    if (format == vk::Format::eR8G8B8A8Unorm) {
        //format = vk::Format::eR8G8B8A8UInt;
    }
 
    swapchainFormat = format;
    swapchainExtent = vk::Extent2D(swapchainInfo.width, swapchainInfo.height);
    //swapChainImagesXr.resize(viewNum + 1);
    swapChainImagesXr.resize(count);
 
    std::vector<XrSwapchainImageBaseHeader*> bases(count);
    for (uint32_t i = 0; i < count; ++i) {
        swapChainImagesXr[i] = { XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR };
        bases[i] = reinterpret_cast<XrSwapchainImageBaseHeader*>(&swapChainImagesXr[i]);
    }
    return bases;
}