qt 6.5.1 original

examples/vulkan/shared/block.txt

@@ -0,0 +1,100 @@
+# Blender v2.78 (sub 0) OBJ File: ''
+# www.blender.org
+mtllib block.mtl
+o Cube_Cube.001
+v 0.450000 -0.500000 -0.450000
+v 0.450000 -0.500000 0.450000
+v -0.450000 -0.500000 0.450000
+v -0.450000 -0.500000 -0.450000
+v -0.500000 0.450000 0.450000
+v -0.500000 0.450000 -0.450000
+v -0.500000 -0.450000 -0.450000
+v -0.500000 -0.450000 0.450000
+v -0.450000 0.500000 -0.450000
+v -0.450000 0.500000 0.450000
+v 0.450000 0.500000 0.450000
+v 0.450000 0.500000 -0.450000
+v -0.450000 0.450000 -0.500000
+v 0.450000 0.450000 -0.500000
+v 0.450000 -0.450000 -0.500000
+v -0.450000 -0.450000 -0.500000
+v 0.450000 0.450000 0.500000
+v -0.450000 0.450000 0.500000
+v -0.450000 -0.450000 0.500000
+v 0.450000 -0.450000 0.500000
+v 0.500000 -0.450000 -0.450000
+v 0.500000 0.450000 -0.450000
+v 0.500000 -0.450000 0.450000
+v 0.500000 0.450000 0.450000
+vn 0.0000 -1.0000 -0.0000
+vn -1.0000 0.0000 0.0000
+vn 0.0000 1.0000 0.0000
+vn 0.0000 0.0000 -1.0000
+vn 0.0000 -0.0000 1.0000
+vn 0.5774 -0.5773 -0.5774
+vn 0.5774 0.5774 -0.5774
+vn 0.5774 -0.5774 0.5774
+vn 0.5774 0.5773 0.5774
+vn -0.5774 -0.5773 -0.5774
+vn -0.5773 0.5774 -0.5774
+vn -0.5774 -0.5774 0.5774
+vn -0.5774 0.5773 0.5774
+vn 0.7071 0.0000 -0.7071
+vn 0.7071 0.7071 0.0000
+vn 0.7071 -0.0000 0.7071
+vn 0.7071 -0.7071 -0.0000
+vn 0.0000 0.7071 0.7071
+vn -0.7071 -0.0000 0.7071
+vn 0.0000 -0.7071 0.7071
+vn -0.7071 0.7071 0.0000
+vn -0.7071 0.0000 -0.7071
+vn -0.7071 -0.7071 -0.0000
+vn 0.0000 0.7071 -0.7071
+vn 0.0000 -0.7071 -0.7071
+vn 1.0000 0.0000 0.0000
+usemtl None
+s 1
+f 2//1 4//1 1//1
+f 6//2 8//2 5//2
+f 10//3 12//3 9//3
+f 14//4 16//4 13//4
+f 18//5 20//5 17//5
+f 15//6 21//6 1//6
+f 14//7 12//7 22//7
+f 20//8 2//8 23//8
+f 11//9 17//9 24//9
+f 16//10 4//10 7//10
+f 9//11 13//11 6//11
+f 8//12 3//12 19//12
+f 10//13 5//13 18//13
+f 14//14 21//14 15//14
+f 11//15 22//15 12//15
+f 20//16 24//16 17//16
+f 1//17 23//17 2//17
+f 10//18 17//18 11//18
+f 8//19 18//19 5//19
+f 2//20 19//20 3//20
+f 9//21 5//21 10//21
+f 16//22 6//22 13//22
+f 3//23 7//23 4//23
+f 12//24 13//24 9//24
+f 4//25 15//25 1//25
+f 24//26 21//26 22//26
+f 2//1 3//1 4//1
+f 6//2 7//2 8//2
+f 10//3 11//3 12//3
+f 14//4 15//4 16//4
+f 18//5 19//5 20//5
+f 14//14 22//14 21//14
+f 11//15 24//15 22//15
+f 20//16 23//16 24//16
+f 1//17 21//17 23//17
+f 10//18 18//18 17//18
+f 8//19 19//19 18//19
+f 2//20 20//20 19//20
+f 9//21 6//21 5//21
+f 16//22 7//22 6//22
+f 3//23 8//23 7//23
+f 12//24 14//24 13//24
+f 4//25 16//25 15//25
+f 24//26 23//26 21//26

examples/vulkan/shared/color.frag

