Revision control
++ // Copyright (C) 2019 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
++
++ #include "vulkantextureimport.h"
++
++ #include <QtGui/QScreen>
++ #include <QtQuick/QQuickWindow>
++ #include <QtQuick/QSGTextureProvider>
++ #include <QtQuick/QSGSimpleTextureNode>
++
++ #include <QVulkanInstance>
++ #include <QVulkanFunctions>
++ #include <QFile>
++
++ class CustomTextureNode : public QSGTextureProvider, public QSGSimpleTextureNode
++ {
++ Q_OBJECT
++
++ public:
++ CustomTextureNode(QQuickItem *item);
++ ~CustomTextureNode() override;
++
++ QSGTexture *texture() const override;
++
++ void sync();
++
++ private slots:
++ void render();
++
++ private:
++ enum Stage {
++ VertexStage,
++ FragmentStage
++ };
++ void prepareShader(Stage stage);
++ bool buildTexture(const QSize &size);
++ void freeTexture();
++ bool createRenderPass();
++ bool initialize();
++
++ QQuickItem *m_item;
++ QQuickWindow *m_window;
++ QSize m_size;
++ qreal m_dpr;
++
++ QByteArray m_vert;
++ QByteArray m_frag;
++
++ VkImage m_texture = VK_NULL_HANDLE;
++ VkDeviceMemory m_textureMemory = VK_NULL_HANDLE;
++ VkFramebuffer m_textureFramebuffer = VK_NULL_HANDLE;
++ VkImageView m_textureView = VK_NULL_HANDLE;
++
++ bool m_initialized = false;
++
++ float m_t;
++
++ VkPhysicalDevice m_physDev = VK_NULL_HANDLE;
++ VkDevice m_dev = VK_NULL_HANDLE;
++ QVulkanDeviceFunctions *m_devFuncs = nullptr;
++ QVulkanFunctions *m_funcs = nullptr;
++
++ VkBuffer m_vbuf = VK_NULL_HANDLE;
++ VkDeviceMemory m_vbufMem = VK_NULL_HANDLE;
++ VkBuffer m_ubuf = VK_NULL_HANDLE;
++ VkDeviceMemory m_ubufMem = VK_NULL_HANDLE;
++ VkDeviceSize m_allocPerUbuf = 0;
++
++ VkPipelineCache m_pipelineCache = VK_NULL_HANDLE;
++
++ VkPipelineLayout m_pipelineLayout = VK_NULL_HANDLE;
++ VkDescriptorSetLayout m_resLayout = VK_NULL_HANDLE;
++ VkPipeline m_pipeline = VK_NULL_HANDLE;
++
++ VkDescriptorPool m_descriptorPool = VK_NULL_HANDLE;
++ VkDescriptorSet m_ubufDescriptor = VK_NULL_HANDLE;
++
++ VkRenderPass m_renderPass = VK_NULL_HANDLE;
++ };
++
++ CustomTextureItem::CustomTextureItem()
++ {
++ setFlag(ItemHasContents, true);
++ }
++
++ void CustomTextureItem::invalidateSceneGraph() // called on the render thread when the scenegraph is invalidated
++ {
++ m_node = nullptr;
++ }
++
++ void CustomTextureItem::releaseResources() // called on the gui thread if the item is removed from scene
++ {
++ m_node = nullptr;
++ }
++
++ QSGNode *CustomTextureItem::updatePaintNode(QSGNode *node, UpdatePaintNodeData *)
++ {
++ CustomTextureNode *n = static_cast<CustomTextureNode *>(node);
++
++ if (!n && (width() <= 0 || height() <= 0))
++ return nullptr;
++
++ if (!n) {
++ m_node = new CustomTextureNode(this);
++ n = m_node;
++ }
++
++ m_node->sync();
++
++ n->setTextureCoordinatesTransform(QSGSimpleTextureNode::NoTransform);
++ n->setFiltering(QSGTexture::Linear);
++ n->setRect(0, 0, width(), height());
++
++ window()->update(); // ensure getting to beforeRendering() at some point
++
++ return n;
++ }
++
++ void CustomTextureItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
++ {
++ QQuickItem::geometryChange(newGeometry, oldGeometry);
++
++ if (newGeometry.size() != oldGeometry.size())
++ update();
++ }
++
++ void CustomTextureItem::setT(qreal t)
++ {
++ if (t == m_t)
++ return;
++
++ m_t = t;
++ emit tChanged();
++
++ update();
++ }
++
++ CustomTextureNode::CustomTextureNode(QQuickItem *item)
++ : m_item(item)
++ {
++ m_window = m_item->window();
++ connect(m_window, &QQuickWindow::beforeRendering, this, &CustomTextureNode::render);
++ connect(m_window, &QQuickWindow::screenChanged, this, [this]() {
++ if (m_window->effectiveDevicePixelRatio() != m_dpr)
++ m_item->update();
++ });
++ }
++
++ CustomTextureNode::~CustomTextureNode()
++ {
++ m_devFuncs->vkDestroyBuffer(m_dev, m_vbuf, nullptr);
++ m_devFuncs->vkDestroyBuffer(m_dev, m_ubuf, nullptr);
++ m_devFuncs->vkFreeMemory(m_dev, m_vbufMem, nullptr);
++ m_devFuncs->vkFreeMemory(m_dev, m_ubufMem, nullptr);
++
++ m_devFuncs->vkDestroyPipelineCache(m_dev, m_pipelineCache, nullptr);
++ m_devFuncs->vkDestroyPipelineLayout(m_dev, m_pipelineLayout, nullptr);
++ m_devFuncs->vkDestroyPipeline(m_dev, m_pipeline, nullptr);
++
++ m_devFuncs->vkDestroyRenderPass(m_dev, m_renderPass, nullptr);
++
++ m_devFuncs->vkDestroyDescriptorSetLayout(m_dev, m_resLayout, nullptr);
++ m_devFuncs->vkDestroyDescriptorPool(m_dev, m_descriptorPool, nullptr);
++
++ delete texture();
++ freeTexture();
++ }
++
++ QSGTexture *CustomTextureNode::texture() const
++ {
++ return QSGSimpleTextureNode::texture();
++ }
++
++ static const float vertices[] = {
++ -1, -1,
++ 1, -1,
++ -1, 1,
++ 1, 1
++ };
++
++ const int UBUF_SIZE = 4;
++
++
++ bool CustomTextureNode::buildTexture(const QSize &size)
++ {
++ VkImageCreateInfo imageInfo;
++ memset(&imageInfo, 0, sizeof(imageInfo));
++ imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
++ imageInfo.flags = 0;
++ imageInfo.imageType = VK_IMAGE_TYPE_2D;
++ imageInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
++ imageInfo.extent.width = uint32_t(size.width());
++ imageInfo.extent.height = uint32_t(size.height());
++ imageInfo.extent.depth = 1;
++ imageInfo.mipLevels = 1;
++ imageInfo.arrayLayers = 1;
++ imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
++ imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
++ imageInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
++
++ imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
++ imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
++
++ VkImage image = VK_NULL_HANDLE;
++ if (m_devFuncs->vkCreateImage(m_dev, &imageInfo, nullptr, &image) != VK_SUCCESS) {
++ qCritical("VulkanWrapper: failed to create image!");
++ return false;
++ }
++
++ m_texture = image;
++
++ VkMemoryRequirements memReq;
++ m_devFuncs->vkGetImageMemoryRequirements(m_dev, image, &memReq);
++
++ quint32 memIndex = 0;
++ VkPhysicalDeviceMemoryProperties physDevMemProps;
++ m_window->vulkanInstance()->functions()->vkGetPhysicalDeviceMemoryProperties(m_physDev, &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
++ };
++
++ VkResult err = m_devFuncs->vkAllocateMemory(m_dev, &allocInfo, nullptr, &m_textureMemory);
++ if (err != VK_SUCCESS) {
++ qWarning("Failed to allocate memory for linear image: %d", err);
++ return false;
++ }
++
++ err = m_devFuncs->vkBindImageMemory(m_dev, image, m_textureMemory, 0);
++ if (err != VK_SUCCESS) {
++ qWarning("Failed to bind linear image memory: %d", err);
++ return false;
++ }
++
++ VkImageViewCreateInfo viewInfo;
++ memset(&viewInfo, 0, sizeof(viewInfo));
++ viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
++ viewInfo.image = image;
++ viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
++ viewInfo.format = imageInfo.format;
++ 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.baseMipLevel = 0;
++ viewInfo.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
++ viewInfo.subresourceRange.baseArrayLayer = 0;
++ viewInfo.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
++
++ err = m_devFuncs->vkCreateImageView(m_dev, &viewInfo, nullptr, &m_textureView);
++ if (err != VK_SUCCESS) {
++ qWarning("Failed to create render target image view: %d", err);
++ return false;
++ }
++
++ VkFramebufferCreateInfo fbInfo;
++ memset(&fbInfo, 0, sizeof(fbInfo));
++ fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
++ fbInfo.renderPass = m_renderPass;
++ fbInfo.attachmentCount = 1;
++ fbInfo.pAttachments = &m_textureView;
++ fbInfo.width = uint32_t(size.width());
++ fbInfo.height = uint32_t(size.height());
++ fbInfo.layers = 1;
++
++ err = m_devFuncs->vkCreateFramebuffer(m_dev, &fbInfo, nullptr, &m_textureFramebuffer);
++ if (err != VK_SUCCESS) {
++ qWarning("Failed to create framebuffer: %d", err);
++ return false;
++ }
++ return true;
++ }
++
++ void CustomTextureNode::freeTexture()
++ {
++ if (m_texture) {
++ m_devFuncs->vkDestroyFramebuffer(m_dev, m_textureFramebuffer, nullptr);
++ m_textureFramebuffer = VK_NULL_HANDLE;
++ m_devFuncs->vkFreeMemory(m_dev, m_textureMemory, nullptr);
++ m_textureMemory = VK_NULL_HANDLE;
++ m_devFuncs->vkDestroyImageView(m_dev, m_textureView, nullptr);
++ m_textureView = VK_NULL_HANDLE;
++ m_devFuncs->vkDestroyImage(m_dev, m_texture, nullptr);
++ m_texture = VK_NULL_HANDLE;
++ }
++ }
++
++
++
++ static inline VkDeviceSize aligned(VkDeviceSize v, VkDeviceSize byteAlign)
++ {
++ return (v + byteAlign - 1) & ~(byteAlign - 1);
++ }
++
++ bool CustomTextureNode::createRenderPass()
++ {
++ const VkFormat vkformat = VK_FORMAT_R8G8B8A8_UNORM;
++ const VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
++ VkAttachmentDescription colorAttDesc;
++ memset(&colorAttDesc, 0, sizeof(colorAttDesc));
++ colorAttDesc.format = vkformat;
++ colorAttDesc.samples = samples;
++ colorAttDesc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
++ colorAttDesc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
++ colorAttDesc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
++ colorAttDesc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
++ colorAttDesc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
++ colorAttDesc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
++
++ const VkAttachmentReference colorRef = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
++
++ VkSubpassDescription subpassDesc;
++ memset(&subpassDesc, 0, sizeof(subpassDesc));
++ subpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
++ subpassDesc.colorAttachmentCount = 1;
++ subpassDesc.pColorAttachments = &colorRef;
++ subpassDesc.pDepthStencilAttachment = nullptr;
++ subpassDesc.pResolveAttachments = nullptr;
++
++ VkRenderPassCreateInfo rpInfo;
++ memset(&rpInfo, 0, sizeof(rpInfo));
++ rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
++ rpInfo.attachmentCount = 1;
++ rpInfo.pAttachments = &colorAttDesc;
++ rpInfo.subpassCount = 1;
++ rpInfo.pSubpasses = &subpassDesc;
++
++ VkResult err = m_devFuncs->vkCreateRenderPass(m_dev, &rpInfo, nullptr, &m_renderPass);
++ if (err != VK_SUCCESS) {
++ qWarning("Failed to create renderpass: %d", err);
++ return false;
++ }
++
++ return true;
++ }
++
++ bool CustomTextureNode::initialize()
++ {
++ const int framesInFlight = m_window->graphicsStateInfo().framesInFlight;
++ m_initialized = true;
++
++ QSGRendererInterface *rif = m_window->rendererInterface();
++ QVulkanInstance *inst = reinterpret_cast<QVulkanInstance *>(
++ rif->getResource(m_window, QSGRendererInterface::VulkanInstanceResource));
++ Q_ASSERT(inst && inst->isValid());
++
++ m_physDev = *static_cast<VkPhysicalDevice *>(rif->getResource(m_window, QSGRendererInterface::PhysicalDeviceResource));
++ m_dev = *static_cast<VkDevice *>(rif->getResource(m_window, QSGRendererInterface::DeviceResource));
++ Q_ASSERT(m_physDev && m_dev);
++
++ m_devFuncs = inst->deviceFunctions(m_dev);
++ m_funcs = inst->functions();
++ Q_ASSERT(m_devFuncs && m_funcs);
++
++ createRenderPass();
++
++ VkPhysicalDeviceProperties physDevProps;
++ m_funcs->vkGetPhysicalDeviceProperties(m_physDev, &physDevProps);
++
++ VkPhysicalDeviceMemoryProperties physDevMemProps;
++ m_funcs->vkGetPhysicalDeviceMemoryProperties(m_physDev, &physDevMemProps);
++
++ VkBufferCreateInfo bufferInfo;
++ memset(&bufferInfo, 0, sizeof(bufferInfo));
++ bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
++ bufferInfo.size = sizeof(vertices);
++ bufferInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
++ VkResult err = m_devFuncs->vkCreateBuffer(m_dev, &bufferInfo, nullptr, &m_vbuf);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create vertex buffer: %d", err);
++
++ VkMemoryRequirements memReq;
++ m_devFuncs->vkGetBufferMemoryRequirements(m_dev, m_vbuf, &memReq);
++ VkMemoryAllocateInfo allocInfo;
++ memset(&allocInfo, 0, sizeof(allocInfo));
++ allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
++ allocInfo.allocationSize = memReq.size;
++
++ uint32_t memTypeIndex = uint32_t(-1);
++ const VkMemoryType *memType = physDevMemProps.memoryTypes;
++ for (uint32_t i = 0; i < physDevMemProps.memoryTypeCount; ++i) {
++ if (memReq.memoryTypeBits & (1 << i)) {
++ if ((memType[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
++ && (memType[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
++ {
++ memTypeIndex = i;
++ break;
++ }
++ }
++ }
++ if (memTypeIndex == uint32_t(-1))
++ qFatal("Failed to find host visible and coherent memory type");
++
++ allocInfo.memoryTypeIndex = memTypeIndex;
++ err = m_devFuncs->vkAllocateMemory(m_dev, &allocInfo, nullptr, &m_vbufMem);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to allocate vertex buffer memory of size %u: %d", uint(allocInfo.allocationSize), err);
++
++ void *p = nullptr;
++ err = m_devFuncs->vkMapMemory(m_dev, m_vbufMem, 0, allocInfo.allocationSize, 0, &p);
++ if (err != VK_SUCCESS || !p)
++ qFatal("Failed to map vertex buffer memory: %d", err);
++ memcpy(p, vertices, sizeof(vertices));
++ m_devFuncs->vkUnmapMemory(m_dev, m_vbufMem);
++ err = m_devFuncs->vkBindBufferMemory(m_dev, m_vbuf, m_vbufMem, 0);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to bind vertex buffer memory: %d", err);
++
++ m_allocPerUbuf = aligned(UBUF_SIZE, physDevProps.limits.minUniformBufferOffsetAlignment);
++
++ bufferInfo.size = framesInFlight * m_allocPerUbuf;
++ bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
++ err = m_devFuncs->vkCreateBuffer(m_dev, &bufferInfo, nullptr, &m_ubuf);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create uniform buffer: %d", err);
++ m_devFuncs->vkGetBufferMemoryRequirements(m_dev, m_ubuf, &memReq);
++ memTypeIndex = -1;
++ for (uint32_t i = 0; i < physDevMemProps.memoryTypeCount; ++i) {
++ if (memReq.memoryTypeBits & (1 << i)) {
++ if ((memType[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
++ && (memType[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
++ {
++ memTypeIndex = i;
++ break;
++ }
++ }
++ }
++ if (memTypeIndex == uint32_t(-1))
++ qFatal("Failed to find host visible and coherent memory type");
++
++ allocInfo.allocationSize = qMax(memReq.size, framesInFlight * m_allocPerUbuf);
++ allocInfo.memoryTypeIndex = memTypeIndex;
++ err = m_devFuncs->vkAllocateMemory(m_dev, &allocInfo, nullptr, &m_ubufMem);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to allocate uniform buffer memory of size %u: %d", uint(allocInfo.allocationSize), err);
++
++ err = m_devFuncs->vkBindBufferMemory(m_dev, m_ubuf, m_ubufMem, 0);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to bind uniform buffer memory: %d", err);
++
++ // Now onto the pipeline.
++
++ VkPipelineCacheCreateInfo pipelineCacheInfo;
++ memset(&pipelineCacheInfo, 0, sizeof(pipelineCacheInfo));
++ pipelineCacheInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
++ err = m_devFuncs->vkCreatePipelineCache(m_dev, &pipelineCacheInfo, nullptr, &m_pipelineCache);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create pipeline cache: %d", err);
++
++ VkDescriptorSetLayoutBinding descLayoutBinding;
++ memset(&descLayoutBinding, 0, sizeof(descLayoutBinding));
++ descLayoutBinding.binding = 0;
++ descLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
++ descLayoutBinding.descriptorCount = 1;
++ descLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
++ VkDescriptorSetLayoutCreateInfo layoutInfo;
++ memset(&layoutInfo, 0, sizeof(layoutInfo));
++ layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
++ layoutInfo.bindingCount = 1;
++ layoutInfo.pBindings = &descLayoutBinding;
++ err = m_devFuncs->vkCreateDescriptorSetLayout(m_dev, &layoutInfo, nullptr, &m_resLayout);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create descriptor set layout: %d", err);
++
++ VkPipelineLayoutCreateInfo pipelineLayoutInfo;
++ memset(&pipelineLayoutInfo, 0, sizeof(pipelineLayoutInfo));
++ pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
++ pipelineLayoutInfo.setLayoutCount = 1;
++ pipelineLayoutInfo.pSetLayouts = &m_resLayout;
++ err = m_devFuncs->vkCreatePipelineLayout(m_dev, &pipelineLayoutInfo, nullptr, &m_pipelineLayout);
++ if (err != VK_SUCCESS)
++ qWarning("Failed to create pipeline layout: %d", err);
++
++ VkGraphicsPipelineCreateInfo pipelineInfo;
++ memset(&pipelineInfo, 0, sizeof(pipelineInfo));
++ pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
++
++ VkShaderModuleCreateInfo shaderInfo;
++ memset(&shaderInfo, 0, sizeof(shaderInfo));
++ shaderInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
++ shaderInfo.codeSize = m_vert.size();
++ shaderInfo.pCode = reinterpret_cast<const quint32 *>(m_vert.constData());
++ VkShaderModule vertShaderModule;
++ err = m_devFuncs->vkCreateShaderModule(m_dev, &shaderInfo, nullptr, &vertShaderModule);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create vertex shader module: %d", err);
++
++ shaderInfo.codeSize = m_frag.size();
++ shaderInfo.pCode = reinterpret_cast<const quint32 *>(m_frag.constData());
++ VkShaderModule fragShaderModule;
++ err = m_devFuncs->vkCreateShaderModule(m_dev, &shaderInfo, nullptr, &fragShaderModule);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create fragment shader module: %d", err);
++
++ VkPipelineShaderStageCreateInfo stageInfo[2];
++ memset(&stageInfo, 0, sizeof(stageInfo));
++ stageInfo[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
++ stageInfo[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
++ stageInfo[0].module = vertShaderModule;
++ stageInfo[0].pName = "main";
++ stageInfo[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
++ stageInfo[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
++ stageInfo[1].module = fragShaderModule;
++ stageInfo[1].pName = "main";
++ pipelineInfo.stageCount = 2;
++ pipelineInfo.pStages = stageInfo;
++
++ VkVertexInputBindingDescription vertexBinding = {
++ 0, // binding
++ 2 * sizeof(float), // stride
++ VK_VERTEX_INPUT_RATE_VERTEX
++ };
++ VkVertexInputAttributeDescription vertexAttr = {
++ 0, // location
++ 0, // binding
++ VK_FORMAT_R32G32_SFLOAT, // 'vertices' only has 2 floats per vertex
++ 0 // offset
++ };
++ VkPipelineVertexInputStateCreateInfo vertexInputInfo;
++ memset(&vertexInputInfo, 0, sizeof(vertexInputInfo));
++ vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
++ vertexInputInfo.vertexBindingDescriptionCount = 1;
++ vertexInputInfo.pVertexBindingDescriptions = &vertexBinding;
++ vertexInputInfo.vertexAttributeDescriptionCount = 1;
++ vertexInputInfo.pVertexAttributeDescriptions = &vertexAttr;
++ pipelineInfo.pVertexInputState = &vertexInputInfo;
++
++ VkDynamicState dynStates[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
++ VkPipelineDynamicStateCreateInfo dynamicInfo;
++ memset(&dynamicInfo, 0, sizeof(dynamicInfo));
++ dynamicInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
++ dynamicInfo.dynamicStateCount = 2;
++ dynamicInfo.pDynamicStates = dynStates;
++ pipelineInfo.pDynamicState = &dynamicInfo;
++
++ VkPipelineViewportStateCreateInfo viewportInfo;
++ memset(&viewportInfo, 0, sizeof(viewportInfo));
++ viewportInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
++ viewportInfo.viewportCount = viewportInfo.scissorCount = 1;
++ pipelineInfo.pViewportState = &viewportInfo;
++
++ VkPipelineInputAssemblyStateCreateInfo iaInfo;
++ memset(&iaInfo, 0, sizeof(iaInfo));
++ iaInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
++ iaInfo.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
++ pipelineInfo.pInputAssemblyState = &iaInfo;
++
++ VkPipelineRasterizationStateCreateInfo rsInfo;
++ memset(&rsInfo, 0, sizeof(rsInfo));
++ rsInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
++ rsInfo.lineWidth = 1.0f;
++ pipelineInfo.pRasterizationState = &rsInfo;
++
++ VkPipelineMultisampleStateCreateInfo msInfo;
++ memset(&msInfo, 0, sizeof(msInfo));
++ msInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
++ msInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
++ pipelineInfo.pMultisampleState = &msInfo;
++
++ VkPipelineDepthStencilStateCreateInfo dsInfo;
++ memset(&dsInfo, 0, sizeof(dsInfo));
++ dsInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
++ pipelineInfo.pDepthStencilState = &dsInfo;
++
++ // SrcAlpha, One
++ VkPipelineColorBlendStateCreateInfo blendInfo;
++ memset(&blendInfo, 0, sizeof(blendInfo));
++ blendInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
++ VkPipelineColorBlendAttachmentState blend;
++ memset(&blend, 0, sizeof(blend));
++ blend.blendEnable = true;
++ blend.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
++ blend.dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
++ blend.colorBlendOp = VK_BLEND_OP_ADD;
++ blend.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
++ blend.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
++ blend.alphaBlendOp = VK_BLEND_OP_ADD;
++ blend.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT
++ | VK_COLOR_COMPONENT_A_BIT;
++ blendInfo.attachmentCount = 1;
++ blendInfo.pAttachments = &blend;
++ pipelineInfo.pColorBlendState = &blendInfo;
++
++ pipelineInfo.layout = m_pipelineLayout;
++
++ pipelineInfo.renderPass = m_renderPass;
++
++ err = m_devFuncs->vkCreateGraphicsPipelines(m_dev, m_pipelineCache, 1, &pipelineInfo, nullptr, &m_pipeline);
++
++ m_devFuncs->vkDestroyShaderModule(m_dev, vertShaderModule, nullptr);
++ m_devFuncs->vkDestroyShaderModule(m_dev, fragShaderModule, nullptr);
++
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create graphics pipeline: %d", err);
++
++ // Now just need some descriptors.
++ VkDescriptorPoolSize descPoolSizes[] = {
++ { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1 }
++ };
++ VkDescriptorPoolCreateInfo descPoolInfo;
++ memset(&descPoolInfo, 0, sizeof(descPoolInfo));
++ descPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
++ descPoolInfo.flags = 0; // won't use vkFreeDescriptorSets
++ descPoolInfo.maxSets = 1;
++ descPoolInfo.poolSizeCount = sizeof(descPoolSizes) / sizeof(descPoolSizes[0]);
++ descPoolInfo.pPoolSizes = descPoolSizes;
++ err = m_devFuncs->vkCreateDescriptorPool(m_dev, &descPoolInfo, nullptr, &m_descriptorPool);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to create descriptor pool: %d", err);
++
++ VkDescriptorSetAllocateInfo descAllocInfo;
++ memset(&descAllocInfo, 0, sizeof(descAllocInfo));
++ descAllocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
++ descAllocInfo.descriptorPool = m_descriptorPool;
++ descAllocInfo.descriptorSetCount = 1;
++ descAllocInfo.pSetLayouts = &m_resLayout;
++ err = m_devFuncs->vkAllocateDescriptorSets(m_dev, &descAllocInfo, &m_ubufDescriptor);
++ if (err != VK_SUCCESS)
++ qFatal("Failed to allocate descriptor set");
++
++ VkWriteDescriptorSet writeInfo;
++ memset(&writeInfo, 0, sizeof(writeInfo));
++ writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
++ writeInfo.dstSet = m_ubufDescriptor;
++ writeInfo.dstBinding = 0;
++ writeInfo.descriptorCount = 1;
++ writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
++ VkDescriptorBufferInfo bufInfo;
++ bufInfo.buffer = m_ubuf;
++ bufInfo.offset = 0; // dynamic offset is used so this is ignored
++ bufInfo.range = UBUF_SIZE;
++ writeInfo.pBufferInfo = &bufInfo;
++
++ m_devFuncs->vkUpdateDescriptorSets(m_dev, 1, &writeInfo, 0, nullptr);
++ return true;
++ }
++
++ void CustomTextureNode::sync()
++ {
++ m_dpr = m_window->effectiveDevicePixelRatio();
++ const QSize newSize = m_window->size() * m_dpr;
++ bool needsNew = false;
++
++ if (!m_initialized) {
++ prepareShader(VertexStage);
++ prepareShader(FragmentStage);
++ initialize();
++ m_initialized = true;
++ }
++
++ if (!texture())
++ needsNew = true;
++
++ if (newSize != m_size) {
++ needsNew = true;
++ m_size = newSize;
++ }
++
++ if (needsNew) {
++ delete texture();
++ freeTexture();
++ buildTexture(m_size);
++ QSGTexture *wrapper = QNativeInterface::QSGVulkanTexture::fromNative(m_texture,
++ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
++ m_window,
++ m_size);
++ setTexture(wrapper);
++ Q_ASSERT(wrapper->nativeInterface<QNativeInterface::QSGVulkanTexture>()->nativeImage() == m_texture);
++ }
++
++ m_t = float(static_cast<CustomTextureItem *>(m_item)->t());
++ }
++
++ void CustomTextureNode::render()
++ {
++ if (!m_initialized)
++ return;
++
++ VkResult err = VK_SUCCESS;
++
++ uint currentFrameSlot = m_window->graphicsStateInfo().currentFrameSlot;
++ VkDeviceSize ubufOffset = currentFrameSlot * m_allocPerUbuf;
++ void *p = nullptr;
++ err = m_devFuncs->vkMapMemory(m_dev, m_ubufMem, ubufOffset, m_allocPerUbuf, 0, &p);
++ if (err != VK_SUCCESS || !p)
++ qFatal("Failed to map uniform buffer memory: %d", err);
++ float t = m_t;
++ memcpy(p, &t, 4);
++ m_devFuncs->vkUnmapMemory(m_dev, m_ubufMem);
++
++ VkClearValue clearColor = {{ {0, 0, 0, 1} }};
++
++ VkRenderPassBeginInfo rpBeginInfo = {};
++ rpBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
++ rpBeginInfo.renderPass = m_renderPass;
++ rpBeginInfo.framebuffer = m_textureFramebuffer;
++ rpBeginInfo.renderArea.extent.width = m_size.width();
++ rpBeginInfo.renderArea.extent.height = m_size.height();
++ rpBeginInfo.clearValueCount = 1;
++ rpBeginInfo.pClearValues = &clearColor;
++
++ QSGRendererInterface *rif = m_window->rendererInterface();
++ VkCommandBuffer cmdBuf = *reinterpret_cast<VkCommandBuffer *>(
++ rif->getResource(m_window, QSGRendererInterface::CommandListResource));
++
++ m_devFuncs->vkCmdBeginRenderPass(cmdBuf, &rpBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
++
++ m_devFuncs->vkCmdBindPipeline(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline);
++
++ VkDeviceSize vbufOffset = 0;
++ m_devFuncs->vkCmdBindVertexBuffers(cmdBuf, 0, 1, &m_vbuf, &vbufOffset);
++
++ uint32_t dynamicOffset = m_allocPerUbuf * currentFrameSlot;
++ m_devFuncs->vkCmdBindDescriptorSets(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipelineLayout, 0, 1,
++ &m_ubufDescriptor, 1, &dynamicOffset);
++
++ VkViewport vp = { 0, 0, float(m_size.width()), float(m_size.height()), 0.0f, 1.0f };
++ m_devFuncs->vkCmdSetViewport(cmdBuf, 0, 1, &vp);
++ VkRect2D scissor = { { 0, 0 }, { uint32_t(m_size.width()), uint32_t(m_size.height()) } };
++ m_devFuncs->vkCmdSetScissor(cmdBuf, 0, 1, &scissor);
++
++ m_devFuncs->vkCmdDraw(cmdBuf, 4, 1, 0, 0);
++ m_devFuncs->vkCmdEndRenderPass(cmdBuf);
++
++ // Memory barrier before the texture can be used as a source.
++ // Since we are not using a sub-pass, we have to do this explicitly.
++
++ VkImageMemoryBarrier imageTransitionBarrier = {};
++ imageTransitionBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
++ imageTransitionBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
++ imageTransitionBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
++ imageTransitionBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
++ imageTransitionBarrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
++ imageTransitionBarrier.image = m_texture;
++ imageTransitionBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
++ imageTransitionBarrier.subresourceRange.levelCount = imageTransitionBarrier.subresourceRange.layerCount = 1;
++
++ m_devFuncs->vkCmdPipelineBarrier(cmdBuf,
++ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
++ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
++ 0, 0, nullptr, 0, nullptr,
++ 1, &imageTransitionBarrier);
++ }
++
++ void CustomTextureNode::prepareShader(Stage stage)
++ {
++ QString filename;
++ if (stage == VertexStage) {
++ filename = QLatin1String(":/scenegraph/vulkantextureimport/squircle.vert.spv");
++ } else {
++ Q_ASSERT(stage == FragmentStage);
++ filename = QLatin1String(":/scenegraph/vulkantextureimport/squircle.frag.spv");
++ }
++ QFile f(filename);
++ if (!f.open(QIODevice::ReadOnly))
++ qFatal("Failed to read shader %s", qPrintable(filename));
++
++ const QByteArray contents = f.readAll();
++
++ if (stage == VertexStage) {
++ m_vert = contents;
++ Q_ASSERT(!m_vert.isEmpty());
++ } else {
++ m_frag = contents;
++ Q_ASSERT(!m_frag.isEmpty());
++ }
++ }
++
++ #include "vulkantextureimport.moc"