qvulkaninstance.h - mozsearch

Enable keyboard shortcuts

// 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

// Qt-Security score:significant reason:default

#ifndef QVULKANINSTANCE_H

#define QVULKANINSTANCE_H

#include <QtGui/qtguiglobal.h>

#if 0

#pragma qt_no_master_include

#pragma qt_sync_skip_header_check

#endif

#if QT_CONFIG(vulkan) || defined(Q_QDOC)

#ifndef VK_NO_PROTOTYPES

#define VK_NO_PROTOTYPES

#endif

#if !defined(Q_QDOC) && __has_include(<vulkan/vulkan.h>)

#include <vulkan/vulkan.h>

#else

// QT_CONFIG(vulkan) implies vulkan.h being available at Qt build time, but it

// does not guarantee vulkan.h is available at *application* build time. Both

// for qdoc and for apps built on systems without Vulkan SDK we provide a set

// of typedefs to keep things compiling since this header may be included from

// Qt Quick and elsewhere just to get types like VkImage and friends defined.

typedef void* PFN_vkVoidFunction;

// non-dispatchable handles (64-bit regardless of arch)

typedef quint64 VkSurfaceKHR;

typedef quint64 VkImage;

typedef quint64 VkImageView;

// dispatchable handles (32 or 64-bit depending on arch)

typedef void* VkInstance;

typedef void* VkPhysicalDevice;

typedef void* VkDevice;

// enums

typedef int VkResult;

typedef int VkFormat;

typedef int VkImageLayout;

typedef int VkDebugReportFlagsEXT;

typedef int VkDebugReportObjectTypeEXT;

typedef int VkDeviceQueueCreateFlags;

#endif

// QVulkanInstance itself is only applicable if vulkan.h is available, or if

// it's qdoc. An application that is built on a vulkan.h-less system against a

// Vulkan-enabled Qt gets the dummy typedefs but not QVulkan*.

#if __has_include(<vulkan/vulkan.h>) || defined(Q_QDOC)

#include <QtCore/qbytearraylist.h>

#include <QtCore/qhashfunctions.h>

#include <QtCore/qlist.h>

#include <QtCore/qscopedpointer.h>

#include <QtCore/qversionnumber.h>

QT_BEGIN_NAMESPACE

class QDebug;

class QVulkanInstancePrivate;

class QPlatformVulkanInstance;

class QVulkanFunctions;

class QVulkanDeviceFunctions;

class QWindow;

struct QVulkanLayer

    QByteArray name;

    uint32_t version;

    QVersionNumber specVersion;

    QByteArray description;

};

Q_DECLARE_TYPEINFO(QVulkanLayer, Q_RELOCATABLE_TYPE);

inline bool operator==(const QVulkanLayer &lhs, const QVulkanLayer &rhs) noexcept

    return lhs.name == rhs.name && lhs.version == rhs.version && lhs.specVersion == rhs.specVersion;

inline bool operator!=(const QVulkanLayer &lhs, const QVulkanLayer &rhs) noexcept

{ return !(lhs == rhs); }

inline size_t qHash(const QVulkanLayer &key, size_t seed = 0) noexcept

    QtPrivate::QHashCombine hash(seed);

    seed = hash(seed, key.name);

    seed = hash(seed, key.version);

    seed = hash(seed, key.specVersion);

    return seed;

struct QVulkanExtension

    QByteArray name;

    uint32_t version;

};

Q_DECLARE_TYPEINFO(QVulkanExtension, Q_RELOCATABLE_TYPE);

inline bool operator==(const QVulkanExtension &lhs, const QVulkanExtension &rhs) noexcept

    return lhs.name == rhs.name && lhs.version == rhs.version;

inline bool operator!=(const QVulkanExtension &lhs, const QVulkanExtension &rhs) noexcept

{ return !(lhs == rhs); }

inline size_t qHash(const QVulkanExtension &key, size_t seed = 0) noexcept

    QtPrivate::QHashCombine hash(seed);

    seed = hash(seed, key.name);

    seed = hash(seed, key.version);

    return seed;

#ifndef QT_NO_DEBUG_STREAM

Q_GUI_EXPORT QDebug operator<<(QDebug, const QVulkanLayer &);