@@ -0,0 +1,10 @@
+#version 440
+
+layout(location = 0) in vec3 v_color;
+
+layout(location = 0) out vec4 fragColor;
+
+void main()
+{
+    fragColor = vec4(v_color, 1.0);
+}

examples/vulkan/shared/color.vert

@@ -0,0 +1,18 @@
+#version 440
+
+layout(location = 0) in vec4 position;
+layout(location = 1) in vec3 color;
+
+layout(location = 0) out vec3 v_color;
+
+layout(std140, binding = 0) uniform buf {
+    mat4 mvp;
+} ubuf;
+
+out gl_PerVertex { vec4 gl_Position; };
+
+void main()
+{
+    v_color = color;
+    gl_Position = ubuf.mvp * position;
+}

examples/vulkan/shared/objconvert.js

@@ -0,0 +1,194 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+var fs = require('fs');
+
+var metadata = {
+    vertexCount: 0,
+    aabb: [[null, null], [null, null], [null, null]],
+    emitVertex: function(v) {
+        ++metadata.vertexCount;
+        var aabb = metadata.aabb;
+        if (aabb[0][0] === null || v[0] < aabb[0][0]) // min x
+            aabb[0][0] = v[0];
+        if (aabb[0][1] === null || v[0] > aabb[0][1]) // max x
+            aabb[0][1] = v[0];
+        if (aabb[1][0] === null || v[1] < aabb[1][0]) // min y
+            aabb[1][0] = v[1];
+        if (aabb[1][1] === null || v[1] > aabb[1][1]) // max y
+            aabb[1][1] = v[1];
+        if (aabb[2][0] === null || v[2] < aabb[2][0]) // min z
+            aabb[2][0] = v[2];
+        if (aabb[2][1] === null || v[2] > aabb[2][1]) // max z
+            aabb[2][1] = v[2];
+    },
+    getBuffer: function() {
+        var aabb = metadata.aabb;
+        console.log(metadata.vertexCount + " vertices");
+        console.log("AABB: " + aabb[0][0] + ".." + aabb[0][1]
+                    + ", " + aabb[1][0] + ".." + aabb[1][1]
+                    + ", " + aabb[2][0] + ".." + aabb[2][1]);
+        var buf = new Buffer((2 + 6) * 4);
+        var format = 1, p = 0;
+        buf.writeUInt32LE(format, p++);
+        buf.writeUInt32LE(metadata.vertexCount, p++ * 4);
+        for (var i = 0; i < 3; ++i) {
+            buf.writeFloatLE(aabb[i][0], p++ * 4);
+            buf.writeFloatLE(aabb[i][1], p++ * 4);
+        }
+        return buf;
+    }
+};
+
+function makeVec(s, n) {
+    var v = [];
+    s.split(' ').forEach(function (coordStr) {
+        var coord = parseFloat(coordStr);
+        if (!isNaN(coord))
+            v.push(coord);
+    });
+    if (v.length != n) {
+        console.error("Wrong vector size, expected " + n + ", got " + v.length);
+        process.exit();
+    }
+    return v;
+}
+
+function parseObj(filename, callback) {
+    fs.readFile(filename, "ascii", function (err, data) {
+        if (err)
+            throw err;
+        var groupCount = 0;
+        var parsed = { 'vertices': [], 'normals': [], 'texcoords': [], 'links': [] };
+        var missingTexCount = 0, missingNormCount = 0;
+        data.split('\n').forEach(function (line) {
+            var s = line.trim();
+            if (!s.length || groupCount > 1)
+                return;
+            if (s[0] === '#')
+                return;
+            if (s[0] === 'g') {
+                ++groupCount;
+            } else if (s.substr(0, 2) === "v ") {
+                parsed.vertices.push(makeVec(s, 3));
+            } else if (s.substr(0, 3) === "vn ") {
+                parsed.normals.push(makeVec(s, 3));
+            } else if (s.substr(0, 3) === "vt ") {
+                parsed.texcoords.push(makeVec(s, 2));
+            } else if (s.substr(0, 2) === "f ") {
+                var refs = s.split(' ');
+                var vertCount = refs.length - 1;
+                if (vertCount != 3)
+                    console.warn("Face " + parsed.links.length / 3 + " has " + vertCount + " vertices! (not triangulated?)");
+                for (var i = 1, ie = Math.min(4, refs.length); i < ie; ++i) {
+                    var refComps = refs[i].split('/');
+                    var vertIndex = parseInt(refComps[0]) - 1;
+                    var texIndex = -1;
+                    if (refComps.length >= 2 && refComps[1].length)
+                        texIndex = parseInt(refComps[1]) - 1;
+                    var normIndex = -1;
+                    if (refComps.length >= 3 && refComps[2].length)
+                        normIndex = parseInt(refComps[2]) - 1;
+                    parsed.links.push([vertIndex, texIndex, normIndex]);
+                    if (texIndex == -1)
+                        ++missingTexCount;
+                    if (normIndex == -1)
+                        ++missingNormCount;
+                }
+            }
+        });
+        console.log(missingTexCount + " missing texture coordinates, " + missingNormCount + " missing normals");
+        callback(parsed);
+    });
+}
+
+function fillVert(src, index, dst, elemCount, isVertexCoord) {
+    var vertex = [];
+    if (index >= 0) {
+        for (var i = 0; i < elemCount; ++i) {
+            var elem = src[index][i];
+            if (isVertexCoord)
+                vertex.push(elem);
+            dst.buf.writeFloatLE(elem, dst.bufptr++ * 4);
+        }
+        if (vertex.length == 3)
+            metadata.emitVertex(vertex);
+    } else {
+        if (isVertexCoord) {
+            console.error("Missing vertex");
+            process.exit();
+        }
+        for (var i = 0; i < elemCount; ++i)
+            dst.buf.writeFloatLE(0, dst.bufptr++ * 4);
+    }
+    return vertex;
+}
+
+function normalize(v) {
+    var len = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+    if (len == 0.0 || len == 1.0)
+        return;
+    len = Math.sqrt(len);
+    return [ v[0] / len, v[1] / len, v[2] / len ];
+}
+
+function surfaceNormal(a, b, c) {
+    var u = [ b[0] - a[0], b[1] - a[1], b[2] - a[2] ];
+    var v = [ c[0] - a[0], c[1] - a[1], c[2] - a[2] ];
+    var result = [ u[1] * v[2] - u[2] * v[1],
+                   u[2] * v[0] - u[0] * v[2],
+                   u[0] * v[1] - u[1] * v[0] ];
+    return normalize(result);
+}
+
+function objDataToBuf(parsed) {
+    var floatCount = parsed.links.length * (3 + 2 + 3);
+    var buf = new Buffer(floatCount * 4);
+    var dst = { 'buf': buf, 'bufptr': 0 };
+    var tri = [];
+    var genNormals = false;
+    var genNormCount = 0;
+    for (var i = 0; i < parsed.links.length; ++i) {
+        var link = parsed.links[i];
+        var vertIndex = link[0], texIndex = link[1], normIndex = link[2];
+        tri.push(fillVert(parsed.vertices, vertIndex, dst, 3, true));
+        fillVert(parsed.texcoords, texIndex, dst, 2);
+        fillVert(parsed.normals, normIndex, dst, 3);
+        if (normIndex == -1)
+            genNormals = true;
+        if (tri.length == 3) {
+            if (genNormals) {
+                var norm = surfaceNormal(tri[0], tri[1], tri[2]);
+                for (var nvIdx = 0; nvIdx < 3; ++nvIdx) {
+                    dst.buf.writeFloatLE(norm[0], (dst.bufptr - 3 - nvIdx * 8) * 4);
+                    dst.buf.writeFloatLE(norm[1], (dst.bufptr - 2 - nvIdx * 8) * 4);
+                    dst.buf.writeFloatLE(norm[2], (dst.bufptr - 1 - nvIdx * 8) * 4);
+                }
+                genNormCount += 3;
+            }
+            tri = [];
+        }
+    }
+    if (genNormCount)
+        console.log("Generated " + genNormCount + " normals");
+    return buf;
+}
+
+var inFilename = process.argv[2];
+var outFilename = process.argv[3];
+
+if (process.argv.length < 4) {
+    console.log("Usage: objconvert file.obj file.buf");
+    process.exit();
+}
+
+parseObj(inFilename, function (parsed) {
+    var buf = objDataToBuf(parsed);
+    var f = fs.createWriteStream(outFilename);
+    f.on("error", function (e) { console.error(e); });
+    f.write(metadata.getBuffer());
+    f.write(buf);
+    f.end();
+    console.log("Written to " + outFilename + ", format is:");
+    console.log("  uint32 version, uint32 vertex_count, float32 aabb[6], vertex_count * (float32 vertex[3], float32 texcoord[2], float32 normal[3])");
+});

