qvulkaninstance.cpp

Go to the documentation of this file.

// Copyright (C) 2017 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qvulkaninstance_p.h"
#include <qpa/qplatformvulkaninstance.h>
#include <qpa/qplatformintegration.h>
#include <qpa/qplatformnativeinterface.h>
#include <QtGui/private/qguiapplication_p.h>
 
QT_BEGIN_NAMESPACE
 
bool QVulkanInstancePrivate::ensureVulkan()
{
    if (!platformInst) {
        platformInst.reset(QGuiApplicationPrivate::platformIntegration()->createPlatformVulkanInstance(q_ptr));
        if (!platformInst) {
            qWarning("QVulkanInstance: Failed to initialize Vulkan");
            return false;
        }
    }
    return true;
}
 
void QVulkanInstancePrivate::reset()
{
    qDeleteAll(deviceFuncs);
    deviceFuncs.clear();
    funcs.reset();
    platformInst.reset();
    vkInst = VK_NULL_HANDLE;
    errorCode = VK_SUCCESS;
}
 
QVulkanInstance::QVulkanInstance()
    : d_ptr(new QVulkanInstancePrivate(this))
{
}
 
QVulkanInstance::~QVulkanInstance()
{
    destroy();
}
 
QVulkanInfoVector<QVulkanLayer> QVulkanInstance::supportedLayers()
{
    return d_ptr->ensureVulkan() ? d_ptr->platformInst->supportedLayers() : QVulkanInfoVector<QVulkanLayer>();
}
 
QVulkanInfoVector<QVulkanExtension> QVulkanInstance::supportedExtensions()
{
    return d_ptr->ensureVulkan() ? d_ptr->platformInst->supportedExtensions() : QVulkanInfoVector<QVulkanExtension>();
}
 
QVersionNumber QVulkanInstance::supportedApiVersion() const
{
    return d_ptr->ensureVulkan() ? d_ptr->platformInst->supportedApiVersion() : QVersionNumber();
}
 
void QVulkanInstance::setVkInstance(VkInstance existingVkInstance)
{
    if (isValid()) {
        qWarning("QVulkanInstance already created; setVkInstance() has no effect");
        return;
    }
 
    d_ptr->vkInst = existingVkInstance;
}
 
void QVulkanInstance::setFlags(Flags flags)
{
    if (isValid()) {
        qWarning("QVulkanInstance already created; setFlags() has no effect");
        return;
    }
 
    d_ptr->flags = flags;
}
 
void QVulkanInstance::setLayers(const QByteArrayList &layers)
{
    if (isValid()) {
        qWarning("QVulkanInstance already created; setLayers() has no effect");
        return;
    }
 
    d_ptr->layers = layers;
}
 
void QVulkanInstance::setExtensions(const QByteArrayList &extensions)
{
    if (isValid()) {
        qWarning("QVulkanInstance already created; setExtensions() has no effect");
        return;
    }
 
    d_ptr->extensions = extensions;
}
 
void QVulkanInstance::setApiVersion(const QVersionNumber &vulkanVersion)
{
    if (isValid()) {
        qWarning("QVulkanInstance already created; setApiVersion() has no effect");
        return;
    }
 
    d_ptr->apiVersion = vulkanVersion;
}
 
bool QVulkanInstance::create()
{
    if (isValid())
        destroy();
 
    if (!d_ptr->ensureVulkan())
        return false;
 
    d_ptr->platformInst->createOrAdoptInstance();
 
    if (d_ptr->platformInst->isValid()) {
        d_ptr->vkInst = d_ptr->platformInst->vkInstance();
        d_ptr->layers = d_ptr->platformInst->enabledLayers();
        d_ptr->extensions = d_ptr->platformInst->enabledExtensions();
        d_ptr->errorCode = VK_SUCCESS;
        d_ptr->funcs.reset(new QVulkanFunctions(this));
        d_ptr->platformInst->setDebugFilters(d_ptr->debugFilters);
        d_ptr->platformInst->setDebugUtilsFilters(d_ptr->debugUtilsFilters);
        return true;
    }
 
    qWarning("Failed to create platform Vulkan instance");
    if (d_ptr->platformInst) {
        d_ptr->errorCode = d_ptr->platformInst->errorCode();
        d_ptr->platformInst.reset();
    } else {
        d_ptr->errorCode = VK_NOT_READY;
    }
    return false;
}
 
void QVulkanInstance::destroy()
{
    d_ptr->reset();
}
 
bool QVulkanInstance::isValid() const
{
    return d_ptr->platformInst && d_ptr->platformInst->isValid();
}
 
