SwapchainOpenXR Class Reference

Class that encapsulate an OpenXR Swapchain and functions associated to it. More...

#include <SwapchainOpenXR.h>

Inheritance diagram for SwapchainOpenXR:

Public Member Functions
	SwapchainOpenXR (int64_t format, const XrViewConfigurationView &vp, WindowAbstract *window, VulkanWrapper *wrapper, XrSession *session)
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 an OpenXR Swapchain and functions associated to it.

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

Can be used for color or depth swapchain

Definition at line 35 of file SwapchainOpenXR.h.

Constructor & Destructor Documentation

SwapchainOpenXR()

SwapchainOpenXR::SwapchainOpenXR	(	int64_t	format,
		const XrViewConfigurationView &	vp,
		WindowAbstract *	window,
		VulkanWrapper *	wrapper,
		XrSession *	session
	)

Constructor

Definition at line 39 of file SwapchainOpenXR.cpp.

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

Member Function Documentation

acquireImage()

std::tuple< uint32_t, std::optional< vk::Semaphore > > SwapchainOpenXR::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 57 of file SwapchainOpenXR.cpp.

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

cleanup()

void SwapchainOpenXR::cleanup ( )

overridevirtual

Clean up allocated ressources

Implements SwapchainAbstract.

Definition at line 116 of file SwapchainOpenXR.cpp.

{
    xrDestroySwapchain(xrswapchain.handle);
}

getAttachmentSize()

int SwapchainOpenXR::getAttachmentSize ( )

overridevirtual

Return the size of the attachment

Implements SwapchainAbstract.

Definition at line 121 of file SwapchainOpenXR.cpp.

{
    assert(swapChainImagesXr.size() == xrSwapchainImagesBase.size());
    return swapChainImagesXr.size();
}

getCurrentImage()

vk::Image SwapchainOpenXR::getCurrentImage ( )

overridevirtual

Return the current vk::Image in use

Implements SwapchainAbstract.

Definition at line 127 of file SwapchainOpenXR.cpp.

{
    return swapChainImagesXr[currentImage].image;
}

getSwapchainImage()

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

overridevirtual

Return vk::Image corresponding to the requested index

Implements SwapchainAbstract.

Definition at line 103 of file SwapchainOpenXR.cpp.

{
    assert(index < swapChainImagesXr.size());
    assert(index < xrSwapchainImagesBase.size());
    return swapChainImagesXr[index].image;
}

getSwapchainImageView()

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

overridevirtual

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

Implements SwapchainAbstract.

Definition at line 97 of file SwapchainOpenXR.cpp.

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

presentImage() [1/2]

void SwapchainOpenXR::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 78 of file SwapchainOpenXR.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...");
    }
 
    XrSwapchainImageReleaseInfo releaseInfo{ XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO };
    CHECK_XRCMD(xrReleaseSwapchainImage(xrswapchain.handle, &releaseInfo));
}

presentImage() [2/2]

void SwapchainOpenXR::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 73 of file SwapchainOpenXR.cpp.

{
    throw std::runtime_error("Synchronization with Semaphore is not supported with openxr swapchains");
}

---

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

• SwapchainOpenXR.h
• SwapchainOpenXR.cpp