examples/vulkan/shared/trianglerenderer.cpp

@@ -0,0 +1,466 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include "trianglerenderer.h"
+#include <QVulkanFunctions>
+#include <QFile>
+
+// Note that the vertex data and the projection matrix assume OpenGL. With
+// Vulkan Y is negated in clip space and the near/far plane is at 0/1 instead
+// of -1/1. These will be corrected for by an extra transformation when
+// calculating the modelview-projection matrix.
+static float vertexData[] = { // Y up, front = CCW
+     0.0f,   0.5f,   1.0f, 0.0f, 0.0f,
+    -0.5f,  -0.5f,   0.0f, 1.0f, 0.0f,
+     0.5f,  -0.5f,   0.0f, 0.0f, 1.0f
+};
+
+static const int UNIFORM_DATA_SIZE = 16 * sizeof(float);
+
+static inline VkDeviceSize aligned(VkDeviceSize v, VkDeviceSize byteAlign)
+{
+    return (v + byteAlign - 1) & ~(byteAlign - 1);
+}
+
+TriangleRenderer::TriangleRenderer(QVulkanWindow *w, bool msaa)
+    : m_window(w)
+{
+    if (msaa) {
+        const QList<int> counts = w->supportedSampleCounts();
+        qDebug() << "Supported sample counts:" << counts;
+        for (int s = 16; s >= 4; s /= 2) {
+            if (counts.contains(s)) {
+                qDebug("Requesting sample count %d", s);
+                m_window->setSampleCount(s);
+                break;
+            }
+        }
+    }
+}
+
+VkShaderModule TriangleRenderer::createShader(const QString &name)
+{
+    QFile file(name);
+    if (!file.open(QIODevice::ReadOnly)) {
+        qWarning("Failed to read shader %s", qPrintable(name));
+        return VK_NULL_HANDLE;
+    }
+    QByteArray blob = file.readAll();
+    file.close();
+
+    VkShaderModuleCreateInfo shaderInfo;
+    memset(&shaderInfo, 0, sizeof(shaderInfo));
+    shaderInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+    shaderInfo.codeSize = blob.size();
+    shaderInfo.pCode = reinterpret_cast<const uint32_t *>(blob.constData());
+    VkShaderModule shaderModule;
+    VkResult err = m_devFuncs->vkCreateShaderModule(m_window->device(), &shaderInfo, nullptr, &shaderModule);
+    if (err != VK_SUCCESS) {
+        qWarning("Failed to create shader module: %d", err);
+        return VK_NULL_HANDLE;
+    }
+
+    return shaderModule;
+}
+
+void TriangleRenderer::initResources()
+{
+    qDebug("initResources");
+
+    VkDevice dev = m_window->device();
+    m_devFuncs = m_window->vulkanInstance()->deviceFunctions(dev);
+
+    // Prepare the vertex and uniform data. The vertex data will never
+    // change so one buffer is sufficient regardless of the value of
+    // QVulkanWindow::CONCURRENT_FRAME_COUNT. Uniform data is changing per
+    // frame however so active frames have to have a dedicated copy.
+
+    // Use just one memory allocation and one buffer. We will then specify the
+    // appropriate offsets for uniform buffers in the VkDescriptorBufferInfo.
+    // Have to watch out for
+    // VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment, though.
+
+    // The uniform buffer is not strictly required in this example, we could
+    // have used push constants as well since our single matrix (64 bytes) fits
+    // into the spec mandated minimum limit of 128 bytes. However, once that
+    // limit is not sufficient, the per-frame buffers, as shown below, will
+    // become necessary.
+
+    const int concurrentFrameCount = m_window->concurrentFrameCount();
+    const VkPhysicalDeviceLimits *pdevLimits = &m_window->physicalDeviceProperties()->limits;
+    const VkDeviceSize uniAlign = pdevLimits->minUniformBufferOffsetAlignment;
+    qDebug("uniform buffer offset alignment is %u", (uint) uniAlign);
+    VkBufferCreateInfo bufInfo;
+    memset(&bufInfo, 0, sizeof(bufInfo));
+    bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    // Our internal layout is vertex, uniform, uniform, ... with each uniform buffer start offset aligned to uniAlign.
+    const VkDeviceSize vertexAllocSize = aligned(sizeof(vertexData), uniAlign);
+    const VkDeviceSize uniformAllocSize = aligned(UNIFORM_DATA_SIZE, uniAlign);
+    bufInfo.size = vertexAllocSize + concurrentFrameCount * uniformAllocSize;
+    bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+
+    VkResult err = m_devFuncs->vkCreateBuffer(dev, &bufInfo, nullptr, &m_buf);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to create buffer: %d", err);
+
+    VkMemoryRequirements memReq;
+    m_devFuncs->vkGetBufferMemoryRequirements(dev, m_buf, &memReq);
+
+    VkMemoryAllocateInfo memAllocInfo = {
+        VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+        nullptr,
+        memReq.size,
+        m_window->hostVisibleMemoryIndex()
+    };
+
+    err = m_devFuncs->vkAllocateMemory(dev, &memAllocInfo, nullptr, &m_bufMem);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to allocate memory: %d", err);
+
+    err = m_devFuncs->vkBindBufferMemory(dev, m_buf, m_bufMem, 0);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to bind buffer memory: %d", err);
+
+    quint8 *p;
+    err = m_devFuncs->vkMapMemory(dev, m_bufMem, 0, memReq.size, 0, reinterpret_cast<void **>(&p));
+    if (err != VK_SUCCESS)
+        qFatal("Failed to map memory: %d", err);
+    memcpy(p, vertexData, sizeof(vertexData));
+    QMatrix4x4 ident;
+    memset(m_uniformBufInfo, 0, sizeof(m_uniformBufInfo));
+    for (int i = 0; i < concurrentFrameCount; ++i) {
+        const VkDeviceSize offset = vertexAllocSize + i * uniformAllocSize;
+        memcpy(p + offset, ident.constData(), 16 * sizeof(float));
+        m_uniformBufInfo[i].buffer = m_buf;
+        m_uniformBufInfo[i].offset = offset;
+        m_uniformBufInfo[i].range = uniformAllocSize;
+    }
+    m_devFuncs->vkUnmapMemory(dev, m_bufMem);
+
+    VkVertexInputBindingDescription vertexBindingDesc = {
+        0, // binding
+        5 * sizeof(float),
+        VK_VERTEX_INPUT_RATE_VERTEX
+    };
+    VkVertexInputAttributeDescription vertexAttrDesc[] = {
+        { // position
+            0, // location
+            0, // binding
+            VK_FORMAT_R32G32_SFLOAT,
+            0
+        },
+        { // color
+            1,
+            0,
+            VK_FORMAT_R32G32B32_SFLOAT,
+            2 * sizeof(float)
+        }
+    };
+
+    VkPipelineVertexInputStateCreateInfo vertexInputInfo;
+    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+    vertexInputInfo.pNext = nullptr;
+    vertexInputInfo.flags = 0;
+    vertexInputInfo.vertexBindingDescriptionCount = 1;
+    vertexInputInfo.pVertexBindingDescriptions = &vertexBindingDesc;
+    vertexInputInfo.vertexAttributeDescriptionCount = 2;
+    vertexInputInfo.pVertexAttributeDescriptions = vertexAttrDesc;
+
+    // Set up descriptor set and its layout.
+    VkDescriptorPoolSize descPoolSizes = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, uint32_t(concurrentFrameCount) };
+    VkDescriptorPoolCreateInfo descPoolInfo;
+    memset(&descPoolInfo, 0, sizeof(descPoolInfo));
+    descPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+    descPoolInfo.maxSets = concurrentFrameCount;
+    descPoolInfo.poolSizeCount = 1;
+    descPoolInfo.pPoolSizes = &descPoolSizes;
+    err = m_devFuncs->vkCreateDescriptorPool(dev, &descPoolInfo, nullptr, &m_descPool);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to create descriptor pool: %d", err);
+
+    VkDescriptorSetLayoutBinding layoutBinding = {
+        0, // binding
+        VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+        1,
+        VK_SHADER_STAGE_VERTEX_BIT,
+        nullptr
+    };
+    VkDescriptorSetLayoutCreateInfo descLayoutInfo = {
+        VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+        nullptr,
+        0,
+        1,
+        &layoutBinding
+    };
+    err = m_devFuncs->vkCreateDescriptorSetLayout(dev, &descLayoutInfo, nullptr, &m_descSetLayout);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to create descriptor set layout: %d", err);
+
+    for (int i = 0; i < concurrentFrameCount; ++i) {
+        VkDescriptorSetAllocateInfo descSetAllocInfo = {
+            VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+            nullptr,
+            m_descPool,
+            1,
+            &m_descSetLayout
+        };
+        err = m_devFuncs->vkAllocateDescriptorSets(dev, &descSetAllocInfo, &m_descSet[i]);
+        if (err != VK_SUCCESS)
+            qFatal("Failed to allocate descriptor set: %d", err);
+
+        VkWriteDescriptorSet descWrite;
+        memset(&descWrite, 0, sizeof(descWrite));
+        descWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        descWrite.dstSet = m_descSet[i];
+        descWrite.descriptorCount = 1;
+        descWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+        descWrite.pBufferInfo = &m_uniformBufInfo[i];
+        m_devFuncs->vkUpdateDescriptorSets(dev, 1, &descWrite, 0, nullptr);
+    }
+
+    // Pipeline cache
+    VkPipelineCacheCreateInfo pipelineCacheInfo;
+    memset(&pipelineCacheInfo, 0, sizeof(pipelineCacheInfo));
+    pipelineCacheInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+    err = m_devFuncs->vkCreatePipelineCache(dev, &pipelineCacheInfo, nullptr, &m_pipelineCache);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to create pipeline cache: %d", err);
+
+    // Pipeline layout
+    VkPipelineLayoutCreateInfo pipelineLayoutInfo;
+    memset(&pipelineLayoutInfo, 0, sizeof(pipelineLayoutInfo));
+    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+    pipelineLayoutInfo.setLayoutCount = 1;
+    pipelineLayoutInfo.pSetLayouts = &m_descSetLayout;
+    err = m_devFuncs->vkCreatePipelineLayout(dev, &pipelineLayoutInfo, nullptr, &m_pipelineLayout);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to create pipeline layout: %d", err);
+
+    // Shaders
+    VkShaderModule vertShaderModule = createShader(QStringLiteral(":/color_vert.spv"));
+    VkShaderModule fragShaderModule = createShader(QStringLiteral(":/color_frag.spv"));
+
+    // Graphics pipeline
+    VkGraphicsPipelineCreateInfo pipelineInfo;
+    memset(&pipelineInfo, 0, sizeof(pipelineInfo));
+    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+
+    VkPipelineShaderStageCreateInfo shaderStages[2] = {
+        {
+            VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+            nullptr,
+            0,
+            VK_SHADER_STAGE_VERTEX_BIT,
+            vertShaderModule,
+            "main",
+            nullptr
+        },
+        {
+            VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+            nullptr,
+            0,
+            VK_SHADER_STAGE_FRAGMENT_BIT,
+            fragShaderModule,
+            "main",
+            nullptr
+        }
+    };
+    pipelineInfo.stageCount = 2;
+    pipelineInfo.pStages = shaderStages;
+
+    pipelineInfo.pVertexInputState = &vertexInputInfo;
+
+    VkPipelineInputAssemblyStateCreateInfo ia;
+    memset(&ia, 0, sizeof(ia));
+    ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    pipelineInfo.pInputAssemblyState = &ia;
+
+    // The viewport and scissor will be set dynamically via vkCmdSetViewport/Scissor.
+    // This way the pipeline does not need to be touched when resizing the window.
+    VkPipelineViewportStateCreateInfo vp;
+    memset(&vp, 0, sizeof(vp));
+    vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    vp.viewportCount = 1;
+    vp.scissorCount = 1;
+    pipelineInfo.pViewportState = &vp;
+
+    VkPipelineRasterizationStateCreateInfo rs;
+    memset(&rs, 0, sizeof(rs));
+    rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    rs.polygonMode = VK_POLYGON_MODE_FILL;
+    rs.cullMode = VK_CULL_MODE_NONE; // we want the back face as well
+    rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+    rs.lineWidth = 1.0f;
+    pipelineInfo.pRasterizationState = &rs;
+
+    VkPipelineMultisampleStateCreateInfo ms;
+    memset(&ms, 0, sizeof(ms));
+    ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    // Enable multisampling.
+    ms.rasterizationSamples = m_window->sampleCountFlagBits();
+    pipelineInfo.pMultisampleState = &ms;
+
+    VkPipelineDepthStencilStateCreateInfo ds;
+    memset(&ds, 0, sizeof(ds));
+    ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+    ds.depthTestEnable = VK_TRUE;
+    ds.depthWriteEnable = VK_TRUE;
+    ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
+    pipelineInfo.pDepthStencilState = &ds;
+
+    VkPipelineColorBlendStateCreateInfo cb;
+    memset(&cb, 0, sizeof(cb));
+    cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    // no blend, write out all of rgba
+    VkPipelineColorBlendAttachmentState att;
+    memset(&att, 0, sizeof(att));
+    att.colorWriteMask = 0xF;
+    cb.attachmentCount = 1;
+    cb.pAttachments = &att;
+    pipelineInfo.pColorBlendState = &cb;
+
+    VkDynamicState dynEnable[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
+    VkPipelineDynamicStateCreateInfo dyn;
+    memset(&dyn, 0, sizeof(dyn));
+    dyn.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+    dyn.dynamicStateCount = sizeof(dynEnable) / sizeof(VkDynamicState);
+    dyn.pDynamicStates = dynEnable;
+    pipelineInfo.pDynamicState = &dyn;
+
+    pipelineInfo.layout = m_pipelineLayout;
+    pipelineInfo.renderPass = m_window->defaultRenderPass();
+
+    err = m_devFuncs->vkCreateGraphicsPipelines(dev, m_pipelineCache, 1, &pipelineInfo, nullptr, &m_pipeline);
+    if (err != VK_SUCCESS)
+        qFatal("Failed to create graphics pipeline: %d", err);
+
+    if (vertShaderModule)
+        m_devFuncs->vkDestroyShaderModule(dev, vertShaderModule, nullptr);
+    if (fragShaderModule)
+        m_devFuncs->vkDestroyShaderModule(dev, fragShaderModule, nullptr);
+}
+
+void TriangleRenderer::initSwapChainResources()
+{
+    qDebug("initSwapChainResources");
+
+    // Projection matrix
+    m_proj = m_window->clipCorrectionMatrix(); // adjust for Vulkan-OpenGL clip space differences
+    const QSize sz = m_window->swapChainImageSize();
+    m_proj.perspective(45.0f, sz.width() / (float) sz.height(), 0.01f, 100.0f);
+    m_proj.translate(0, 0, -4);
+}
+
+void TriangleRenderer::releaseSwapChainResources()
+{
+    qDebug("releaseSwapChainResources");
+}
+
+void TriangleRenderer::releaseResources()
+{
+    qDebug("releaseResources");
+
+    VkDevice dev = m_window->device();
+
+    if (m_pipeline) {
+        m_devFuncs->vkDestroyPipeline(dev, m_pipeline, nullptr);
+        m_pipeline = VK_NULL_HANDLE;
+    }
+
+    if (m_pipelineLayout) {
+        m_devFuncs->vkDestroyPipelineLayout(dev, m_pipelineLayout, nullptr);
+        m_pipelineLayout = VK_NULL_HANDLE;
+    }
+
+    if (m_pipelineCache) {
+        m_devFuncs->vkDestroyPipelineCache(dev, m_pipelineCache, nullptr);
+        m_pipelineCache = VK_NULL_HANDLE;
+    }
+
+    if (m_descSetLayout) {
+        m_devFuncs->vkDestroyDescriptorSetLayout(dev, m_descSetLayout, nullptr);
+        m_descSetLayout = VK_NULL_HANDLE;
+    }
+
+    if (m_descPool) {
+        m_devFuncs->vkDestroyDescriptorPool(dev, m_descPool, nullptr);
+        m_descPool = VK_NULL_HANDLE;
+    }
+
+    if (m_buf) {
+        m_devFuncs->vkDestroyBuffer(dev, m_buf, nullptr);
+        m_buf = VK_NULL_HANDLE;
+    }
+
+    if (m_bufMem) {
+        m_devFuncs->vkFreeMemory(dev, m_bufMem, nullptr);
+        m_bufMem = VK_NULL_HANDLE;
+    }
+}
+
+void TriangleRenderer::startNextFrame()
+{
+    VkDevice dev = m_window->device();
+    VkCommandBuffer cb = m_window->currentCommandBuffer();
+    const QSize sz = m_window->swapChainImageSize();
+
+    VkClearColorValue clearColor = {{ 0, 0, 0, 1 }};
+    VkClearDepthStencilValue clearDS = { 1, 0 };
+    VkClearValue clearValues[3];
+    memset(clearValues, 0, sizeof(clearValues));
+    clearValues[0].color = clearValues[2].color = clearColor;
+    clearValues[1].depthStencil = clearDS;
+
+    VkRenderPassBeginInfo rpBeginInfo;
+    memset(&rpBeginInfo, 0, sizeof(rpBeginInfo));
+    rpBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+    rpBeginInfo.renderPass = m_window->defaultRenderPass();
+    rpBeginInfo.framebuffer = m_window->currentFramebuffer();
+    rpBeginInfo.renderArea.extent.width = sz.width();
+    rpBeginInfo.renderArea.extent.height = sz.height();
+    rpBeginInfo.clearValueCount = m_window->sampleCountFlagBits() > VK_SAMPLE_COUNT_1_BIT ? 3 : 2;
+    rpBeginInfo.pClearValues = clearValues;
+    VkCommandBuffer cmdBuf = m_window->currentCommandBuffer();
+    m_devFuncs->vkCmdBeginRenderPass(cmdBuf, &rpBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+    quint8 *p;
+    VkResult err = m_devFuncs->vkMapMemory(dev, m_bufMem, m_uniformBufInfo[m_window->currentFrame()].offset,
+            UNIFORM_DATA_SIZE, 0, reinterpret_cast<void **>(&p));
+    if (err != VK_SUCCESS)
+        qFatal("Failed to map memory: %d", err);
+    QMatrix4x4 m = m_proj;
+    m.rotate(m_rotation, 0, 1, 0);
+    memcpy(p, m.constData(), 16 * sizeof(float));
+    m_devFuncs->vkUnmapMemory(dev, m_bufMem);
+
+    // Not exactly a real animation system, just advance on every frame for now.
+    m_rotation += 1.0f;
+
+    m_devFuncs->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline);
+    m_devFuncs->vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipelineLayout, 0, 1,
+                               &m_descSet[m_window->currentFrame()], 0, nullptr);
+    VkDeviceSize vbOffset = 0;
+    m_devFuncs->vkCmdBindVertexBuffers(cb, 0, 1, &m_buf, &vbOffset);
+
+    VkViewport viewport;
+    viewport.x = viewport.y = 0;
+    viewport.width = sz.width();
+    viewport.height = sz.height();
+    viewport.minDepth = 0;
+    viewport.maxDepth = 1;
+    m_devFuncs->vkCmdSetViewport(cb, 0, 1, &viewport);
+
+    VkRect2D scissor;
+    scissor.offset.x = scissor.offset.y = 0;
+    scissor.extent.width = viewport.width;
+    scissor.extent.height = viewport.height;
+    m_devFuncs->vkCmdSetScissor(cb, 0, 1, &scissor);
+
+    m_devFuncs->vkCmdDraw(cb, 3, 1, 0, 0);
+
+    m_devFuncs->vkCmdEndRenderPass(cmdBuf);
+
+    m_window->frameReady();
+    m_window->requestUpdate(); // render continuously, throttled by the presentation rate
+}

