SwapchainCommon Class Reference

Class that encapsulate a vkSwapchainHHR object and the methods linked to it. More...

#include <SwapchainCommon.h>

Inheritance diagram for SwapchainCommon:

Public Member Functions
	SwapchainCommon (VkSurfaceKHR &surface, WindowAbstract *window, VulkanWrapper *wrapper)
std::tuple< uint32_t, std::optional< vk::Semaphore > >	acquireImage () override
void	presentImage (uint32_t imageIndex, vk::Semaphore &renderingFinnished) override
void	presentImage (uint32_t imageIndex, vk::Fence &renderingFinnishedFence) override
vk::ImageView	getSwapchainImageView (int elem) override
vk::Image	getSwapchainImage (int index) override
void	cleanup () override
int	getAttachmentSize () override
vk::Image	getCurrentImage () override
virtual std::tuple< uint32_t, std::optional< vk::Semaphore > >	acquireImage ()=0
virtual void	presentImage (uint32_t imageIndex, vk::Semaphore &renderingFinnished)=0
virtual void	presentImage (uint32_t imageIndex, vk::Fence &renderingFinnishedFence)=0
virtual void	cleanup ()=0
virtual vk::ImageView	getSwapchainImageView (int elem)=0
virtual int	getAttachmentSize ()=0
virtual vk::Image	getSwapchainImage (int index)=0
virtual vk::Image	getCurrentImage ()=0

Additional Inherited Members
Data Fields inherited from SwapchainAbstract
std::variant< vk::SwapchainKHR >	handle
vk::Extent2D	swapchainExtent
vk::Format	swapchainFormat
Protected Attributes inherited from SwapchainAbstract
std::vector< vk::ImageView >	swapchainImageViews
VulkanWrapper *	wraps = nullptr
WindowAbstract *	window = nullptr

Detailed Description

Class that encapsulate a vkSwapchainHHR object and the methods linked to it.

Class that encapsulates an OpenXR swapchain and functions associated to it.

Definition at line 36 of file SwapchainCommon.h.

Constructor & Destructor Documentation

SwapchainCommon()

SwapchainCommon::SwapchainCommon	(	VkSurfaceKHR &	surface,
		WindowAbstract *	window,
		VulkanWrapper *	wrapper
	)

Constructor

Definition at line 23 of file SwapchainCommon.cpp.

{
    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();
}

Member Function Documentation

acquireImage()

std::tuple< uint32_t, std::optional< vk::Semaphore > > SwapchainCommon::acquireImage ( )

overridevirtual

Acquire the next image that will be the rendering target and optionnaly the semaphore signalling when the image is available

Implements SwapchainAbstract.

Definition at line 97 of file SwapchainCommon.cpp.

{
    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 );
}

cleanup()

void SwapchainCommon::cleanup ( )

overridevirtual

cleanUp ressources

Implements SwapchainAbstract.

Definition at line 215 of file SwapchainCommon.cpp.

{
    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);
    
}

getAttachmentSize()

int SwapchainCommon::getAttachmentSize ( )

overridevirtual

Return the size of the attachment

Implements SwapchainAbstract.

Definition at line 232 of file SwapchainCommon.cpp.

{
    return swapchainImageViews.size();
}

getCurrentImage()

vk::Image SwapchainCommon::getCurrentImage ( )

overridevirtual

Return the current vk::Image in use

Implements SwapchainAbstract.

Definition at line 237 of file SwapchainCommon.cpp.

{
    return swapChainImages[currentFrame];
}

getSwapchainImage()

vk::Image SwapchainCommon::getSwapchainImage ( int  index )

overridevirtual

Return vk::Image corresponding to the requested index

Implements SwapchainAbstract.

Definition at line 209 of file SwapchainCommon.cpp.

{
    assert(index < swapChainImages.size());
    return swapChainImages[index];
}

getSwapchainImageView()

vk::ImageView SwapchainCommon::getSwapchainImageView ( int  elem )

overridevirtual

Used to retrieve the vk::ImageView corresponding to the image used

Implements SwapchainAbstract.

Definition at line 203 of file SwapchainCommon.cpp.

{
    assert(elem < swapchainImageViews.size());
    return swapchainImageViews[elem];
}

presentImage() [1/2]

void SwapchainCommon::presentImage ( uint32_t  imageIndex, vk::Fence &  renderingFinnishedFence  )

overridevirtual

Called to signal that rendering work have been submitted to the GPU, and that the fence have to be used for synchronization

Implements SwapchainAbstract.

Definition at line 141 of file SwapchainCommon.cpp.

{
    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();
}

presentImage() [2/2]

void SwapchainCommon::presentImage ( uint32_t  imageIndex, vk::Semaphore &  renderingFinnished  )

overridevirtual

Called to signal that rendering work have been submitted to the GPU, and that the Semaphore have to be used for synchronization

Implements SwapchainAbstract.

Definition at line 110 of file SwapchainCommon.cpp.

{
    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();
}

---

The documentation for this class was generated from the following files:

• SwapchainCommon.h
• SwapchainCommon.cpp