Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qopenxrgraphics_vulkan_p.h"
#include "qopenxrhelpers_p.h"
#include <QtQuick/QQuickWindow>
#include <QtQuick/QQuickGraphicsDevice>
#include <QtQuick/QQuickGraphicsConfiguration>
#include <QtQuick/private/qquickrendertarget_p.h>
#include <rhi/qrhi.h>
//#define XR_USE_GRAPHICS_API_VULKAN
QT_BEGIN_NAMESPACE
QOpenXRGraphicsVulkan::QOpenXRGraphicsVulkan()
{
m_graphicsBinding.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR;
}
bool QOpenXRGraphicsVulkan::initialize(const QVector<XrExtensionProperties> &extensions)
{
return hasExtension(extensions, XR_KHR_VULKAN_ENABLE_EXTENSION_NAME);
}
QVector<const char *> QOpenXRGraphicsVulkan::getRequiredExtensions() const
{
return { XR_KHR_VULKAN_ENABLE_EXTENSION_NAME };
}
const XrBaseInStructure *QOpenXRGraphicsVulkan::handle() const
{
return reinterpret_cast<const XrBaseInStructure*>(&m_graphicsBinding);
}
bool QOpenXRGraphicsVulkan::setupGraphics(const XrInstance &instance, XrSystemId &systemId, const QQuickGraphicsConfiguration &quickConfig)
{
// Setup Vulkan Instance.
// In hybrid applications that also show Qt Quick windows on the desktop, it
// is not ideal to create multiple VkInstances (as the on-screen
// QQuickWindow(s) will have another one), but there is nothing we can do
// due to the forced upfront nature of Vulkan API design. And we need to do
// OpenXR API calls to get the things we need to create the instance. This
// is hard to reconcile with Quick, that knows nothing about XrView and
// such, and cannot predict the future either (i.e., "guess" if the user is
// ever going to instantiate an XRView, and so on).
//
// This has no relevance for XR-only apps, and even the hybrid case this
// works in practice, so we might just live with this for now.
PFN_xrGetVulkanGraphicsRequirementsKHR pfnGetVulkanGraphicsRequirementsKHR = nullptr;
OpenXRHelpers::checkXrResult(xrGetInstanceProcAddr(instance,
"xrGetVulkanGraphicsRequirementsKHR",
reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanGraphicsRequirementsKHR)),
instance);
if (!pfnGetVulkanGraphicsRequirementsKHR) {
qWarning("Could not resolve xrGetVulkanGraphicsRequirementsKHR; perhaps the OpenXR implementation does not support Vulkan?");
return false;
}
PFN_xrGetVulkanInstanceExtensionsKHR pfnGetVulkanInstanceExtensionsKHR = nullptr;
OpenXRHelpers::checkXrResult(xrGetInstanceProcAddr(instance,
"xrGetVulkanInstanceExtensionsKHR",
reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanInstanceExtensionsKHR)),
instance);
XrGraphicsRequirementsVulkanKHR graphicsRequirements{};
graphicsRequirements.type = XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR;
OpenXRHelpers::checkXrResult(pfnGetVulkanGraphicsRequirementsKHR(instance,
systemId,
&graphicsRequirements),
instance);
quint32 extensionNamesSize = 0;
OpenXRHelpers::checkXrResult(pfnGetVulkanInstanceExtensionsKHR(instance,
systemId,
0,
&extensionNamesSize,
nullptr),
instance);
QByteArray extensionNames;
extensionNames.resize(extensionNamesSize);
OpenXRHelpers::checkXrResult(pfnGetVulkanInstanceExtensionsKHR(instance,
systemId,
extensionNamesSize,
&extensionNamesSize,
extensionNames.data()),
instance);
// The last extension could have extra null characters but
// the way we handle extenions doesn't handle null terminated
// strings well, so we have to strip them ourselves
auto stripNullChars = [](const QByteArray &string) {
auto begin = string.begin();
auto end = string.end();
while (begin < end && end[-1] == '\x00')
--end;
return QByteArray(begin, end - begin);
};
QByteArrayList extensions = extensionNames.split(' ');
for (auto &ext : extensions)
ext = stripNullChars(ext);
for (auto &rhiExt : QRhiVulkanInitParams::preferredInstanceExtensions()) {
if (!extensions.contains(rhiExt))
extensions.append(rhiExt);
}
m_vulkanInstance.setExtensions(extensions);
// Multiview is a Vulkan 1.1 feature and won't work without setting up the instance accordingly.
const QVersionNumber supportedVersion = m_vulkanInstance.supportedApiVersion();
if (supportedVersion >= QVersionNumber(1, 3))
m_vulkanInstance.setApiVersion(QVersionNumber(1, 3));
else if (supportedVersion >= QVersionNumber(1, 2))
m_vulkanInstance.setApiVersion(QVersionNumber(1, 2));
else if (supportedVersion >= QVersionNumber(1, 1))
m_vulkanInstance.setApiVersion(QVersionNumber(1, 1));
if (quickConfig.isDebugLayerEnabled())
m_vulkanInstance.setLayers({ "VK_LAYER_LUNARG_standard_validation" });
if (!m_vulkanInstance.create()) {
qWarning("Quick 3D XR: Failed to create Vulkan instance");
return false;
}
// Get Vulkan device extensions
PFN_xrGetVulkanDeviceExtensionsKHR pfnGetVulkanDeviceExtensionsKHR = nullptr;
OpenXRHelpers::checkXrResult(xrGetInstanceProcAddr(instance,
"xrGetVulkanDeviceExtensionsKHR",
reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanDeviceExtensionsKHR)),
instance);
uint32_t deviceExtensionNamesSize = 0;
OpenXRHelpers::checkXrResult(pfnGetVulkanDeviceExtensionsKHR(instance,
systemId,
0,
&deviceExtensionNamesSize,
nullptr),
instance);
QByteArray deviceExtensionNames;
deviceExtensionNames.resize(deviceExtensionNamesSize);
OpenXRHelpers::checkXrResult(pfnGetVulkanDeviceExtensionsKHR(instance,
systemId,
deviceExtensionNamesSize,
&deviceExtensionNamesSize,
deviceExtensionNames.data()),
instance);
auto deviceExtensions = deviceExtensionNames.split(' ');
for (auto &ext : deviceExtensions) {
ext = stripNullChars(ext);
}
m_graphicsConfiguration.setDeviceExtensions(deviceExtensions);
// Get the Vulkan Graphics Device
PFN_xrGetVulkanGraphicsDeviceKHR pfnGetVulkanGraphicsDeviceKHR = nullptr;
OpenXRHelpers::checkXrResult(xrGetInstanceProcAddr(instance, "xrGetVulkanGraphicsDeviceKHR",
reinterpret_cast<PFN_xrVoidFunction*>(&pfnGetVulkanGraphicsDeviceKHR)), instance);
OpenXRHelpers::checkXrResult(pfnGetVulkanGraphicsDeviceKHR(instance, systemId, m_vulkanInstance.vkInstance(), &m_vulkanPhysicalDevice), instance);
return true;
}
bool QOpenXRGraphicsVulkan::finializeGraphics(QRhi *rhi)
{
const QRhiVulkanNativeHandles *vulkanRhi = static_cast<const QRhiVulkanNativeHandles *>(rhi->nativeHandles());
m_vulkanDevice = vulkanRhi->dev;
Q_ASSERT(m_vulkanPhysicalDevice == vulkanRhi->physDev);
m_vulkanCommandQueue = vulkanRhi->gfxQueue;
m_queueFamilyIndex = vulkanRhi->gfxQueueFamilyIdx;
m_graphicsBinding.instance = m_vulkanInstance.vkInstance();
m_graphicsBinding.physicalDevice = m_vulkanPhysicalDevice;
m_graphicsBinding.device = m_vulkanDevice;
m_graphicsBinding.queueFamilyIndex = m_queueFamilyIndex;
m_graphicsBinding.queueIndex = 0;
m_rhi = rhi;
return true;
}
int64_t QOpenXRGraphicsVulkan::colorSwapchainFormat(const QVector<int64_t> &swapchainFormats) const
{
// List of supported color swapchain formats.
constexpr int64_t supportedColorSwapchainFormats[] = {
VK_FORMAT_B8G8R8A8_SRGB,
VK_FORMAT_R8G8B8A8_SRGB,
VK_FORMAT_B8G8R8A8_UNORM,
VK_FORMAT_R8G8B8A8_UNORM
};
auto swapchainFormatIt = std::find_first_of(std::begin(supportedColorSwapchainFormats),
std::end(supportedColorSwapchainFormats),
swapchainFormats.begin(),
swapchainFormats.end());
return *swapchainFormatIt;
}
int64_t QOpenXRGraphicsVulkan::depthSwapchainFormat(const QVector<int64_t> &swapchainFormats) const
{
// in order of preference
QVarLengthArray<int64_t, 4> supportedDepthSwapchainFormats;
constexpr std::pair<int64_t, QRhiTexture::Format> nativeDepthSwapchainFormats[] = {
{ VK_FORMAT_D24_UNORM_S8_UINT, QRhiTexture::D24S8 },
{ VK_FORMAT_D32_SFLOAT_S8_UINT, QRhiTexture::D32F },
{ VK_FORMAT_D32_SFLOAT, QRhiTexture::D32F },
{ VK_FORMAT_D16_UNORM, QRhiTexture::D16 }
};
for (const auto &format : nativeDepthSwapchainFormats) {
if (m_rhi->isTextureFormatSupported(format.second))
supportedDepthSwapchainFormats.append(format.first);
}
if (supportedDepthSwapchainFormats.isEmpty())
return 0;
// order matters, we prefer D24S8 above all the others
return *std::find_first_of(std::begin(supportedDepthSwapchainFormats),
std::end(supportedDepthSwapchainFormats),
swapchainFormats.begin(),
swapchainFormats.end());
}
QVector<XrSwapchainImageBaseHeader*> QOpenXRGraphicsVulkan::allocateSwapchainImages(int count, XrSwapchain swapchain)
{
QVector<XrSwapchainImageBaseHeader*> swapchainImages;
QVector<XrSwapchainImageVulkanKHR> swapchainImageBuffer(count);
for (XrSwapchainImageVulkanKHR& image : swapchainImageBuffer) {
image.type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR;
swapchainImages.push_back(reinterpret_cast<XrSwapchainImageBaseHeader*>(&image));
}
m_swapchainImageBuffer.insert(swapchain, swapchainImageBuffer);
return swapchainImages;
}
QQuickRenderTarget QOpenXRGraphicsVulkan::renderTarget(const XrSwapchainSubImage &subImage,
const XrSwapchainImageBaseHeader *swapchainImage,
quint64 swapchainFormat,
int samples,
int arraySize,
const XrSwapchainImageBaseHeader *depthSwapchainImage,
quint64 depthSwapchainFormat) const
{
VkImage colorTexture = reinterpret_cast<const XrSwapchainImageVulkanKHR*>(swapchainImage)->image;
VkFormat viewFormat = VkFormat(swapchainFormat);
switch (swapchainFormat) {
case VK_FORMAT_R8G8B8A8_SRGB:
viewFormat = VK_FORMAT_R8G8B8A8_UNORM;
break;
case VK_FORMAT_B8G8R8A8_SRGB:
viewFormat = VK_FORMAT_B8G8R8A8_UNORM;
break;
default:
break;
}
QQuickRenderTarget::Flags flags;
if (samples > 1)
flags |= QQuickRenderTarget::Flag::MultisampleResolve;
const QSize pixelSize(subImage.imageRect.extent.width, subImage.imageRect.extent.height);
QQuickRenderTarget rt = QQuickRenderTarget::fromVulkanImage(colorTexture,
VK_IMAGE_LAYOUT_UNDEFINED,
VkFormat(swapchainFormat),
viewFormat,
pixelSize,
samples,
arraySize,
flags);
if (depthSwapchainImage) {
// There might be issues with stencil when MSAA is not used and the
// format is D16 or D32F or the half-unsupported D32FS8 (because then
// the OpenXR-provided texture is the one and only depth-stencil buffer,
// perhaps without stencil). But we prefer D24S8 whenever that's
// available, so hopefully this problem won't come up in practice.
QRhiTexture::Format format = QRhiTexture::D24S8;
switch (depthSwapchainFormat) {
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_D32_SFLOAT:
format = QRhiTexture::D32F;
break;
case VK_FORMAT_D16_UNORM:
format = QRhiTexture::D16;
break;
}
VkImage depthImage = reinterpret_cast<const XrSwapchainImageVulkanKHR*>(depthSwapchainImage)->image;
if (m_depthTexture && (m_depthTexture->format() != format || m_depthTexture->pixelSize() != pixelSize || m_depthTexture->arraySize() != arraySize)) {
delete m_depthTexture;
m_depthTexture = nullptr;
}
if (!m_depthTexture) {
// this is never multisample, QQuickRt takes care of resolving depth-stencil
if (arraySize > 1)
m_depthTexture = m_rhi->newTextureArray(format, arraySize, pixelSize, 1, QRhiTexture::RenderTarget);
else
m_depthTexture = m_rhi->newTexture(format, pixelSize, 1, QRhiTexture::RenderTarget);
}
m_depthTexture->createFrom({ quint64(depthImage), VK_IMAGE_LAYOUT_UNDEFINED });
rt.setDepthTexture(m_depthTexture);
}
return rt;
}
void QOpenXRGraphicsVulkan::setupWindow(QQuickWindow *quickWindow)
{
quickWindow->setGraphicsDevice(QQuickGraphicsDevice::fromPhysicalDevice(m_vulkanPhysicalDevice));
quickWindow->setGraphicsConfiguration(m_graphicsConfiguration);
quickWindow->setVulkanInstance(&m_vulkanInstance);
}
void QOpenXRGraphicsVulkan::releaseResources()
{
delete m_depthTexture;
m_depthTexture = nullptr;
}
QT_END_NAMESPACE