2017-03-24 13:54:24 +00:00
|
|
|
/****************************************************************************
|
|
|
|
**
|
|
|
|
** 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 "renderer.h"
|
2019-03-27 18:59:47 +00:00
|
|
|
#include "qrandom.h"
|
2017-03-24 13:54:24 +00:00
|
|
|
#include <QVulkanFunctions>
|
|
|
|
#include <QtConcurrentRun>
|
|
|
|
#include <QTime>
|
|
|
|
|
2018-09-01 17:51:43 +00:00
|
|
|
static float quadVert[] = { // Y up, front = CW
|
2017-03-24 13:54:24 +00:00
|
|
|
-1, -1, 0,
|
|
|
|
-1, 1, 0,
|
|
|
|
1, -1, 0,
|
|
|
|
1, 1, 0
|
|
|
|
};
|
|
|
|
|
|
|
|
#define DBG Q_UNLIKELY(m_window->isDebugEnabled())
|
|
|
|
|
|
|
|
const int MAX_INSTANCES = 16384;
|
|
|
|
const VkDeviceSize PER_INSTANCE_DATA_SIZE = 6 * sizeof(float); // instTranslate, instDiffuseAdjust
|
|
|
|
|
|
|
|
static inline VkDeviceSize aligned(VkDeviceSize v, VkDeviceSize byteAlign)
|
|
|
|
{
|
|
|
|
return (v + byteAlign - 1) & ~(byteAlign - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
Renderer::Renderer(VulkanWindow *w, int initialCount)
|
|
|
|
: m_window(w),
|
|
|
|
// Have the light positioned just behind the default camera position, looking forward.
|
|
|
|
m_lightPos(0.0f, 0.0f, 25.0f),
|
|
|
|
m_cam(QVector3D(0.0f, 0.0f, 20.0f)), // starting camera position
|
|
|
|
m_instCount(initialCount)
|
|
|
|
{
|
|
|
|
m_floorModel.translate(0, -5, 0);
|
|
|
|
m_floorModel.rotate(-90, 1, 0, 0);
|
|
|
|
m_floorModel.scale(20, 100, 1);
|
|
|
|
|
|
|
|
m_blockMesh.load(QStringLiteral(":/block.buf"));
|
|
|
|
m_logoMesh.load(QStringLiteral(":/qt_logo.buf"));
|
|
|
|
|
|
|
|
QObject::connect(&m_frameWatcher, &QFutureWatcherBase::finished, [this] {
|
|
|
|
if (m_framePending) {
|
|
|
|
m_framePending = false;
|
|
|
|
m_window->frameReady();
|
|
|
|
m_window->requestUpdate();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::preInitResources()
|
|
|
|
{
|
2017-05-22 08:23:16 +00:00
|
|
|
const QVector<int> sampleCounts = m_window->supportedSampleCounts();
|
2017-03-24 13:54:24 +00:00
|
|
|
if (DBG)
|
|
|
|
qDebug() << "Supported sample counts:" << sampleCounts;
|
|
|
|
if (sampleCounts.contains(4)) {
|
|
|
|
if (DBG)
|
|
|
|
qDebug("Requesting 4x MSAA");
|
|
|
|
m_window->setSampleCount(4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::initResources()
|
|
|
|
{
|
|
|
|
if (DBG)
|
|
|
|
qDebug("Renderer init");
|
|
|
|
|
|
|
|
m_animating = true;
|
|
|
|
m_framePending = false;
|
|
|
|
|
|
|
|
QVulkanInstance *inst = m_window->vulkanInstance();
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
const VkPhysicalDeviceLimits *pdevLimits = &m_window->physicalDeviceProperties()->limits;
|
|
|
|
const VkDeviceSize uniAlign = pdevLimits->minUniformBufferOffsetAlignment;
|
|
|
|
|
|
|
|
m_devFuncs = inst->deviceFunctions(dev);
|
|
|
|
|
|
|
|
// Note the std140 packing rules. A vec3 still has an alignment of 16,
|
|
|
|
// while a mat3 is like 3 * vec3.
|
|
|
|
m_itemMaterial.vertUniSize = aligned(2 * 64 + 48, uniAlign); // see color_phong.vert
|
|
|
|
m_itemMaterial.fragUniSize = aligned(6 * 16 + 12 + 2 * 4, uniAlign); // see color_phong.frag
|
|
|
|
|
|
|
|
if (!m_itemMaterial.vs.isValid())
|
|
|
|
m_itemMaterial.vs.load(inst, dev, QStringLiteral(":/color_phong_vert.spv"));
|
|
|
|
if (!m_itemMaterial.fs.isValid())
|
|
|
|
m_itemMaterial.fs.load(inst, dev, QStringLiteral(":/color_phong_frag.spv"));
|
|
|
|
|
|
|
|
if (!m_floorMaterial.vs.isValid())
|
|
|
|
m_floorMaterial.vs.load(inst, dev, QStringLiteral(":/color_vert.spv"));
|
|
|
|
if (!m_floorMaterial.fs.isValid())
|
|
|
|
m_floorMaterial.fs.load(inst, dev, QStringLiteral(":/color_frag.spv"));
|
|
|
|
|
|
|
|
m_pipelinesFuture = QtConcurrent::run(this, &Renderer::createPipelines);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::createPipelines()
|
|
|
|
{
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
|
|
|
|
VkPipelineCacheCreateInfo pipelineCacheInfo;
|
|
|
|
memset(&pipelineCacheInfo, 0, sizeof(pipelineCacheInfo));
|
|
|
|
pipelineCacheInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
|
|
|
|
VkResult err = m_devFuncs->vkCreatePipelineCache(dev, &pipelineCacheInfo, nullptr, &m_pipelineCache);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create pipeline cache: %d", err);
|
|
|
|
|
|
|
|
createItemPipeline();
|
|
|
|
createFloorPipeline();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::createItemPipeline()
|
|
|
|
{
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
|
|
|
|
// Vertex layout.
|
|
|
|
VkVertexInputBindingDescription vertexBindingDesc[] = {
|
|
|
|
{
|
|
|
|
0, // binding
|
|
|
|
8 * sizeof(float),
|
|
|
|
VK_VERTEX_INPUT_RATE_VERTEX
|
|
|
|
},
|
|
|
|
{
|
|
|
|
1,
|
|
|
|
6 * sizeof(float),
|
|
|
|
VK_VERTEX_INPUT_RATE_INSTANCE
|
|
|
|
}
|
|
|
|
};
|
|
|
|
VkVertexInputAttributeDescription vertexAttrDesc[] = {
|
|
|
|
{ // position
|
|
|
|
0, // location
|
|
|
|
0, // binding
|
|
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
|
|
|
0 // offset
|
|
|
|
},
|
|
|
|
{ // normal
|
|
|
|
1,
|
|
|
|
0,
|
|
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
|
|
|
5 * sizeof(float)
|
|
|
|
},
|
|
|
|
{ // instTranslate
|
|
|
|
2,
|
|
|
|
1,
|
|
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
|
|
|
0
|
|
|
|
},
|
|
|
|
{ // instDiffuseAdjust
|
|
|
|
3,
|
|
|
|
1,
|
|
|
|
VK_FORMAT_R32G32B32_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 = sizeof(vertexBindingDesc) / sizeof(vertexBindingDesc[0]);
|
|
|
|
vertexInputInfo.pVertexBindingDescriptions = vertexBindingDesc;
|
|
|
|
vertexInputInfo.vertexAttributeDescriptionCount = sizeof(vertexAttrDesc) / sizeof(vertexAttrDesc[0]);
|
|
|
|
vertexInputInfo.pVertexAttributeDescriptions = vertexAttrDesc;
|
|
|
|
|
|
|
|
// Descriptor set layout.
|
|
|
|
VkDescriptorPoolSize descPoolSizes[] = {
|
|
|
|
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 2 }
|
|
|
|
};
|
|
|
|
VkDescriptorPoolCreateInfo descPoolInfo;
|
|
|
|
memset(&descPoolInfo, 0, sizeof(descPoolInfo));
|
|
|
|
descPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
|
|
|
descPoolInfo.maxSets = 1; // a single set is enough due to the dynamic uniform buffer
|
|
|
|
descPoolInfo.poolSizeCount = sizeof(descPoolSizes) / sizeof(descPoolSizes[0]);
|
|
|
|
descPoolInfo.pPoolSizes = descPoolSizes;
|
|
|
|
VkResult err = m_devFuncs->vkCreateDescriptorPool(dev, &descPoolInfo, nullptr, &m_itemMaterial.descPool);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create descriptor pool: %d", err);
|
|
|
|
|
|
|
|
VkDescriptorSetLayoutBinding layoutBindings[] =
|
|
|
|
{
|
|
|
|
{
|
|
|
|
0, // binding
|
|
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
|
|
|
|
1, // descriptorCount
|
|
|
|
VK_SHADER_STAGE_VERTEX_BIT,
|
|
|
|
nullptr
|
|
|
|
},
|
|
|
|
{
|
|
|
|
1,
|
|
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
|
|
|
|
1,
|
|
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
|
|
nullptr
|
|
|
|
}
|
|
|
|
};
|
|
|
|
VkDescriptorSetLayoutCreateInfo descLayoutInfo = {
|
|
|
|
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
|
|
|
|
nullptr,
|
|
|
|
0,
|
|
|
|
sizeof(layoutBindings) / sizeof(layoutBindings[0]),
|
|
|
|
layoutBindings
|
|
|
|
};
|
|
|
|
err = m_devFuncs->vkCreateDescriptorSetLayout(dev, &descLayoutInfo, nullptr, &m_itemMaterial.descSetLayout);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create descriptor set layout: %d", err);
|
|
|
|
|
|
|
|
VkDescriptorSetAllocateInfo descSetAllocInfo = {
|
|
|
|
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
|
|
|
|
nullptr,
|
|
|
|
m_itemMaterial.descPool,
|
|
|
|
1,
|
|
|
|
&m_itemMaterial.descSetLayout
|
|
|
|
};
|
|
|
|
err = m_devFuncs->vkAllocateDescriptorSets(dev, &descSetAllocInfo, &m_itemMaterial.descSet);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to allocate descriptor set: %d", err);
|
|
|
|
|
|
|
|
// Graphics pipeline.
|
|
|
|
VkPipelineLayoutCreateInfo pipelineLayoutInfo;
|
|
|
|
memset(&pipelineLayoutInfo, 0, sizeof(pipelineLayoutInfo));
|
|
|
|
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
|
|
pipelineLayoutInfo.setLayoutCount = 1;
|
|
|
|
pipelineLayoutInfo.pSetLayouts = &m_itemMaterial.descSetLayout;
|
|
|
|
|
|
|
|
err = m_devFuncs->vkCreatePipelineLayout(dev, &pipelineLayoutInfo, nullptr, &m_itemMaterial.pipelineLayout);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create pipeline layout: %d", err);
|
|
|
|
|
|
|
|
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,
|
|
|
|
m_itemMaterial.vs.data()->shaderModule,
|
|
|
|
"main",
|
|
|
|
nullptr
|
|
|
|
},
|
|
|
|
{
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
|
|
|
|
nullptr,
|
|
|
|
0,
|
|
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
|
|
m_itemMaterial.fs.data()->shaderModule,
|
|
|
|
"main",
|
|
|
|
nullptr
|
|
|
|
}
|
|
|
|
};
|
|
|
|
pipelineInfo.stageCount = 2;
|
|
|
|
pipelineInfo.pStages = shaderStages;
|
|
|
|
|
|
|
|
pipelineInfo.pVertexInputState = &vertexInputInfo;
|
|
|
|
|
|
|
|
VkPipelineInputAssemblyStateCreateInfo ia;
|
|
|
|
memset(&ia, 0, sizeof(ia));
|
|
|
|
ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
|
|
|
|
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
|
|
pipelineInfo.pInputAssemblyState = &ia;
|
|
|
|
|
|
|
|
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_COUNTER_CLOCKWISE;
|
|
|
|
rs.lineWidth = 1.0f;
|
|
|
|
pipelineInfo.pRasterizationState = &rs;
|
|
|
|
|
|
|
|
VkPipelineMultisampleStateCreateInfo ms;
|
|
|
|
memset(&ms, 0, sizeof(ms));
|
|
|
|
ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
|
|
|
|
ms.rasterizationSamples = m_window->sampleCountFlagBits();
|
|
|
|
pipelineInfo.pMultisampleState = &ms;
|
|
|
|
|
|
|
|
VkPipelineDepthStencilStateCreateInfo ds;
|
|
|
|
memset(&ds, 0, sizeof(ds));
|
|
|
|
ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
|
|
|
|
ds.depthTestEnable = VK_TRUE;
|
|
|
|
ds.depthWriteEnable = VK_TRUE;
|
|
|
|
ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
|
|
|
|
pipelineInfo.pDepthStencilState = &ds;
|
|
|
|
|
|
|
|
VkPipelineColorBlendStateCreateInfo cb;
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
|
|
|
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
|
|
|
VkPipelineColorBlendAttachmentState att;
|
|
|
|
memset(&att, 0, sizeof(att));
|
|
|
|
att.colorWriteMask = 0xF;
|
|
|
|
cb.attachmentCount = 1;
|
|
|
|
cb.pAttachments = &att;
|
|
|
|
pipelineInfo.pColorBlendState = &cb;
|
|
|
|
|
|
|
|
VkDynamicState dynEnable[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
|
|
|
|
VkPipelineDynamicStateCreateInfo dyn;
|
|
|
|
memset(&dyn, 0, sizeof(dyn));
|
|
|
|
dyn.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
|
|
|
dyn.dynamicStateCount = sizeof(dynEnable) / sizeof(VkDynamicState);
|
|
|
|
dyn.pDynamicStates = dynEnable;
|
|
|
|
pipelineInfo.pDynamicState = &dyn;
|
|
|
|
|
|
|
|
pipelineInfo.layout = m_itemMaterial.pipelineLayout;
|
|
|
|
pipelineInfo.renderPass = m_window->defaultRenderPass();
|
|
|
|
|
|
|
|
err = m_devFuncs->vkCreateGraphicsPipelines(dev, m_pipelineCache, 1, &pipelineInfo, nullptr, &m_itemMaterial.pipeline);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create graphics pipeline: %d", err);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::createFloorPipeline()
|
|
|
|
{
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
|
|
|
|
// Vertex layout.
|
|
|
|
VkVertexInputBindingDescription vertexBindingDesc = {
|
|
|
|
0, // binding
|
|
|
|
3 * sizeof(float),
|
|
|
|
VK_VERTEX_INPUT_RATE_VERTEX
|
|
|
|
};
|
|
|
|
VkVertexInputAttributeDescription vertexAttrDesc[] = {
|
|
|
|
{ // position
|
|
|
|
0, // location
|
|
|
|
0, // binding
|
|
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
|
|
|
0 // offset
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
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 = sizeof(vertexAttrDesc) / sizeof(vertexAttrDesc[0]);
|
|
|
|
vertexInputInfo.pVertexAttributeDescriptions = vertexAttrDesc;
|
|
|
|
|
|
|
|
// Do not bother with uniform buffers and descriptors, all the data fits
|
|
|
|
// into the spec mandated minimum of 128 bytes for push constants.
|
|
|
|
VkPushConstantRange pcr[] = {
|
|
|
|
// mvp
|
|
|
|
{
|
|
|
|
VK_SHADER_STAGE_VERTEX_BIT,
|
|
|
|
0,
|
|
|
|
64
|
|
|
|
},
|
|
|
|
// color
|
|
|
|
{
|
|
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
|
|
64,
|
|
|
|
12
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
VkPipelineLayoutCreateInfo pipelineLayoutInfo;
|
|
|
|
memset(&pipelineLayoutInfo, 0, sizeof(pipelineLayoutInfo));
|
|
|
|
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
|
|
pipelineLayoutInfo.pushConstantRangeCount = sizeof(pcr) / sizeof(pcr[0]);
|
|
|
|
pipelineLayoutInfo.pPushConstantRanges = pcr;
|
|
|
|
|
|
|
|
VkResult err = m_devFuncs->vkCreatePipelineLayout(dev, &pipelineLayoutInfo, nullptr, &m_floorMaterial.pipelineLayout);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create pipeline layout: %d", err);
|
|
|
|
|
|
|
|
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,
|
|
|
|
m_floorMaterial.vs.data()->shaderModule,
|
|
|
|
"main",
|
|
|
|
nullptr
|
|
|
|
},
|
|
|
|
{
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
|
|
|
|
nullptr,
|
|
|
|
0,
|
|
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
|
|
m_floorMaterial.fs.data()->shaderModule,
|
|
|
|
"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;
|
|
|
|
|
|
|
|
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 = m_window->sampleCountFlagBits();
|
|
|
|
pipelineInfo.pMultisampleState = &ms;
|
|
|
|
|
|
|
|
VkPipelineDepthStencilStateCreateInfo ds;
|
|
|
|
memset(&ds, 0, sizeof(ds));
|
|
|
|
ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
|
|
|
|
ds.depthTestEnable = VK_TRUE;
|
|
|
|
ds.depthWriteEnable = VK_TRUE;
|
|
|
|
ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
|
|
|
|
pipelineInfo.pDepthStencilState = &ds;
|
|
|
|
|
|
|
|
VkPipelineColorBlendStateCreateInfo cb;
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
|
|
|
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
|
|
|
|
VkPipelineColorBlendAttachmentState att;
|
|
|
|
memset(&att, 0, sizeof(att));
|
|
|
|
att.colorWriteMask = 0xF;
|
|
|
|
cb.attachmentCount = 1;
|
|
|
|
cb.pAttachments = &att;
|
|
|
|
pipelineInfo.pColorBlendState = &cb;
|
|
|
|
|
|
|
|
VkDynamicState dynEnable[] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
|
|
|
|
VkPipelineDynamicStateCreateInfo dyn;
|
|
|
|
memset(&dyn, 0, sizeof(dyn));
|
|
|
|
dyn.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
|
|
|
|
dyn.dynamicStateCount = sizeof(dynEnable) / sizeof(VkDynamicState);
|
|
|
|
dyn.pDynamicStates = dynEnable;
|
|
|
|
pipelineInfo.pDynamicState = &dyn;
|
|
|
|
|
|
|
|
pipelineInfo.layout = m_floorMaterial.pipelineLayout;
|
|
|
|
pipelineInfo.renderPass = m_window->defaultRenderPass();
|
|
|
|
|
|
|
|
err = m_devFuncs->vkCreateGraphicsPipelines(dev, m_pipelineCache, 1, &pipelineInfo, nullptr, &m_floorMaterial.pipeline);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create graphics pipeline: %d", err);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::initSwapChainResources()
|
|
|
|
{
|
2017-05-22 08:15:34 +00:00
|
|
|
m_proj = m_window->clipCorrectionMatrix();
|
2017-03-24 13:54:24 +00:00
|
|
|
const QSize sz = m_window->swapChainImageSize();
|
|
|
|
m_proj.perspective(45.0f, sz.width() / (float) sz.height(), 0.01f, 1000.0f);
|
|
|
|
markViewProjDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::releaseSwapChainResources()
|
|
|
|
{
|
|
|
|
// It is important to finish the pending frame right here since this is the
|
|
|
|
// last opportunity to act with all resources intact.
|
|
|
|
m_frameWatcher.waitForFinished();
|
|
|
|
// Cannot count on the finished() signal being emitted before returning
|
|
|
|
// from here.
|
|
|
|
if (m_framePending) {
|
|
|
|
m_framePending = false;
|
|
|
|
m_window->frameReady();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::releaseResources()
|
|
|
|
{
|
|
|
|
if (DBG)
|
|
|
|
qDebug("Renderer release");
|
|
|
|
|
|
|
|
m_pipelinesFuture.waitForFinished();
|
|
|
|
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
|
|
|
|
if (m_itemMaterial.descSetLayout) {
|
|
|
|
m_devFuncs->vkDestroyDescriptorSetLayout(dev, m_itemMaterial.descSetLayout, nullptr);
|
|
|
|
m_itemMaterial.descSetLayout = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_itemMaterial.descPool) {
|
|
|
|
m_devFuncs->vkDestroyDescriptorPool(dev, m_itemMaterial.descPool, nullptr);
|
|
|
|
m_itemMaterial.descPool = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_itemMaterial.pipeline) {
|
|
|
|
m_devFuncs->vkDestroyPipeline(dev, m_itemMaterial.pipeline, nullptr);
|
|
|
|
m_itemMaterial.pipeline = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_itemMaterial.pipelineLayout) {
|
|
|
|
m_devFuncs->vkDestroyPipelineLayout(dev, m_itemMaterial.pipelineLayout, nullptr);
|
|
|
|
m_itemMaterial.pipelineLayout = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_floorMaterial.pipeline) {
|
|
|
|
m_devFuncs->vkDestroyPipeline(dev, m_floorMaterial.pipeline, nullptr);
|
|
|
|
m_floorMaterial.pipeline = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_floorMaterial.pipelineLayout) {
|
|
|
|
m_devFuncs->vkDestroyPipelineLayout(dev, m_floorMaterial.pipelineLayout, nullptr);
|
|
|
|
m_floorMaterial.pipelineLayout = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_pipelineCache) {
|
|
|
|
m_devFuncs->vkDestroyPipelineCache(dev, m_pipelineCache, nullptr);
|
|
|
|
m_pipelineCache = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_blockVertexBuf) {
|
|
|
|
m_devFuncs->vkDestroyBuffer(dev, m_blockVertexBuf, nullptr);
|
|
|
|
m_blockVertexBuf = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_logoVertexBuf) {
|
|
|
|
m_devFuncs->vkDestroyBuffer(dev, m_logoVertexBuf, nullptr);
|
|
|
|
m_logoVertexBuf = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_floorVertexBuf) {
|
|
|
|
m_devFuncs->vkDestroyBuffer(dev, m_floorVertexBuf, nullptr);
|
|
|
|
m_floorVertexBuf = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_uniBuf) {
|
|
|
|
m_devFuncs->vkDestroyBuffer(dev, m_uniBuf, nullptr);
|
|
|
|
m_uniBuf = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_bufMem) {
|
|
|
|
m_devFuncs->vkFreeMemory(dev, m_bufMem, nullptr);
|
|
|
|
m_bufMem = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_instBuf) {
|
|
|
|
m_devFuncs->vkDestroyBuffer(dev, m_instBuf, nullptr);
|
|
|
|
m_instBuf = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_instBufMem) {
|
|
|
|
m_devFuncs->vkFreeMemory(dev, m_instBufMem, nullptr);
|
|
|
|
m_instBufMem = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_itemMaterial.vs.isValid()) {
|
|
|
|
m_devFuncs->vkDestroyShaderModule(dev, m_itemMaterial.vs.data()->shaderModule, nullptr);
|
|
|
|
m_itemMaterial.vs.reset();
|
|
|
|
}
|
|
|
|
if (m_itemMaterial.fs.isValid()) {
|
|
|
|
m_devFuncs->vkDestroyShaderModule(dev, m_itemMaterial.fs.data()->shaderModule, nullptr);
|
|
|
|
m_itemMaterial.fs.reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_floorMaterial.vs.isValid()) {
|
|
|
|
m_devFuncs->vkDestroyShaderModule(dev, m_floorMaterial.vs.data()->shaderModule, nullptr);
|
|
|
|
m_floorMaterial.vs.reset();
|
|
|
|
}
|
|
|
|
if (m_floorMaterial.fs.isValid()) {
|
|
|
|
m_devFuncs->vkDestroyShaderModule(dev, m_floorMaterial.fs.data()->shaderModule, nullptr);
|
|
|
|
m_floorMaterial.fs.reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::ensureBuffers()
|
|
|
|
{
|
|
|
|
if (m_blockVertexBuf)
|
|
|
|
return;
|
|
|
|
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
const int concurrentFrameCount = m_window->concurrentFrameCount();
|
|
|
|
|
|
|
|
// Vertex buffer for the block.
|
|
|
|
VkBufferCreateInfo bufInfo;
|
|
|
|
memset(&bufInfo, 0, sizeof(bufInfo));
|
|
|
|
bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
|
|
const int blockMeshByteCount = m_blockMesh.data()->vertexCount * 8 * sizeof(float);
|
|
|
|
bufInfo.size = blockMeshByteCount;
|
|
|
|
bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
|
|
|
|
VkResult err = m_devFuncs->vkCreateBuffer(dev, &bufInfo, nullptr, &m_blockVertexBuf);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create vertex buffer: %d", err);
|
|
|
|
|
|
|
|
VkMemoryRequirements blockVertMemReq;
|
|
|
|
m_devFuncs->vkGetBufferMemoryRequirements(dev, m_blockVertexBuf, &blockVertMemReq);
|
|
|
|
|
|
|
|
// Vertex buffer for the logo.
|
|
|
|
const int logoMeshByteCount = m_logoMesh.data()->vertexCount * 8 * sizeof(float);
|
|
|
|
bufInfo.size = logoMeshByteCount;
|
|
|
|
bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
|
|
|
|
err = m_devFuncs->vkCreateBuffer(dev, &bufInfo, nullptr, &m_logoVertexBuf);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create vertex buffer: %d", err);
|
|
|
|
|
|
|
|
VkMemoryRequirements logoVertMemReq;
|
|
|
|
m_devFuncs->vkGetBufferMemoryRequirements(dev, m_logoVertexBuf, &logoVertMemReq);
|
|
|
|
|
|
|
|
// Vertex buffer for the floor.
|
|
|
|
bufInfo.size = sizeof(quadVert);
|
|
|
|
err = m_devFuncs->vkCreateBuffer(dev, &bufInfo, nullptr, &m_floorVertexBuf);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create vertex buffer: %d", err);
|
|
|
|
|
|
|
|
VkMemoryRequirements floorVertMemReq;
|
|
|
|
m_devFuncs->vkGetBufferMemoryRequirements(dev, m_floorVertexBuf, &floorVertMemReq);
|
|
|
|
|
|
|
|
// Uniform buffer. Instead of using multiple descriptor sets, we take a
|
|
|
|
// different approach: have a single dynamic uniform buffer and specify the
|
|
|
|
// active-frame-specific offset at the time of binding the descriptor set.
|
|
|
|
bufInfo.size = (m_itemMaterial.vertUniSize + m_itemMaterial.fragUniSize) * concurrentFrameCount;
|
|
|
|
bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
|
|
|
|
err = m_devFuncs->vkCreateBuffer(dev, &bufInfo, nullptr, &m_uniBuf);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create uniform buffer: %d", err);
|
|
|
|
|
|
|
|
VkMemoryRequirements uniMemReq;
|
|
|
|
m_devFuncs->vkGetBufferMemoryRequirements(dev, m_uniBuf, &uniMemReq);
|
|
|
|
|
|
|
|
// Allocate memory for everything at once.
|
|
|
|
VkDeviceSize logoVertStartOffset = aligned(0 + blockVertMemReq.size, logoVertMemReq.alignment);
|
|
|
|
VkDeviceSize floorVertStartOffset = aligned(logoVertStartOffset + logoVertMemReq.size, floorVertMemReq.alignment);
|
|
|
|
m_itemMaterial.uniMemStartOffset = aligned(floorVertStartOffset + floorVertMemReq.size, uniMemReq.alignment);
|
|
|
|
VkMemoryAllocateInfo memAllocInfo = {
|
|
|
|
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
|
|
|
|
nullptr,
|
|
|
|
m_itemMaterial.uniMemStartOffset + uniMemReq.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_blockVertexBuf, m_bufMem, 0);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to bind vertex buffer memory: %d", err);
|
|
|
|
err = m_devFuncs->vkBindBufferMemory(dev, m_logoVertexBuf, m_bufMem, logoVertStartOffset);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to bind vertex buffer memory: %d", err);
|
|
|
|
err = m_devFuncs->vkBindBufferMemory(dev, m_floorVertexBuf, m_bufMem, floorVertStartOffset);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to bind vertex buffer memory: %d", err);
|
|
|
|
err = m_devFuncs->vkBindBufferMemory(dev, m_uniBuf, m_bufMem, m_itemMaterial.uniMemStartOffset);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to bind uniform buffer memory: %d", err);
|
|
|
|
|
|
|
|
// Copy vertex data.
|
|
|
|
quint8 *p;
|
|
|
|
err = m_devFuncs->vkMapMemory(dev, m_bufMem, 0, m_itemMaterial.uniMemStartOffset, 0, reinterpret_cast<void **>(&p));
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to map memory: %d", err);
|
|
|
|
memcpy(p, m_blockMesh.data()->geom.constData(), blockMeshByteCount);
|
|
|
|
memcpy(p + logoVertStartOffset, m_logoMesh.data()->geom.constData(), logoMeshByteCount);
|
|
|
|
memcpy(p + floorVertStartOffset, quadVert, sizeof(quadVert));
|
|
|
|
m_devFuncs->vkUnmapMemory(dev, m_bufMem);
|
|
|
|
|
|
|
|
// Write descriptors for the uniform buffers in the vertex and fragment shaders.
|
|
|
|
VkDescriptorBufferInfo vertUni = { m_uniBuf, 0, m_itemMaterial.vertUniSize };
|
|
|
|
VkDescriptorBufferInfo fragUni = { m_uniBuf, m_itemMaterial.vertUniSize, m_itemMaterial.fragUniSize };
|
|
|
|
|
|
|
|
VkWriteDescriptorSet descWrite[2];
|
|
|
|
memset(descWrite, 0, sizeof(descWrite));
|
|
|
|
descWrite[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
|
|
descWrite[0].dstSet = m_itemMaterial.descSet;
|
|
|
|
descWrite[0].dstBinding = 0;
|
|
|
|
descWrite[0].descriptorCount = 1;
|
|
|
|
descWrite[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
|
|
|
|
descWrite[0].pBufferInfo = &vertUni;
|
|
|
|
|
|
|
|
descWrite[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
|
|
descWrite[1].dstSet = m_itemMaterial.descSet;
|
|
|
|
descWrite[1].dstBinding = 1;
|
|
|
|
descWrite[1].descriptorCount = 1;
|
|
|
|
descWrite[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
|
|
|
|
descWrite[1].pBufferInfo = &fragUni;
|
|
|
|
|
|
|
|
m_devFuncs->vkUpdateDescriptorSets(dev, 2, descWrite, 0, nullptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::ensureInstanceBuffer()
|
|
|
|
{
|
|
|
|
if (m_instCount == m_preparedInstCount && m_instBuf)
|
|
|
|
return;
|
|
|
|
|
|
|
|
Q_ASSERT(m_instCount <= MAX_INSTANCES);
|
|
|
|
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
|
|
|
|
// allocate only once, for the maximum instance count
|
|
|
|
if (!m_instBuf) {
|
|
|
|
VkBufferCreateInfo bufInfo;
|
|
|
|
memset(&bufInfo, 0, sizeof(bufInfo));
|
|
|
|
bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
|
|
bufInfo.size = MAX_INSTANCES * PER_INSTANCE_DATA_SIZE;
|
|
|
|
bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
|
|
|
|
|
|
|
|
// Keep a copy of the data since we may lose all graphics resources on
|
|
|
|
// unexpose, and reinitializing to new random positions afterwards
|
|
|
|
// would not be nice.
|
|
|
|
m_instData.resize(bufInfo.size);
|
|
|
|
|
|
|
|
VkResult err = m_devFuncs->vkCreateBuffer(dev, &bufInfo, nullptr, &m_instBuf);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to create instance buffer: %d", err);
|
|
|
|
|
|
|
|
VkMemoryRequirements memReq;
|
|
|
|
m_devFuncs->vkGetBufferMemoryRequirements(dev, m_instBuf, &memReq);
|
|
|
|
if (DBG)
|
|
|
|
qDebug("Allocating %u bytes for instance data", uint32_t(memReq.size));
|
|
|
|
|
|
|
|
VkMemoryAllocateInfo memAllocInfo = {
|
|
|
|
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
|
|
|
|
nullptr,
|
|
|
|
memReq.size,
|
|
|
|
m_window->hostVisibleMemoryIndex()
|
|
|
|
};
|
|
|
|
err = m_devFuncs->vkAllocateMemory(dev, &memAllocInfo, nullptr, &m_instBufMem);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to allocate memory: %d", err);
|
|
|
|
|
|
|
|
err = m_devFuncs->vkBindBufferMemory(dev, m_instBuf, m_instBufMem, 0);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to bind instance buffer memory: %d", err);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_instCount != m_preparedInstCount) {
|
|
|
|
if (DBG)
|
|
|
|
qDebug("Preparing instances %d..%d", m_preparedInstCount, m_instCount - 1);
|
|
|
|
char *p = m_instData.data();
|
|
|
|
p += m_preparedInstCount * PER_INSTANCE_DATA_SIZE;
|
2019-03-27 18:59:47 +00:00
|
|
|
auto gen = [](int a, int b) {
|
|
|
|
return float(QRandomGenerator::global()->bounded(double(b - a)) + a);
|
|
|
|
};
|
2017-03-24 13:54:24 +00:00
|
|
|
for (int i = m_preparedInstCount; i < m_instCount; ++i) {
|
|
|
|
// Apply a random translation to each instance of the mesh.
|
|
|
|
float t[] = { gen(-5, 5), gen(-4, 6), gen(-30, 5) };
|
|
|
|
memcpy(p, t, 12);
|
|
|
|
// Apply a random adjustment to the diffuse color for each instance. (default is 0.7)
|
|
|
|
float d[] = { gen(-6, 3) / 10.0f, gen(-6, 3) / 10.0f, gen(-6, 3) / 10.0f };
|
|
|
|
memcpy(p + 12, d, 12);
|
|
|
|
p += PER_INSTANCE_DATA_SIZE;
|
|
|
|
}
|
|
|
|
m_preparedInstCount = m_instCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
quint8 *p;
|
|
|
|
VkResult err = m_devFuncs->vkMapMemory(dev, m_instBufMem, 0, m_instCount * PER_INSTANCE_DATA_SIZE, 0,
|
|
|
|
reinterpret_cast<void **>(&p));
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to map memory: %d", err);
|
|
|
|
memcpy(p, m_instData.constData(), m_instData.size());
|
|
|
|
m_devFuncs->vkUnmapMemory(dev, m_instBufMem);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::getMatrices(QMatrix4x4 *vp, QMatrix4x4 *model, QMatrix3x3 *modelNormal, QVector3D *eyePos)
|
|
|
|
{
|
|
|
|
model->setToIdentity();
|
|
|
|
if (m_useLogo)
|
|
|
|
model->rotate(90, 1, 0, 0);
|
|
|
|
model->rotate(m_rotation, 1, 1, 0);
|
|
|
|
|
|
|
|
*modelNormal = model->normalMatrix();
|
|
|
|
|
|
|
|
QMatrix4x4 view = m_cam.viewMatrix();
|
|
|
|
*vp = m_proj * view;
|
|
|
|
|
|
|
|
*eyePos = view.inverted().column(3).toVector3D();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::writeFragUni(quint8 *p, const QVector3D &eyePos)
|
|
|
|
{
|
|
|
|
float ECCameraPosition[] = { eyePos.x(), eyePos.y(), eyePos.z() };
|
|
|
|
memcpy(p, ECCameraPosition, 12);
|
|
|
|
p += 16;
|
|
|
|
|
|
|
|
// Material
|
|
|
|
float ka[] = { 0.05f, 0.05f, 0.05f };
|
|
|
|
memcpy(p, ka, 12);
|
|
|
|
p += 16;
|
|
|
|
|
|
|
|
float kd[] = { 0.7f, 0.7f, 0.7f };
|
|
|
|
memcpy(p, kd, 12);
|
|
|
|
p += 16;
|
|
|
|
|
|
|
|
float ks[] = { 0.66f, 0.66f, 0.66f };
|
|
|
|
memcpy(p, ks, 12);
|
|
|
|
p += 16;
|
|
|
|
|
|
|
|
// Light parameters
|
|
|
|
float ECLightPosition[] = { m_lightPos.x(), m_lightPos.y(), m_lightPos.z() };
|
|
|
|
memcpy(p, ECLightPosition, 12);
|
|
|
|
p += 16;
|
|
|
|
|
|
|
|
float att[] = { 1, 0, 0 };
|
|
|
|
memcpy(p, att, 12);
|
|
|
|
p += 16;
|
|
|
|
|
|
|
|
float color[] = { 1.0f, 1.0f, 1.0f };
|
|
|
|
memcpy(p, color, 12);
|
|
|
|
p += 12; // next we have two floats which have an alignment of 4, hence 12 only
|
|
|
|
|
|
|
|
float intensity = 0.8f;
|
|
|
|
memcpy(p, &intensity, 4);
|
|
|
|
p += 4;
|
|
|
|
|
|
|
|
float specularExp = 150.0f;
|
|
|
|
memcpy(p, &specularExp, 4);
|
|
|
|
p += 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::startNextFrame()
|
|
|
|
{
|
|
|
|
// For demonstration purposes offload the command buffer generation onto a
|
|
|
|
// worker thread and continue with the frame submission only when it has
|
|
|
|
// finished.
|
|
|
|
Q_ASSERT(!m_framePending);
|
|
|
|
m_framePending = true;
|
|
|
|
QFuture<void> future = QtConcurrent::run(this, &Renderer::buildFrame);
|
|
|
|
m_frameWatcher.setFuture(future);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::buildFrame()
|
|
|
|
{
|
|
|
|
QMutexLocker locker(&m_guiMutex);
|
|
|
|
|
|
|
|
ensureBuffers();
|
|
|
|
ensureInstanceBuffer();
|
|
|
|
m_pipelinesFuture.waitForFinished();
|
|
|
|
|
|
|
|
VkCommandBuffer cb = m_window->currentCommandBuffer();
|
|
|
|
const QSize sz = m_window->swapChainImageSize();
|
|
|
|
|
Vulkan Examples: Fix Clang warnings about initialization of VkClearColorValue
hellovulkanwindow.cpp(97,38): warning: suggest braces around initialization of subobject [-Wmissing-braces]
VkClearColorValue clearColor = { 0.0f, m_green, 0.0f, 1.0f };
hellovulkantexture.cpp(771,38): warning: suggest braces around initialization of subobject [-Wmissing-braces]
VkClearColorValue clearColor = { 0, 0, 0, 1 };
..\shared\trianglerenderer.cpp(455,38): warning: suggest braces around initialization of subobject [-Wmissing-braces]
VkClearColorValue clearColor = { 0, 0, 0, 1 };
renderer.cpp(896,38): warning: suggest braces around initialization of subobject [-Wmissing-braces]
VkClearColorValue clearColor = { 0.67f, 0.84f, 0.9f, 1.0f };
Change-Id: I3c2403699059dac2f88541f2a2102b774db0c887
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2018-04-27 13:31:17 +00:00
|
|
|
VkClearColorValue clearColor = {{ 0.67f, 0.84f, 0.9f, 1.0f }};
|
2017-03-24 13:54:24 +00:00
|
|
|
VkClearDepthStencilValue clearDS = { 1, 0 };
|
|
|
|
VkClearValue clearValues[3];
|
|
|
|
memset(clearValues, 0, sizeof(clearValues));
|
|
|
|
clearValues[0].color = clearValues[2].color = clearColor;
|
|
|
|
clearValues[1].depthStencil = clearDS;
|
|
|
|
|
|
|
|
VkRenderPassBeginInfo rpBeginInfo;
|
|
|
|
memset(&rpBeginInfo, 0, sizeof(rpBeginInfo));
|
|
|
|
rpBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
|
|
|
|
rpBeginInfo.renderPass = m_window->defaultRenderPass();
|
|
|
|
rpBeginInfo.framebuffer = m_window->currentFramebuffer();
|
|
|
|
rpBeginInfo.renderArea.extent.width = sz.width();
|
|
|
|
rpBeginInfo.renderArea.extent.height = sz.height();
|
|
|
|
rpBeginInfo.clearValueCount = m_window->sampleCountFlagBits() > VK_SAMPLE_COUNT_1_BIT ? 3 : 2;
|
|
|
|
rpBeginInfo.pClearValues = clearValues;
|
|
|
|
VkCommandBuffer cmdBuf = m_window->currentCommandBuffer();
|
|
|
|
m_devFuncs->vkCmdBeginRenderPass(cmdBuf, &rpBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
|
|
|
|
VkViewport viewport = {
|
|
|
|
0, 0,
|
|
|
|
float(sz.width()), float(sz.height()),
|
|
|
|
0, 1
|
|
|
|
};
|
|
|
|
m_devFuncs->vkCmdSetViewport(cb, 0, 1, &viewport);
|
|
|
|
|
|
|
|
VkRect2D scissor = {
|
|
|
|
{ 0, 0 },
|
|
|
|
{ uint32_t(sz.width()), uint32_t(sz.height()) }
|
|
|
|
};
|
|
|
|
m_devFuncs->vkCmdSetScissor(cb, 0, 1, &scissor);
|
|
|
|
|
|
|
|
buildDrawCallsForFloor();
|
|
|
|
buildDrawCallsForItems();
|
|
|
|
|
|
|
|
m_devFuncs->vkCmdEndRenderPass(cmdBuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::buildDrawCallsForItems()
|
|
|
|
{
|
|
|
|
VkDevice dev = m_window->device();
|
|
|
|
VkCommandBuffer cb = m_window->currentCommandBuffer();
|
|
|
|
|
|
|
|
m_devFuncs->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, m_itemMaterial.pipeline);
|
|
|
|
|
|
|
|
VkDeviceSize vbOffset = 0;
|
|
|
|
m_devFuncs->vkCmdBindVertexBuffers(cb, 0, 1, m_useLogo ? &m_logoVertexBuf : &m_blockVertexBuf, &vbOffset);
|
|
|
|
m_devFuncs->vkCmdBindVertexBuffers(cb, 1, 1, &m_instBuf, &vbOffset);
|
|
|
|
|
|
|
|
// Now provide offsets so that the two dynamic buffers point to the
|
|
|
|
// beginning of the vertex and fragment uniform data for the current frame.
|
|
|
|
uint32_t frameUniOffset = m_window->currentFrame() * (m_itemMaterial.vertUniSize + m_itemMaterial.fragUniSize);
|
|
|
|
uint32_t frameUniOffsets[] = { frameUniOffset, frameUniOffset };
|
|
|
|
m_devFuncs->vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, m_itemMaterial.pipelineLayout, 0, 1,
|
|
|
|
&m_itemMaterial.descSet, 2, frameUniOffsets);
|
|
|
|
|
|
|
|
if (m_animating)
|
|
|
|
m_rotation += 0.5;
|
|
|
|
|
|
|
|
if (m_animating || m_vpDirty) {
|
|
|
|
if (m_vpDirty)
|
|
|
|
--m_vpDirty;
|
|
|
|
QMatrix4x4 vp, model;
|
|
|
|
QMatrix3x3 modelNormal;
|
|
|
|
QVector3D eyePos;
|
|
|
|
getMatrices(&vp, &model, &modelNormal, &eyePos);
|
|
|
|
|
|
|
|
// Map the uniform data for the current frame, ignore the geometry data at
|
|
|
|
// the beginning and the uniforms for other frames.
|
|
|
|
quint8 *p;
|
|
|
|
VkResult err = m_devFuncs->vkMapMemory(dev, m_bufMem,
|
|
|
|
m_itemMaterial.uniMemStartOffset + frameUniOffset,
|
|
|
|
m_itemMaterial.vertUniSize + m_itemMaterial.fragUniSize,
|
|
|
|
0, reinterpret_cast<void **>(&p));
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
qFatal("Failed to map memory: %d", err);
|
|
|
|
|
|
|
|
// Vertex shader uniforms
|
|
|
|
memcpy(p, vp.constData(), 64);
|
|
|
|
memcpy(p + 64, model.constData(), 64);
|
|
|
|
const float *mnp = modelNormal.constData();
|
|
|
|
memcpy(p + 128, mnp, 12);
|
|
|
|
memcpy(p + 128 + 16, mnp + 3, 12);
|
|
|
|
memcpy(p + 128 + 32, mnp + 6, 12);
|
|
|
|
|
|
|
|
// Fragment shader uniforms
|
|
|
|
p += m_itemMaterial.vertUniSize;
|
|
|
|
writeFragUni(p, eyePos);
|
|
|
|
|
|
|
|
m_devFuncs->vkUnmapMemory(dev, m_bufMem);
|
|
|
|
}
|
|
|
|
|
|
|
|
m_devFuncs->vkCmdDraw(cb, (m_useLogo ? m_logoMesh.data() : m_blockMesh.data())->vertexCount, m_instCount, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::buildDrawCallsForFloor()
|
|
|
|
{
|
|
|
|
VkCommandBuffer cb = m_window->currentCommandBuffer();
|
|
|
|
|
|
|
|
m_devFuncs->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, m_floorMaterial.pipeline);
|
|
|
|
|
|
|
|
VkDeviceSize vbOffset = 0;
|
|
|
|
m_devFuncs->vkCmdBindVertexBuffers(cb, 0, 1, &m_floorVertexBuf, &vbOffset);
|
|
|
|
|
|
|
|
QMatrix4x4 mvp = m_proj * m_cam.viewMatrix() * m_floorModel;
|
|
|
|
m_devFuncs->vkCmdPushConstants(cb, m_floorMaterial.pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, 64, mvp.constData());
|
|
|
|
float color[] = { 0.67f, 1.0f, 0.2f };
|
|
|
|
m_devFuncs->vkCmdPushConstants(cb, m_floorMaterial.pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 64, 12, color);
|
|
|
|
|
|
|
|
m_devFuncs->vkCmdDraw(cb, 4, 1, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::addNew()
|
|
|
|
{
|
|
|
|
QMutexLocker locker(&m_guiMutex);
|
|
|
|
m_instCount = qMin(m_instCount + 16, MAX_INSTANCES);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::yaw(float degrees)
|
|
|
|
{
|
|
|
|
QMutexLocker locker(&m_guiMutex);
|
|
|
|
m_cam.yaw(degrees);
|
|
|
|
markViewProjDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::pitch(float degrees)
|
|
|
|
{
|
|
|
|
QMutexLocker locker(&m_guiMutex);
|
|
|
|
m_cam.pitch(degrees);
|
|
|
|
markViewProjDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::walk(float amount)
|
|
|
|
{
|
|
|
|
QMutexLocker locker(&m_guiMutex);
|
|
|
|
m_cam.walk(amount);
|
|
|
|
markViewProjDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::strafe(float amount)
|
|
|
|
{
|
|
|
|
QMutexLocker locker(&m_guiMutex);
|
|
|
|
m_cam.strafe(amount);
|
|
|
|
markViewProjDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Renderer::setUseLogo(bool b)
|
|
|
|
{
|
|
|
|
QMutexLocker locker(&m_guiMutex);
|
|
|
|
m_useLogo = b;
|
|
|
|
if (!m_animating)
|
|
|
|
m_window->requestUpdate();
|
|
|
|
}
|