examples/vulkan/shared/trianglerenderer.h

@@ -0,0 +1,43 @@
+// Copyright (C) 2017 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#ifndef TRIANGLERENDERER_H
+#define TRIANGLERENDERER_H
+
+#include <QVulkanWindow>
+
+class TriangleRenderer : public QVulkanWindowRenderer
+{
+public:
+    TriangleRenderer(QVulkanWindow *w, bool msaa = false);
+
+    void initResources() override;
+    void initSwapChainResources() override;
+    void releaseSwapChainResources() override;
+    void releaseResources() override;
+
+    void startNextFrame() override;
+
+protected:
+    VkShaderModule createShader(const QString &name);
+
+    QVulkanWindow *m_window;
+    QVulkanDeviceFunctions *m_devFuncs;
+
+    VkDeviceMemory m_bufMem = VK_NULL_HANDLE;
+    VkBuffer m_buf = VK_NULL_HANDLE;
+    VkDescriptorBufferInfo m_uniformBufInfo[QVulkanWindow::MAX_CONCURRENT_FRAME_COUNT];
+
+    VkDescriptorPool m_descPool = VK_NULL_HANDLE;
+    VkDescriptorSetLayout m_descSetLayout = VK_NULL_HANDLE;
+    VkDescriptorSet m_descSet[QVulkanWindow::MAX_CONCURRENT_FRAME_COUNT];
+
+    VkPipelineCache m_pipelineCache = VK_NULL_HANDLE;
+    VkPipelineLayout m_pipelineLayout = VK_NULL_HANDLE;
+    VkPipeline m_pipeline = VK_NULL_HANDLE;
+
+    QMatrix4x4 m_proj;
+    float m_rotation = 0.0f;
+};
+
+#endif // TRIANGLERENDERER_H