VkResult QVulkanInstance::errorCode() const
{
    return d_ptr->errorCode;
}
 
VkInstance QVulkanInstance::vkInstance() const
{
    return d_ptr->vkInst;
}
 
QVulkanInstance::Flags QVulkanInstance::flags() const
{
    return d_ptr->flags;
}
 
QByteArrayList QVulkanInstance::layers() const
{
    return d_ptr->layers;
}
 
QByteArrayList QVulkanInstance::extensions() const
{
    return d_ptr->extensions;
}
 
QVersionNumber QVulkanInstance::apiVersion() const
{
    return d_ptr->apiVersion;
}
 
PFN_vkVoidFunction QVulkanInstance::getInstanceProcAddr(const char *name)
{
    // The return value is PFN_vkVoidFunction instead of QFunctionPointer or
    // similar because on some platforms honoring VKAPI_PTR is important.
    return d_ptr->platformInst->getInstanceProcAddr(name);
}
 
QPlatformVulkanInstance *QVulkanInstance::handle() const
{
    return d_ptr->platformInst.data();
}
 
QVulkanFunctions *QVulkanInstance::functions() const
{
    return d_ptr->funcs.data();
}
 
QVulkanDeviceFunctions *QVulkanInstance::deviceFunctions(VkDevice device)
{
    QVulkanDeviceFunctions *&f = d_ptr->deviceFuncs[device];
    if (!f)
        f = new QVulkanDeviceFunctions(this, device);
    return f;
}
 
void QVulkanInstance::resetDeviceFunctions(VkDevice device)
{
    QVulkanDeviceFunctions *&f = d_ptr->deviceFuncs[device];
    delete f;
    f = nullptr;
}
 
VkSurfaceKHR QVulkanInstance::surfaceForWindow(QWindow *window)
{
    QPlatformNativeInterface *nativeInterface = qGuiApp->platformNativeInterface();
    // VkSurfaceKHR is non-dispatchable and maps to a pointer on x64 and a uint64 on x86.
    // Therefore a pointer is returned from the platform plugin, not the value itself.
    void *p = nativeInterface->nativeResourceForWindow(QByteArrayLiteral("vkSurface"), window);
    return p ? *static_cast<VkSurfaceKHR *>(p) : VK_NULL_HANDLE;
}
 
bool QVulkanInstance::supportsPresent(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, QWindow *window)
{
    return d_ptr->platformInst->supportsPresent(physicalDevice, queueFamilyIndex, window);
}
 
void QVulkanInstance::presentAboutToBeQueued(QWindow *window)
{
    d_ptr->platformInst->presentAboutToBeQueued(window);
}
 
void QVulkanInstance::presentQueued(QWindow *window)
{
    d_ptr->platformInst->presentQueued(window);
}
 
void QVulkanInstance::installDebugOutputFilter(DebugFilter filter)
{
    if (!d_ptr->debugFilters.contains(filter)) {
        d_ptr->debugFilters.append(filter);
        if (d_ptr->platformInst)
            d_ptr->platformInst->setDebugFilters(d_ptr->debugFilters);
    }
}
 
void QVulkanInstance::removeDebugOutputFilter(DebugFilter filter)
{
    d_ptr->debugFilters.removeOne(filter);
    if (d_ptr->platformInst)
        d_ptr->platformInst->setDebugFilters(d_ptr->debugFilters);
}
 
void QVulkanInstance::installDebugOutputFilter(DebugUtilsFilter filter)
{
    d_ptr->debugUtilsFilters.append(filter);
    if (d_ptr->platformInst)
        d_ptr->platformInst->setDebugUtilsFilters(d_ptr->debugUtilsFilters);
}
 
void QVulkanInstance::clearDebugOutputFilters()
{
    d_ptr->debugFilters.clear();
    d_ptr->debugUtilsFilters.clear();
    if (d_ptr->platformInst) {
        d_ptr->platformInst->setDebugFilters(d_ptr->debugFilters);
        d_ptr->platformInst->setDebugUtilsFilters(d_ptr->debugUtilsFilters);
    }
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QVulkanLayer &layer)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QVulkanLayer(" << layer.name << " " << layer.version
                  << " " << layer.specVersion << " " << layer.description << ")";
    return dbg;
}
 
QDebug operator<<(QDebug dbg, const QVulkanExtension &extension)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QVulkanExtension(" << extension.name << " " << extension.version << ")";
    return dbg;
}
#endif
 
QT_END_NAMESPACE