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[] = { // 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); 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 = 0; // VK_ACCESS_HOST_WRITE_BIT ### no, keep validation layer happy (??) barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; barrier.image = m_texImage; m_devFuncs->vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TOP_OF_PIPE_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_TOP_OF_PIPE_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 }

© 2018 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.