Q_GUI_EXPORT QDebug operator<<(QDebug, const QVulkanExtension &);

#endif

template<typename T>

class QVulkanInfoVector : public QList<T>

public:

    bool contains(const QByteArray &name) const {

        return std::any_of(this->cbegin(), this->cend(), [&](const T &entry) {

            return entry.name == name; });

    bool contains(const QByteArray &name, int minVersion) const {

        return std::any_of(this->cbegin(), this->cend(), [&](const T &entry) {

            return entry.name == name && entry.version >= minVersion; });

};

class Q_GUI_EXPORT QVulkanInstance

public:

    QVulkanInstance();

    ~QVulkanInstance();

    enum Flag {

        NoDebugOutputRedirect = 0x01,

        NoPortabilityDrivers = 0x02

};

    Q_DECLARE_FLAGS(Flags, Flag)

    // ### Qt 7: remove non-const overloads

    QVulkanInfoVector<QVulkanLayer> supportedLayers();

    inline QVulkanInfoVector<QVulkanLayer> supportedLayers() const

    { return const_cast<QVulkanInstance*>(this)->supportedLayers(); }

    QVulkanInfoVector<QVulkanExtension> supportedExtensions();

    inline QVulkanInfoVector<QVulkanExtension> supportedExtensions() const

    { return const_cast<QVulkanInstance*>(this)->supportedExtensions(); }

    QVersionNumber supportedApiVersion() const;

    void setVkInstance(VkInstance existingVkInstance);

    void setFlags(Flags flags);

    void setLayers(const QByteArrayList &layers);

    void setExtensions(const QByteArrayList &extensions);

    void setApiVersion(const QVersionNumber &vulkanVersion);

    bool create();

    void destroy();

    bool isValid() const;

    VkResult errorCode() const;

    VkInstance vkInstance() const;

    Flags flags() const;

    QByteArrayList layers() const;

    QByteArrayList extensions() const;

    QVersionNumber apiVersion() const;

    PFN_vkVoidFunction getInstanceProcAddr(const char *name);

    QPlatformVulkanInstance *handle() const;

    QVulkanFunctions *functions() const;

    QVulkanDeviceFunctions *deviceFunctions(VkDevice device);

    void resetDeviceFunctions(VkDevice device);

    static VkSurfaceKHR surfaceForWindow(QWindow *window);

    bool supportsPresent(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, QWindow *window);

    void presentAboutToBeQueued(QWindow *window);

    void presentQueued(QWindow *window);

    typedef bool (*DebugFilter)(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object,

                                size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage);

    void installDebugOutputFilter(DebugFilter filter);

    void removeDebugOutputFilter(DebugFilter filter);

    enum DebugMessageSeverityFlag {

        VerboseSeverity = 0x01,

        InfoSeverity = 0x02,

        WarningSeverity = 0x04,

        ErrorSeverity = 0x08

};

    Q_DECLARE_FLAGS(DebugMessageSeverityFlags, DebugMessageSeverityFlag)

    enum DebugMessageTypeFlag {

        GeneralMessage = 0x01,

        ValidationMessage = 0x02,

        PerformanceMessage = 0x04

};

    Q_DECLARE_FLAGS(DebugMessageTypeFlags, DebugMessageTypeFlag)

    using DebugUtilsFilter = std::function<bool(DebugMessageSeverityFlags severity, DebugMessageTypeFlags type, const void *message)>;

    void installDebugOutputFilter(DebugUtilsFilter filter);

    void clearDebugOutputFilters();

private:

    friend class QVulkanInstancePrivate;

    QScopedPointer<QVulkanInstancePrivate> d_ptr;

    Q_DISABLE_COPY(QVulkanInstance)

};

Q_DECLARE_OPERATORS_FOR_FLAGS(QVulkanInstance::Flags)

Q_DECLARE_OPERATORS_FOR_FLAGS(QVulkanInstance::DebugMessageTypeFlags)

Q_DECLARE_OPERATORS_FOR_FLAGS(QVulkanInstance::DebugMessageSeverityFlags)

QT_END_NAMESPACE

#endif // __has_include(<vulkan/vulkan.h>) || defined(Q_QDOC)

#endif // QT_CONFIG(vulkan) || defined(Q_QDOC)

#endif // QVULKANINSTANCE_H