hellovulkantexture.cpp Example File | Qt GUI 5.12.4

Qt 5.12 | Qt GUI | Hello Vulkan Texture Vulkan Example | hellovulkantexture.cpp Example File

Qt 5.12.4 Reference Documentation

# hellovulkantexture.cpp Example File

hellovulkantexture/hellovulkantexture.cpp

      /****************************************************************************
      **
      ** Copyright (C) 2017 The Qt Company Ltd.
      ** Contact: https://www.qt.io/licensing/
      **
      ** This file is part of the examples of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** 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.
      **
      ** BSD License Usage
      ** Alternatively, you may use this file under the terms of the BSD license
      ** as follows:
      **
      ** "Redistribution and use in source and binary forms, with or without
      ** modification, are permitted provided that the following conditions are
      ** met:
      **   * Redistributions of source code must retain the above copyright
      **     notice, this list of conditions and the following disclaimer.
      **   * Redistributions in binary form must reproduce the above copyright
      **     notice, this list of conditions and the following disclaimer in
      **     the documentation and/or other materials provided with the
      **     distribution.
      **   * Neither the name of The Qt Company Ltd nor the names of its
      **     contributors may be used to endorse or promote products derived
      **     from this software without specific prior written permission.
      **
      **
      ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
      **
      ** $QT_END_LICENSE$
      **
      ****************************************************************************/

      #include "hellovulkantexture.h"
      #include <QVulkanFunctions>
      #include <QCoreApplication>
      #include <QFile>

      // Use a triangle strip to get a quad.
      //
      // 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 = CW
          // x, y, z, u, v
          -1, -1, 0, 0, 1,
          -1,  1, 0, 0, 0,
           1, -1, 0, 1, 1,
           1,  1, 0, 1, 0
      };

      static const int UNIFORM_DATA_SIZE = 16 * sizeof(float);

      static inline VkDeviceSize aligned(VkDeviceSize v, VkDeviceSize byteAlign)
      {
          return (v + byteAlign - 1) & ~(byteAlign - 1);
      }

      QVulkanWindowRenderer *VulkanWindow::createRenderer()
      {
          return new VulkanRenderer(this);
      }

      VulkanRenderer::VulkanRenderer(QVulkanWindow *w)
          : m_window(w)
      {
      }

      VkShaderModule VulkanRenderer::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;
      }

      bool VulkanRenderer::createTexture(const QString &name)
      {
          QImage img(name);
          if (img.isNull()) {
              qWarning("Failed to load image %s", qPrintable(name));
              return false;
          }

          // Convert to byte ordered RGBA8. Use premultiplied alpha, see pColorBlendState in the pipeline.
          img = img.convertToFormat(QImage::Format_RGBA8888_Premultiplied);

          QVulkanFunctions *f = m_window->vulkanInstance()->functions();
          VkDevice dev = m_window->device();

          const bool srgb = QCoreApplication::arguments().contains(QStringLiteral("--srgb"));
          if (srgb)
              qDebug("sRGB swapchain was requested, making texture sRGB too");

          m_texFormat = srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;

          // Now we can either map and copy the image data directly, or have to go
          // through a staging buffer to copy and convert into the internal optimal
          // tiling format.
          VkFormatProperties props;
          f->vkGetPhysicalDeviceFormatProperties(m_window->physicalDevice(), m_texFormat, &props);
          const bool canSampleLinear = (props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT);
          const bool canSampleOptimal = (props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT);
          if (!canSampleLinear && !canSampleOptimal) {
              qWarning("Neither linear nor optimal image sampling is supported for RGBA8");
              return false;
          }

          static bool alwaysStage = qEnvironmentVariableIntValue("QT_VK_FORCE_STAGE_TEX");

          if (canSampleLinear && !alwaysStage) {
              if (!createTextureImage(img.size(), &m_texImage, &m_texMem,
                                      VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_SAMPLED_BIT,
                                      m_window->hostVisibleMemoryIndex()))
                  return false;

              if (!writeLinearImage(img, m_texImage, m_texMem))
                  return false;

              m_texLayoutPending = true;
          } else {
              if (!createTextureImage(img.size(), &m_texStaging, &m_texStagingMem,
                                      VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
                                      m_window->hostVisibleMemoryIndex()))
                  return false;

              if (!createTextureImage(img.size(), &m_texImage, &m_texMem,
                                      VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
                                      m_window->deviceLocalMemoryIndex()))
                  return false;

              if (!writeLinearImage(img, m_texStaging, m_texStagingMem))
                  return false;

              m_texStagingPending = true;
          }

          VkImageViewCreateInfo viewInfo;
          memset(&viewInfo, 0, sizeof(viewInfo));
          viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
          viewInfo.image = m_texImage;
          viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
          viewInfo.format = m_texFormat;
          viewInfo.components.r = VK_COMPONENT_SWIZZLE_R;
          viewInfo.components.g = VK_COMPONENT_SWIZZLE_G;
          viewInfo.components.b = VK_COMPONENT_SWIZZLE_B;
          viewInfo.components.a = VK_COMPONENT_SWIZZLE_A;
          viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
          viewInfo.subresourceRange.levelCount = viewInfo.subresourceRange.layerCount = 1;

          VkResult err = m_devFuncs->vkCreateImageView(dev, &viewInfo, nullptr, &m_texView);
          if (err != VK_SUCCESS) {
              qWarning("Failed to create image view for texture: %d", err);
              return false;
          }

          m_texSize = img.size();

          return true;
      }

      bool VulkanRenderer::createTextureImage(const QSize &size, VkImage *image, VkDeviceMemory *mem,
                                              VkImageTiling tiling, VkImageUsageFlags usage, uint32_t memIndex)
      {
          VkDevice dev = m_window->device();

          VkImageCreateInfo imageInfo;
          memset(&imageInfo, 0, sizeof(imageInfo));
          imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
          imageInfo.imageType = VK_IMAGE_TYPE_2D;
          imageInfo.format = m_texFormat;
          imageInfo.extent.width = size.width();
          imageInfo.extent.height = size.height();
          imageInfo.extent.depth = 1;
          imageInfo.mipLevels = 1;
          imageInfo.arrayLayers = 1;
          imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
          imageInfo.tiling = tiling;
          imageInfo.usage = usage;
          imageInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;

          VkResult err = m_devFuncs->vkCreateImage(dev, &imageInfo, nullptr, image);
          if (err != VK_SUCCESS) {
              qWarning("Failed to create linear image for texture: %d", err);
              return false;
          }

          VkMemoryRequirements memReq;
          m_devFuncs->vkGetImageMemoryRequirements(dev, *image, &memReq);

          if (!(memReq.memoryTypeBits & (1 << memIndex))) {
              VkPhysicalDeviceMemoryProperties physDevMemProps;
              m_window->vulkanInstance()->functions()->vkGetPhysicalDeviceMemoryProperties(m_window->physicalDevice(), &physDevMemProps);
              for (uint32_t i = 0; i < physDevMemProps.memoryTypeCount; ++i) {
                  if (!(memReq.memoryTypeBits & (1 << i)))
                      continue;
                  memIndex = i;
              }
          }

          VkMemoryAllocateInfo allocInfo = {
              VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
              nullptr,
              memReq.size,
              memIndex
          };
          qDebug("allocating %u bytes for texture image", uint32_t(memReq.size));

          err = m_devFuncs->vkAllocateMemory(dev, &allocInfo, nullptr, mem);
          if (err != VK_SUCCESS) {
              qWarning("Failed to allocate memory for linear image: %d", err);
              return false;
          }

          err = m_devFuncs->vkBindImageMemory(dev, *image, *mem, 0);
          if (err != VK_SUCCESS) {
              qWarning("Failed to bind linear image memory: %d", err);
              return false;
          }

          return true;
      }

      bool VulkanRenderer::writeLinearImage(const QImage &img, VkImage image, VkDeviceMemory memory)
      {
          VkDevice dev = m_window->device();

          VkImageSubresource subres = {
              VK_IMAGE_ASPECT_COLOR_BIT,
              0, // mip level
              0
          };
          VkSubresourceLayout layout;
          m_devFuncs->vkGetImageSubresourceLayout(dev, image, &subres, &layout);

          uchar *p;
          VkResult err = m_devFuncs->vkMapMemory(dev, memory, layout.offset, layout.size, 0, reinterpret_cast<void **>(&p));
          if (err != VK_SUCCESS) {
              qWarning("Failed to map memory for linear image: %d", err);
              return false;
          }

          for (int y = 0; y < img.height(); ++y) {
              const uchar *line = img.constScanLine(y);
              memcpy(p, line, img.width() * 4);
              p += layout.rowPitch;
          }

          m_devFuncs->vkUnmapMemory(dev, memory);
          return true;
      }

      void VulkanRenderer::ensureTexture()
      {
          if (!m_texLayoutPending && !m_texStagingPending)
              return;

          Q_ASSERT(m_texLayoutPending != m_texStagingPending);
          VkCommandBuffer cb = m_window->currentCommandBuffer();

          VkImageMemoryBarrier barrier;
          memset(&barrier, 0, sizeof(barrier));
          barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
          barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
          barrier.subresourceRange.levelCount = barrier.subresourceRange.layerCount = 1;

          if (m_texLayoutPending) {
              m_texLayoutPending = false;

              barrier.oldLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
              barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
              barrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
              barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
              barrier.image = m_texImage;

              m_devFuncs->vkCmdPipelineBarrier(cb,
                                      VK_PIPELINE_STAGE_HOST_BIT,
                                      VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                                      0, 0, nullptr, 0, nullptr,
                                      1, &barrier);
          } else {
              m_texStagingPending = false;

              barrier.oldLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
              barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
              barrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
              barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
              barrier.image = m_texStaging;
              m_devFuncs->vkCmdPipelineBarrier(cb,
                                      VK_PIPELINE_STAGE_HOST_BIT,
                                      VK_PIPELINE_STAGE_TRANSFER_BIT,
                                      0, 0, nullptr, 0, nullptr,
                                      1, &barrier);

              barrier.oldLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
              barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
              barrier.srcAccessMask = 0;
              barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
              barrier.image = m_texImage;
              m_devFuncs->vkCmdPipelineBarrier(cb,
                                      VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                      VK_PIPELINE_STAGE_TRANSFER_BIT,
                                      0, 0, nullptr, 0, nullptr,
                                      1, &barrier);

              VkImageCopy copyInfo;
              memset(&copyInfo, 0, sizeof(copyInfo));
              copyInfo.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
              copyInfo.srcSubresource.layerCount = 1;
              copyInfo.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
              copyInfo.dstSubresource.layerCount = 1;
              copyInfo.extent.width = m_texSize.width();
              copyInfo.extent.height = m_texSize.height();
              copyInfo.extent.depth = 1;
              m_devFuncs->vkCmdCopyImage(cb, m_texStaging, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                m_texImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copyInfo);

              barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
              barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
              barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
              barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
              barrier.image = m_texImage;
              m_devFuncs->vkCmdPipelineBarrier(cb,
                                      VK_PIPELINE_STAGE_TRANSFER_BIT,
                                      VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                                      0, 0, nullptr, 0, nullptr,
                                      1, &barrier);
          }
      }

      void VulkanRenderer::initResources()
      {
          qDebug("initResources");

          VkDevice dev = m_window->device();
          m_devFuncs = m_window->vulkanInstance()->deviceFunctions(dev);

          // The setup is similar to hellovulkantriangle. The difference is the
          // presence of a second vertex attribute (texcoord), a sampler, and that we
          // need blending.

          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_R32G32B32_SFLOAT,
                  0
              },
              { // texcoord
                  1,
                  0,
                  VK_FORMAT_R32G32_SFLOAT,
                  3 * 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;

          // Sampler.
          VkSamplerCreateInfo samplerInfo;
          memset(&samplerInfo, 0, sizeof(samplerInfo));
          samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
          samplerInfo.magFilter = VK_FILTER_NEAREST;
          samplerInfo.minFilter = VK_FILTER_NEAREST;
          samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
          samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
          samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
          samplerInfo.maxAnisotropy = 1.0f;
          err = m_devFuncs->vkCreateSampler(dev, &samplerInfo, nullptr, &m_sampler);
          if (err != VK_SUCCESS)
              qFatal("Failed to create sampler: %d", err);

          // Texture.
          if (!createTexture(QStringLiteral(":/qt256.png")))
              qFatal("Failed to create texture");

          // Set up descriptor set and its layout.
          VkDescriptorPoolSize descPoolSizes[2] = {
              { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, uint32_t(concurrentFrameCount) },
              { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, uint32_t(concurrentFrameCount) }
          };
          VkDescriptorPoolCreateInfo descPoolInfo;
          memset(&descPoolInfo, 0, sizeof(descPoolInfo));
          descPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
          descPoolInfo.maxSets = concurrentFrameCount;
          descPoolInfo.poolSizeCount = 2;
          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[2] =
          {
              {
                  0, // binding
                  VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                  1, // descriptorCount
                  VK_SHADER_STAGE_VERTEX_BIT,
                  nullptr
              },
              {
                  1, // binding
                  VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                  1, // descriptorCount
                  VK_SHADER_STAGE_FRAGMENT_BIT,
                  nullptr
              }
          };
          VkDescriptorSetLayoutCreateInfo descLayoutInfo = {
              VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
              nullptr,
              0,
              2, // bindingCount
              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[2];
              memset(descWrite, 0, sizeof(descWrite));
              descWrite[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
              descWrite[0].dstSet = m_descSet[i];
              descWrite[0].dstBinding = 0;
              descWrite[0].descriptorCount = 1;
              descWrite[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
              descWrite[0].pBufferInfo = &m_uniformBufInfo[i];

              VkDescriptorImageInfo descImageInfo = {
                  m_sampler,
                  m_texView,
                  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
              };

              descWrite[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
              descWrite[1].dstSet = m_descSet[i];
              descWrite[1].dstBinding = 1;
              descWrite[1].descriptorCount = 1;
              descWrite[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
              descWrite[1].pImageInfo = &descImageInfo;

              m_devFuncs->vkUpdateDescriptorSets(dev, 2, 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(":/texture_vert.spv"));
          VkShaderModule fragShaderModule = createShader(QStringLiteral(":/texture_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_STRIP;
          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_BACK_BIT;
          rs.frontFace = VK_FRONT_FACE_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;
          ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
          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;
          // assume pre-multiplied alpha, blend, write out all of rgba
          VkPipelineColorBlendAttachmentState att;
          memset(&att, 0, sizeof(att));
          att.colorWriteMask = 0xF;
          att.blendEnable = VK_TRUE;
          att.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
          att.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
          att.colorBlendOp = VK_BLEND_OP_ADD;
          att.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
          att.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
          att.alphaBlendOp = VK_BLEND_OP_ADD;
          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 VulkanRenderer::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 VulkanRenderer::releaseSwapChainResources()
      {
          qDebug("releaseSwapChainResources");
      }

      void VulkanRenderer::releaseResources()
      {
          qDebug("releaseResources");

          VkDevice dev = m_window->device();

          if (m_sampler) {
              m_devFuncs->vkDestroySampler(dev, m_sampler, nullptr);
              m_sampler = VK_NULL_HANDLE;
          }

          if (m_texStaging) {
              m_devFuncs->vkDestroyImage(dev, m_texStaging, nullptr);
              m_texStaging = VK_NULL_HANDLE;
          }

          if (m_texStagingMem) {
              m_devFuncs->vkFreeMemory(dev, m_texStagingMem, nullptr);
              m_texStagingMem = VK_NULL_HANDLE;
          }

          if (m_texView) {
              m_devFuncs->vkDestroyImageView(dev, m_texView, nullptr);
              m_texView = VK_NULL_HANDLE;
          }

          if (m_texImage) {
              m_devFuncs->vkDestroyImage(dev, m_texImage, nullptr);
              m_texImage = VK_NULL_HANDLE;
          }

          if (m_texMem) {
              m_devFuncs->vkFreeMemory(dev, m_texMem, nullptr);
              m_texMem = VK_NULL_HANDLE;
          }

          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 VulkanRenderer::startNextFrame()
      {
          VkDevice dev = m_window->device();
          VkCommandBuffer cb = m_window->currentCommandBuffer();
          const QSize sz = m_window->swapChainImageSize();

          // Add the necessary barriers and do the host-linear -> device-optimal copy, if not yet done.
          ensureTexture();

          VkClearColorValue clearColor = {{ 0, 0, 0, 1 }};
          VkClearDepthStencilValue clearDS = { 1, 0 };
          VkClearValue clearValues[2];
          memset(clearValues, 0, sizeof(clearValues));
          clearValues[0].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 = 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, 0, 1);
          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, 4, 1, 0, 0);

          m_devFuncs->vkCmdEndRenderPass(cmdBuf);

          m_window->frameReady();
          m_window->requestUpdate(); // render continuously, throttled by the presentation rate
      }