Basic Vulkan enablers

For Android, Windows and xcb. Verified on Win10 with NVIDIA, Win10
with AMD, Android with Tegra K1, Android aarch64 with Tegra X1, and
Linux aarch64 with Tegra X1 (Jetson TX1, L4T).

Introduce QPA-based Vulkan library loader, core function resolver, and
instance creation support. In addition to creating a new VkInstance,
adopting an existing one from an external engine is supported as well.

The WSI specifics are hidden in the platform plugins. Vulkan-capable
windows use the new surface type VulkanSurface and are associated with
a QVulkanInstance.

On Windows VULKAN_SDK is picked up automatically so finding vulkan.h
needs no additional manual steps once the LunarG SDK is installed.

[ChangeLog][QtGui] Added support for rendering to QWindow via the Vulkan
graphics API.

Task-number: QTBUG-55981
Change-Id: I50fa92d313fa440e0cc73939c6d7510ca317fbc9
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@qt.io>
Reviewed-by: Andy Nichols <andy.nichols@qt.io>

2 files changed, 535 insertions, 0 deletions

diff --git a/src/tools/qvkgen/qvkgen.cpp b/src/tools/qvkgen/qvkgen.cpp
new file mode 100644
index 0000000000..cf97a84062
--- /dev/null
+++ b/src/tools/qvkgen/qvkgen.cpp
@@ -0,0 +1,530 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qvector.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qfileinfo.h>
+#include <QtCore/qxmlstream.h>
+
+class VkSpecParser
+{
+public:
+    bool parse();
+
+    struct TypedName {
+        QString name;
+        QString type;
+        QString typeSuffix;
+    };
+
+    struct Command {
+        TypedName cmd;
+        QVector<TypedName> args;
+        bool deviceLevel;
+    };
+
+    QVector<Command> commands() const { return m_commands; }
+
+    void setFileName(const QString &fn) { m_fn = fn; }
+
+private:
+    void skip();
+    void parseCommands();
+    Command parseCommand();
+    TypedName parseParamOrProto(const QString &tag);
+    QString parseName();
+
+    QFile m_file;
+    QXmlStreamReader m_reader;
+    QVector<Command> m_commands;
+    QString m_fn;
+};
+
+bool VkSpecParser::parse()
+{
+    m_file.setFileName(m_fn);
+    if (!m_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qWarning("Failed to open %s", qPrintable(m_file.fileName()));
+        return false;
+    }
+
+    m_reader.setDevice(&m_file);
+    while (!m_reader.atEnd()) {
+        m_reader.readNext();
+        if (m_reader.isStartElement()) {
+            if (m_reader.name() == QStringLiteral("commands"))
+                parseCommands();
+        }
+    }
+
+    return true;
+}
+
+void VkSpecParser::skip()
+{
+    QString tag = m_reader.name().toString();
+    while (!m_reader.atEnd()) {
+        m_reader.readNext();
+        if (m_reader.isEndElement() && m_reader.name() == tag)
+            break;
+    }
+}
+
+void VkSpecParser::parseCommands()
+{
+    m_commands.clear();
+
+    while (!m_reader.atEnd()) {
+        m_reader.readNext();
+        if (m_reader.isEndElement() && m_reader.name() == QStringLiteral("commands"))
+            return;
+        if (m_reader.isStartElement() && m_reader.name() == "command")
+            m_commands.append(parseCommand());
+    }
+}
+
+VkSpecParser::Command VkSpecParser::parseCommand()
+{
+    Command c;
+
+    while (!m_reader.atEnd()) {
+        m_reader.readNext();
+        if (m_reader.isEndElement() && m_reader.name() == QStringLiteral("command"))
+            break;
+        if (m_reader.isStartElement()) {
+            const QString protoStr = QStringLiteral("proto");
+            const QString paramStr = QStringLiteral("param");
+            if (m_reader.name() == protoStr) {
+                c.cmd = parseParamOrProto(protoStr);
+            } else if (m_reader.name() == paramStr) {
+                c.args.append(parseParamOrProto(paramStr));
+            } else {
+                skip();
+            }
+        }
+    }
+
+    c.deviceLevel = false;
+    if (!c.args.isEmpty()) {
+        QStringList dispatchableDeviceAndChildTypes {
+            QStringLiteral("VkDevice"),
+            QStringLiteral("VkQueue"),
+            QStringLiteral("VkCommandBuffer")
+        };
+        if (dispatchableDeviceAndChildTypes.contains(c.args[0].type)
+                && c.cmd.name != QStringLiteral("vkGetDeviceProcAddr"))
+        {
+            c.deviceLevel = true;
+        }
+    }
+
+    return c;
+}
+
+VkSpecParser::TypedName VkSpecParser::parseParamOrProto(const QString &tag)
+{
+    TypedName t;
+
+    while (!m_reader.atEnd()) {
+        m_reader.readNext();
+        if (m_reader.isEndElement() && m_reader.name() == tag)
+            break;
+        if (m_reader.isStartElement()) {
+            if (m_reader.name() == QStringLiteral("name")) {
+                t.name = parseName();
+            } else if (m_reader.name() != QStringLiteral("type")) {
+                skip();
+            }
+        } else {
+            QStringRef text = m_reader.text().trimmed();
+            if (!text.isEmpty()) {
+                if (text.startsWith(QLatin1Char('['))) {
+                    t.typeSuffix += text;
+                } else {
+                    if (!t.type.isEmpty())
+                        t.type += QLatin1Char(' ');
+                    t.type += text;
+                }
+            }
+        }
+    }
+
+    return t;
+}
+
+QString VkSpecParser::parseName()
+{
+    QString name;
+    while (!m_reader.atEnd()) {
+        m_reader.readNext();
+        if (m_reader.isEndElement() && m_reader.name() == QStringLiteral("name"))
+            break;
+        name += m_reader.text();
+    }
+    return name.trimmed();
+}
+
+QString funcSig(const VkSpecParser::Command &c, const char *className = nullptr)
+{
+    QString s;
+    s.sprintf("%s %s%s%s", qPrintable(c.cmd.type),
+              (className ? className : ""), (className ? "::" : ""),
+              qPrintable(c.cmd.name));
+    if (!c.args.isEmpty()) {
+        s += QLatin1Char('(');
+        bool first = true;
+        for (const VkSpecParser::TypedName &a : c.args) {
+            QString argStr;
+            argStr.sprintf("%s%s%s%s", qPrintable(a.type), (a.type.endsWith(QLatin1Char('*')) ? "" : " "),
+                           qPrintable(a.name), qPrintable(a.typeSuffix));
+            if (!first)
+                s += QStringLiteral(", ");
+            else
+                first = false;
+            s += argStr;
+        }
+        s += QLatin1Char(')');
+    }
+    return s;
+}
+
+QString funcCall(const VkSpecParser::Command &c, int idx)
+{
+    QString s;
+    // template:
+    //     [return] reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(d_ptr->m_funcs[0])(instance, pPhysicalDeviceCount, pPhysicalDevices);
+    s.sprintf("%sreinterpret_cast<PFN_%s>(d_ptr->m_funcs[%d])",
+              (c.cmd.type == QStringLiteral("void") ? "" : "return "),
+              qPrintable(c.cmd.name),
+              idx);
+    if (!c.args.isEmpty()) {
+        s += QLatin1Char('(');
+        bool first = true;
+        for (const VkSpecParser::TypedName &a : c.args) {
+            if (!first)
+                s += QStringLiteral(", ");
+            else
+                first = false;
+            s += a.name;
+        }
+        s += QLatin1Char(')');
+    }
+    return s;
+}
+
+class Preamble
+{
+public:
+    QByteArray get(const QString &fn);
+
+private:
+    QByteArray m_str;
+} preamble;
+
+QByteArray Preamble::get(const QString &fn)
+{
+    if (!m_str.isEmpty())
+        return m_str;
+
+    QFile f(fn);
+    if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qWarning("Failed to open %s", qPrintable(fn));
+        return m_str;
+    }
+
+    m_str = f.readAll();
+    m_str.replace("FOO", "QtGui");
+    m_str += "\n// This file is automatically generated by qvkgen. Do not edit.\n";
+
+    return m_str;
+}
+
+bool genVulkanFunctionsH(const QVector<VkSpecParser::Command> &commands, const QString &licHeaderFn, const QString &outputBase)
+{
+    QFile f(outputBase + QStringLiteral(".h"));
+    if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        qWarning("Failed to write %s", qPrintable(f.fileName()));
+        return false;
+    }
+
+    static const char *s =
+"%s\n"
+"#ifndef QVULKANFUNCTIONS_H\n"
+"#define QVULKANFUNCTIONS_H\n"
+"\n"
+"#include <QtGui/qtguiglobal.h>\n"
+"\n"
+"#if QT_CONFIG(vulkan)\n"
+"\n"
+"#ifndef VK_NO_PROTOTYPES\n"
+"#define VK_NO_PROTOTYPES\n"
+"#endif\n"
+"#include <vulkan/vulkan.h>\n"
+"\n"
+"#include <QtCore/qscopedpointer.h>\n"
+"\n"
+"QT_BEGIN_NAMESPACE\n"
+"\n"
+"class QVulkanInstance;\n"
+"class QVulkanFunctionsPrivate;\n"
+"class QVulkanDeviceFunctionsPrivate;\n"
+"\n"
+"class Q_GUI_EXPORT QVulkanFunctions\n"
+"{\n"
+"public:\n"
+"    ~QVulkanFunctions();\n"
+"\n"
+"%s\n"
+"private:\n"
+"    Q_DISABLE_COPY(QVulkanFunctions)\n"
+"    QVulkanFunctions(QVulkanInstance *inst);\n"
+"\n"
+"    QScopedPointer<QVulkanFunctionsPrivate> d_ptr;\n"
+"    friend class QVulkanInstance;\n"
+"};\n"
+"\n"
+"class Q_GUI_EXPORT QVulkanDeviceFunctions\n"
+"{\n"
+"public:\n"
+"    ~QVulkanDeviceFunctions();\n"
+"\n"
+"%s\n"
+"private:\n"
+"    Q_DISABLE_COPY(QVulkanDeviceFunctions)\n"
+"    QVulkanDeviceFunctions(QVulkanInstance *inst, VkDevice device);\n"
+"\n"
+"    QScopedPointer<QVulkanDeviceFunctionsPrivate> d_ptr;\n"
+"    friend class QVulkanInstance;\n"
+"};\n"
+"\n"
+"QT_END_NAMESPACE\n"
+"\n"
+"#endif // QT_CONFIG(vulkan)\n"
+"\n"
+"#endif // QVULKANFUNCTIONS_H\n";
+
+    QString instCmdStr;
+    QString devCmdStr;
+    for (const VkSpecParser::Command &c : commands) {
+        QString *dst = c.deviceLevel ? &devCmdStr : &instCmdStr;
+        *dst += QStringLiteral("    ");
+        *dst += funcSig(c);
+        *dst += QStringLiteral(";\n");
+    }
+
+    QString str;
+    str.sprintf(s, preamble.get(licHeaderFn).constData(), instCmdStr.toUtf8().constData(), devCmdStr.toUtf8().constData());
+
+    f.write(str.toUtf8());
+
+    return true;
+}
+
+bool genVulkanFunctionsPH(const QVector<VkSpecParser::Command> &commands, const QString &licHeaderFn, const QString &outputBase)
+{
+    QFile f(outputBase + QStringLiteral("_p.h"));
+    if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        qWarning("Failed to write %s", qPrintable(f.fileName()));
+        return false;
+    }
+
+    static const char *s =
+"%s\n"
+"#ifndef QVULKANFUNCTIONS_P_H\n"
+"#define QVULKANFUNCTIONS_P_H\n"
+"\n"
+"//\n"
+"//  W A R N I N G\n"
+"//  -------------\n"
+"//\n"
+"// This file is not part of the Qt API.  It exists purely as an\n"
+"// implementation detail.  This header file may change from version to\n"
+"// version without notice, or even be removed.\n"
+"//\n"
+"// We mean it.\n"
+"//\n"
+"\n"
+"#include \"qvulkanfunctions.h\"\n"
+"\n"
+"QT_BEGIN_NAMESPACE\n"
+"\n"
+"class QVulkanInstance;\n"
+"\n"
+"class QVulkanFunctionsPrivate\n"
+"{\n"
+"public:\n"
+"    QVulkanFunctionsPrivate(QVulkanInstance *inst);\n"
+"\n"
+"    PFN_vkVoidFunction m_funcs[%d];\n"
+"};\n"
+"\n"
+"class QVulkanDeviceFunctionsPrivate\n"
+"{\n"
+"public:\n"
+"    QVulkanDeviceFunctionsPrivate(QVulkanInstance *inst, VkDevice device);\n"
+"\n"
+"    PFN_vkVoidFunction m_funcs[%d];\n"
+"};\n"
+"\n"
+"QT_END_NAMESPACE\n"
+"\n"
+"#endif // QVULKANFUNCTIONS_P_H\n";
+
+    const int devLevelCount = std::count_if(commands.cbegin(), commands.cend(),
+                                            [](const VkSpecParser::Command &c) { return c.deviceLevel; });
+    const int instLevelCount = commands.count() - devLevelCount;
+
+    QString str;
+    str.sprintf(s, preamble.get(licHeaderFn).constData(), instLevelCount, devLevelCount);
+
+    f.write(str.toUtf8());
+
+    return true;
+}
+
+bool genVulkanFunctionsPC(const QVector<VkSpecParser::Command> &commands, const QString &licHeaderFn, const QString &outputBase)
+{
+    QFile f(outputBase + QStringLiteral("_p.cpp"));
+    if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        qWarning("Failed to write %s", qPrintable(f.fileName()));
+        return false;
+    }
+
+    static const char *s =
+"%s\n"
+"#include \"qvulkanfunctions_p.h\"\n"
+"#include \"qvulkaninstance.h\"\n"
+"\n"
+"QT_BEGIN_NAMESPACE\n"
+"\n%s"
+"QVulkanFunctionsPrivate::QVulkanFunctionsPrivate(QVulkanInstance *inst)\n"
+"{\n"
+"    static const char *funcNames[] = {\n"
+"%s\n"
+"    };\n"
+"    for (int i = 0; i < %d; ++i) {\n"
+"        m_funcs[i] = inst->getInstanceProcAddr(funcNames[i]);\n"
+"        if (!m_funcs[i])\n"
+"            qWarning(\"QVulkanFunctions: Failed to resolve %%s\", funcNames[i]);\n"
+"    }\n"
+"}\n"
+"\n%s"
+"QVulkanDeviceFunctionsPrivate::QVulkanDeviceFunctionsPrivate(QVulkanInstance *inst, VkDevice device)\n"
+"{\n"
+"    QVulkanFunctions *f = inst->functions();\n"
+"    Q_ASSERT(f);\n\n"
+"    static const char *funcNames[] = {\n"
+"%s\n"
+"    };\n"
+"    for (int i = 0; i < %d; ++i) {\n"
+"        m_funcs[i] = f->vkGetDeviceProcAddr(device, funcNames[i]);\n"
+"        if (!m_funcs[i])\n"
+"            qWarning(\"QVulkanDeviceFunctions: Failed to resolve %%s\", funcNames[i]);\n"
+"    }\n"
+"}\n"
+"\n"
+"QT_END_NAMESPACE\n";
+
+    QString devCmdWrapperStr;
+    QString instCmdWrapperStr;
+    int devIdx = 0;
+    int instIdx = 0;
+    QString devCmdNamesStr;
+    QString instCmdNamesStr;
+
+    for (int i = 0; i < commands.count(); ++i) {
+        QString *dst = commands[i].deviceLevel ? &devCmdWrapperStr : &instCmdWrapperStr;
+        int *idx = commands[i].deviceLevel ? &devIdx : &instIdx;
+        *dst += funcSig(commands[i], commands[i].deviceLevel ? "QVulkanDeviceFunctions" : "QVulkanFunctions");
+        *dst += QString(QStringLiteral("\n{\n    Q_ASSERT(d_ptr->m_funcs[%1]);\n    ")).arg(*idx);
+        *dst += funcCall(commands[i], *idx);
+        *dst += QStringLiteral(";\n}\n\n");
+        ++*idx;
+
+        dst = commands[i].deviceLevel ? &devCmdNamesStr : &instCmdNamesStr;
+        *dst += QStringLiteral("        \"");
+        *dst += commands[i].cmd.name;
+        *dst += QStringLiteral("\",\n");
+    }
+
+    if (devCmdNamesStr.count() > 2)
+        devCmdNamesStr = devCmdNamesStr.left(devCmdNamesStr.count() - 2);
+    if (instCmdNamesStr.count() > 2)
+        instCmdNamesStr = instCmdNamesStr.left(instCmdNamesStr.count() - 2);
+
+    QString str;
+    str.sprintf(s, preamble.get(licHeaderFn).constData(),
+                instCmdWrapperStr.toUtf8().constData(), instCmdNamesStr.toUtf8().constData(), instIdx,
+                devCmdWrapperStr.toUtf8().constData(), devCmdNamesStr.toUtf8().constData(), commands.count() - instIdx);
+
+    f.write(str.toUtf8());
+
+    return true;
+}
+
+int main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+    VkSpecParser parser;
+
+    if (argc < 4) {
+        qWarning("Usage: qvkgen input_vk_xml input_license_header output_base\n"
+                 "  For example: qvkgen vulkan/vk.xml vulkan/qvulkanfunctions.header vulkan/qvulkanfunctions");
+        return 1;
+    }
+
+    parser.setFileName(QString::fromUtf8(argv[1]));
+
+    if (!parser.parse())
+        return 1;
+
+    QVector<VkSpecParser::Command> commands = parser.commands();
+    QStringList ignoredFuncs {
+        QStringLiteral("vkCreateInstance"),
+        QStringLiteral("vkDestroyInstance"),
+        QStringLiteral("vkGetInstanceProcAddr")
+    };
+
+    // Filter out extensions and unwanted functions.
+    // The check for the former is rather simplistic for now: skip if the last letter is uppercase...
+    for (int i = 0; i < commands.count(); ++i) {
+        QString name = commands[i].cmd.name;
+        QChar c = name[name.count() - 1];
+        if (c.isUpper() || ignoredFuncs.contains(name))
+            commands.remove(i--);
+    }
+
+    QString licenseHeaderFileName = QString::fromUtf8(argv[2]);
+    QString outputBase = QString::fromUtf8(argv[3]);
+    genVulkanFunctionsH(commands, licenseHeaderFileName, outputBase);
+    genVulkanFunctionsPH(commands, licenseHeaderFileName, outputBase);
+    genVulkanFunctionsPC(commands, licenseHeaderFileName, outputBase);
+
+    return 0;
+}
diff --git a/src/tools/qvkgen/qvkgen.pro b/src/tools/qvkgen/qvkgen.pro
new file mode 100644
index 0000000000..9f2c2f6594
--- /dev/null
+++ b/src/tools/qvkgen/qvkgen.pro
@@ -0,0 +1,5 @@
+option(host_build)
+
+SOURCES += qvkgen.cpp
+
+load(qt_tool)