525 lines
No EOL
22 KiB
C++
525 lines
No EOL
22 KiB
C++
/*
|
|
* Vulkan Example - Drawing multiple animated gears (emulating the look of glxgears)
|
|
*
|
|
* All gears are using single index, vertex and uniform buffers to show the Vulkan best practices of keeping the no. of buffer/memory allocations to a mimimum
|
|
* We use index offsets and instance indices to offset into the buffers at draw time for each gear
|
|
*
|
|
* Copyright (C) 2016-2023 by Sascha Willems - www.saschawillems.de
|
|
*
|
|
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
|
|
*/
|
|
|
|
#include "vulkanexamplebase.h"
|
|
|
|
const uint32_t numGears = 3;
|
|
|
|
// Used for passing the definition of a gear during construction
|
|
struct GearDefinition {
|
|
float innerRadius;
|
|
float outerRadius;
|
|
float width;
|
|
int numTeeth;
|
|
float toothDepth;
|
|
glm::vec3 color;
|
|
glm::vec3 pos;
|
|
float rotSpeed;
|
|
float rotOffset;
|
|
};
|
|
|
|
/*
|
|
* Gear
|
|
* This class contains the properties of a single gear and a function to generate vertices and indices
|
|
*/
|
|
class Gear
|
|
{
|
|
public:
|
|
// Definition for the vertex data used to render the gears
|
|
struct Vertex {
|
|
glm::vec3 position;
|
|
glm::vec3 normal;
|
|
glm::vec3 color;
|
|
};
|
|
|
|
glm::vec3 color;
|
|
glm::vec3 pos;
|
|
float rotSpeed{ 0.0f };
|
|
float rotOffset{ 0.0f };
|
|
// These are used at draw time to offset into the single buffers
|
|
uint32_t indexCount{ 0 };
|
|
uint32_t indexStart{ 0 };
|
|
|
|
// Generates the indices and vertices for this gear
|
|
// They are added to the vertex and index buffers passed into the function
|
|
// This way we can put all gears into single vertex and index buffers instead of having to allocate single buffers for each gear (which would be bad practice)
|
|
void generate(GearDefinition& gearDefinition, std::vector<Vertex>& vertexBuffer, std::vector<uint32_t>& indexBuffer) {
|
|
this->color = gearDefinition.color;
|
|
this->pos = gearDefinition.pos;
|
|
this->rotOffset = gearDefinition.rotOffset;
|
|
this->rotSpeed = gearDefinition.rotSpeed;
|
|
|
|
int i;
|
|
float r0, r1, r2;
|
|
float ta, da;
|
|
float u1, v1, u2, v2, len;
|
|
float cos_ta, cos_ta_1da, cos_ta_2da, cos_ta_3da, cos_ta_4da;
|
|
float sin_ta, sin_ta_1da, sin_ta_2da, sin_ta_3da, sin_ta_4da;
|
|
int32_t ix0, ix1, ix2, ix3, ix4, ix5;
|
|
|
|
// We need to know where this triangle's indices start within the single index buffer
|
|
indexStart = static_cast<uint32_t>(indexBuffer.size());
|
|
|
|
r0 = gearDefinition.innerRadius;
|
|
r1 = gearDefinition.outerRadius - gearDefinition.toothDepth / 2.0f;
|
|
r2 = gearDefinition.outerRadius + gearDefinition.toothDepth / 2.0f;
|
|
da = static_cast <float>(2.0 * M_PI / gearDefinition.numTeeth / 4.0);
|
|
|
|
glm::vec3 normal;
|
|
|
|
// Use lambda functions to simplify vertex and face creation
|
|
auto addFace = [&indexBuffer](int a, int b, int c) {
|
|
indexBuffer.push_back(a);
|
|
indexBuffer.push_back(b);
|
|
indexBuffer.push_back(c);
|
|
};
|
|
|
|
auto addVertex = [this, &vertexBuffer](float x, float y, float z, glm::vec3 normal) {
|
|
Vertex v{};
|
|
v.position = { x, y, z };
|
|
v.normal = normal;
|
|
v.color = this->color;
|
|
vertexBuffer.push_back(v);
|
|
return static_cast<int32_t>(vertexBuffer.size()) - 1;
|
|
};
|
|
|
|
for (i = 0; i < gearDefinition.numTeeth; i++) {
|
|
ta = i * static_cast <float>(2.0 * M_PI / gearDefinition.numTeeth);
|
|
|
|
cos_ta = cos(ta);
|
|
cos_ta_1da = cos(ta + da);
|
|
cos_ta_2da = cos(ta + 2.0f * da);
|
|
cos_ta_3da = cos(ta + 3.0f * da);
|
|
cos_ta_4da = cos(ta + 4.0f * da);
|
|
sin_ta = sin(ta);
|
|
sin_ta_1da = sin(ta + da);
|
|
sin_ta_2da = sin(ta + 2.0f * da);
|
|
sin_ta_3da = sin(ta + 3.0f * da);
|
|
sin_ta_4da = sin(ta + 4.0f * da);
|
|
|
|
u1 = r2 * cos_ta_1da - r1 * cos_ta;
|
|
v1 = r2 * sin_ta_1da - r1 * sin_ta;
|
|
len = sqrt(u1 * u1 + v1 * v1);
|
|
u1 /= len;
|
|
v1 /= len;
|
|
u2 = r1 * cos_ta_3da - r2 * cos_ta_2da;
|
|
v2 = r1 * sin_ta_3da - r2 * sin_ta_2da;
|
|
|
|
// Front face
|
|
normal = glm::vec3(0.0f, 0.0f, 1.0f);
|
|
ix0 = addVertex(r0 * cos_ta, r0 * sin_ta, gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r1 * cos_ta, r1 * sin_ta, gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r0 * cos_ta, r0 * sin_ta, gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, gearDefinition.width * 0.5f, normal);
|
|
ix4 = addVertex(r0 * cos_ta_4da, r0 * sin_ta_4da, gearDefinition.width * 0.5f, normal);
|
|
ix5 = addVertex(r1 * cos_ta_4da, r1 * sin_ta_4da, gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
addFace(ix2, ix3, ix4);
|
|
addFace(ix3, ix5, ix4);
|
|
|
|
// Teeth front face
|
|
normal = glm::vec3(0.0f, 0.0f, 1.0f);
|
|
ix0 = addVertex(r1 * cos_ta, r1 * sin_ta, gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r2 * cos_ta_1da, r2 * sin_ta_1da, gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r2 * cos_ta_2da, r2 * sin_ta_2da, gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
|
|
// Back face
|
|
normal = glm::vec3(0.0f, 0.0f, -1.0f);
|
|
ix0 = addVertex(r1 * cos_ta, r1 * sin_ta, -gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r0 * cos_ta, r0 * sin_ta, -gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, -gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r0 * cos_ta, r0 * sin_ta, -gearDefinition.width * 0.5f, normal);
|
|
ix4 = addVertex(r1 * cos_ta_4da, r1 * sin_ta_4da, -gearDefinition.width * 0.5f, normal);
|
|
ix5 = addVertex(r0 * cos_ta_4da, r0 * sin_ta_4da, -gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
addFace(ix2, ix3, ix4);
|
|
addFace(ix3, ix5, ix4);
|
|
|
|
// Teeth back face
|
|
normal = glm::vec3(0.0f, 0.0f, -1.0f);
|
|
ix0 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, -gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r2 * cos_ta_2da, r2 * sin_ta_2da, -gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r1 * cos_ta, r1 * sin_ta, -gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r2 * cos_ta_1da, r2 * sin_ta_1da, -gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
|
|
// Outard teeth faces
|
|
normal = glm::vec3(v1, -u1, 0.0f);
|
|
ix0 = addVertex(r1 * cos_ta, r1 * sin_ta, gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r1 * cos_ta, r1 * sin_ta, -gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r2 * cos_ta_1da, r2 * sin_ta_1da, gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r2 * cos_ta_1da, r2 * sin_ta_1da, -gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
|
|
normal = glm::vec3(cos_ta, sin_ta, 0.0f);
|
|
ix0 = addVertex(r2 * cos_ta_1da, r2 * sin_ta_1da, gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r2 * cos_ta_1da, r2 * sin_ta_1da, -gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r2 * cos_ta_2da, r2 * sin_ta_2da, gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r2 * cos_ta_2da, r2 * sin_ta_2da, -gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
|
|
normal = glm::vec3(v2, -u2, 0.0f);
|
|
ix0 = addVertex(r2 * cos_ta_2da, r2 * sin_ta_2da, gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r2 * cos_ta_2da, r2 * sin_ta_2da, -gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, -gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
|
|
normal = glm::vec3(cos_ta, sin_ta, 0.0f);
|
|
ix0 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, gearDefinition.width * 0.5f, normal);
|
|
ix1 = addVertex(r1 * cos_ta_3da, r1 * sin_ta_3da, -gearDefinition.width * 0.5f, normal);
|
|
ix2 = addVertex(r1 * cos_ta_4da, r1 * sin_ta_4da, gearDefinition.width * 0.5f, normal);
|
|
ix3 = addVertex(r1 * cos_ta_4da, r1 * sin_ta_4da, -gearDefinition.width * 0.5f, normal);
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
|
|
// Inside cylinder faces
|
|
ix0 = addVertex(r0 * cos_ta, r0 * sin_ta, -gearDefinition.width * 0.5f, glm::vec3(-cos_ta, -sin_ta, 0.0f));
|
|
ix1 = addVertex(r0 * cos_ta, r0 * sin_ta, gearDefinition.width * 0.5f, glm::vec3(-cos_ta, -sin_ta, 0.0f));
|
|
ix2 = addVertex(r0 * cos_ta_4da, r0 * sin_ta_4da, -gearDefinition.width * 0.5f, glm::vec3(-cos_ta_4da, -sin_ta_4da, 0.0f));
|
|
ix3 = addVertex(r0 * cos_ta_4da, r0 * sin_ta_4da, gearDefinition.width * 0.5f, glm::vec3(-cos_ta_4da, -sin_ta_4da, 0.0f));
|
|
addFace(ix0, ix1, ix2);
|
|
addFace(ix1, ix3, ix2);
|
|
}
|
|
|
|
// We need to know how many indices this triangle has at draw time
|
|
indexCount = static_cast<uint32_t>(indexBuffer.size()) - indexStart;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* VulkanExample
|
|
*/
|
|
class VulkanExample : public VulkanExampleBase
|
|
{
|
|
public:
|
|
std::vector<Gear> gears{};
|
|
|
|
VkPipeline pipeline{ VK_NULL_HANDLE };
|
|
VkPipelineLayout pipelineLayout{ VK_NULL_HANDLE };
|
|
VkDescriptorSet descriptorSet{ VK_NULL_HANDLE };
|
|
VkDescriptorSetLayout descriptorSetLayout{ VK_NULL_HANDLE };
|
|
|
|
// Even though this sample renders multiple objects (gears), we only use single buffers
|
|
// This is a best practices and Vulkan applications should keep the number of memory allocations as small as possible
|
|
// Having as little buffers as possible also reduces the number of buffer binds
|
|
vks::Buffer vertexBuffer;
|
|
vks::Buffer indexBuffer;
|
|
struct UniformData
|
|
{
|
|
glm::mat4 projection;
|
|
glm::mat4 view;
|
|
glm::vec4 lightPos;
|
|
// The model matrix is used to rotate a given gear, so we have one mat4 per gear
|
|
glm::mat4 model[numGears];
|
|
} uniformData;
|
|
vks::Buffer uniformBuffer;
|
|
|
|
VulkanExample() : VulkanExampleBase()
|
|
{
|
|
title = "Vulkan gears";
|
|
camera.type = Camera::CameraType::lookat;
|
|
camera.setPosition(glm::vec3(0.0f, 2.5f, -16.0f));
|
|
camera.setRotation(glm::vec3(0.0f, 0.0f, 0.0f));
|
|
camera.setPerspective(60.0f, (float)width / (float)height, 0.001f, 256.0f);
|
|
timerSpeed *= 0.25f;
|
|
}
|
|
|
|
~VulkanExample()
|
|
{
|
|
if (device) {
|
|
vkDestroyPipeline(device, pipeline, nullptr);
|
|
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
|
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
|
|
indexBuffer.destroy();
|
|
vertexBuffer.destroy();
|
|
uniformBuffer.destroy();
|
|
}
|
|
}
|
|
|
|
void prepareGears()
|
|
{
|
|
// Set up three differntly shaped and colored gears
|
|
std::vector<GearDefinition> gearDefinitions(3);
|
|
|
|
// Large red gear
|
|
gearDefinitions[0].innerRadius = 1.0f;
|
|
gearDefinitions[0].outerRadius = 4.0f;
|
|
gearDefinitions[0].width = 1.0f;
|
|
gearDefinitions[0].numTeeth = 20;
|
|
gearDefinitions[0].toothDepth = 0.7f;
|
|
gearDefinitions[0].color = { 1.0f, 0.0f, 0.0f };
|
|
gearDefinitions[0].pos = { -3.0f, 0.0f, 0.0f };
|
|
gearDefinitions[0].rotSpeed = 1.0f;
|
|
gearDefinitions[0].rotOffset = 0.0f;
|
|
|
|
// Medium sized green gear
|
|
gearDefinitions[1].innerRadius = 0.5f;
|
|
gearDefinitions[1].outerRadius = 2.0f;
|
|
gearDefinitions[1].width = 2.0f;
|
|
gearDefinitions[1].numTeeth = 10;
|
|
gearDefinitions[1].toothDepth = 0.7f;
|
|
gearDefinitions[1].color = { 0.0f, 1.0f, 0.2f };
|
|
gearDefinitions[1].pos = { 3.1f, 0.0f, 0.0f };
|
|
gearDefinitions[1].rotSpeed = -2.0f;
|
|
gearDefinitions[1].rotOffset = -9.0f;
|
|
|
|
// Small blue gear
|
|
gearDefinitions[2].innerRadius = 1.3f;
|
|
gearDefinitions[2].outerRadius = 2.0f;
|
|
gearDefinitions[2].width = 0.5f;
|
|
gearDefinitions[2].numTeeth = 10;
|
|
gearDefinitions[2].toothDepth = 0.7f;
|
|
gearDefinitions[2].color = { 0.0f, 0.0f, 1.0f };
|
|
gearDefinitions[2].pos = { -3.1f, -6.2f, 0.0f };
|
|
gearDefinitions[2].rotSpeed = -2.0f;
|
|
gearDefinitions[2].rotOffset = -30.0f;
|
|
|
|
// We'll be using a single vertex and a single index buffer for all the gears, no matter their number
|
|
// This is a Vulkan best practice as it keeps the no. of memory/buffer allocations low
|
|
// Vulkan offers all the tools to easily index into those buffers at a later point (see the buildCommandBuffers function)
|
|
std::vector<Gear::Vertex> vertices{};
|
|
std::vector<uint32_t> indices{};
|
|
|
|
// Fills the vertex and index buffers for each of the gear
|
|
gears.resize(gearDefinitions.size());
|
|
for (int32_t i = 0; i < gears.size(); i++) {
|
|
gears[i].generate(gearDefinitions[i], vertices, indices);
|
|
}
|
|
|
|
// Create buffers and stage to device for performances
|
|
size_t vertexBufferSize = vertices.size() * sizeof(Gear::Vertex);
|
|
size_t indexBufferSize = indices.size() * sizeof(uint32_t);
|
|
|
|
vks::Buffer vertexStaging, indexStaging;
|
|
|
|
// Temorary Staging buffers from vertex and index data
|
|
vulkanDevice->createBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &vertexStaging, vertexBufferSize, vertices.data());
|
|
vulkanDevice->createBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &indexStaging, indexBufferSize, indices.data());
|
|
// Device local buffers to where our staging buffers will be copied to
|
|
vulkanDevice->createBuffer(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &vertexBuffer, vertexBufferSize);
|
|
vulkanDevice->createBuffer(VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &indexBuffer, indexBufferSize);
|
|
|
|
// Copy host (staging) to device
|
|
VkCommandBuffer copyCmd = vulkanDevice->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
|
|
VkBufferCopy copyRegion = {};
|
|
copyRegion.size = vertexBufferSize;
|
|
vkCmdCopyBuffer(copyCmd, vertexStaging.buffer, vertexBuffer.buffer, 1, ©Region);
|
|
copyRegion.size = indexBufferSize;
|
|
vkCmdCopyBuffer(copyCmd, indexStaging.buffer, indexBuffer.buffer, 1, ©Region);
|
|
vulkanDevice->flushCommandBuffer(copyCmd, queue, true);
|
|
|
|
vertexStaging.destroy();
|
|
indexStaging.destroy();
|
|
}
|
|
|
|
void setupDescriptors()
|
|
{
|
|
// We use a single descriptor set for the uniform data that contains both global matrices as well as per-gear model matrices
|
|
|
|
// Pool
|
|
std::vector<VkDescriptorPoolSize> poolSizes = {
|
|
vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
|
|
};
|
|
VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, static_cast<uint32_t>(gears.size()));
|
|
VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
|
|
|
|
// Layout
|
|
std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0)
|
|
};
|
|
VkDescriptorSetLayoutCreateInfo descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
|
|
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
|
|
|
|
// Set
|
|
VkDescriptorSetAllocateInfo allocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);
|
|
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
|
|
|
|
VkWriteDescriptorSet writeDescriptorSet = vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &uniformBuffer.descriptor);
|
|
vkUpdateDescriptorSets(vulkanDevice->logicalDevice, 1, &writeDescriptorSet, 0, nullptr);
|
|
}
|
|
|
|
void preparePipelines()
|
|
{
|
|
// Layout
|
|
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);
|
|
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));
|
|
|
|
// Pipelines
|
|
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
|
|
VkPipelineRasterizationStateCreateInfo rasterizationState = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_CLOCKWISE, 0);
|
|
VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
|
|
VkPipelineColorBlendStateCreateInfo colorBlendState = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState);
|
|
VkPipelineDepthStencilStateCreateInfo depthStencilState = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);
|
|
VkPipelineViewportStateCreateInfo viewportState = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
|
|
VkPipelineMultisampleStateCreateInfo multisampleState = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0);
|
|
std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
|
|
VkPipelineDynamicStateCreateInfo dynamicState = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables);
|
|
|
|
// Solid rendering pipeline
|
|
// Load shaders
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
|
|
|
|
shaderStages[0] = loadShader(getShadersPath() + "gears/gears.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shaderStages[1] = loadShader(getShadersPath() + "gears/gears.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
// Vertex bindings and attributes to match the vertex buffers storing the vertices for the gears
|
|
VkVertexInputBindingDescription vertexInputBinding = {
|
|
vks::initializers::vertexInputBindingDescription(0, sizeof(Gear::Vertex), VK_VERTEX_INPUT_RATE_VERTEX)
|
|
};
|
|
std::vector<VkVertexInputAttributeDescription> vertexInputAttributes = {
|
|
vks::initializers::vertexInputAttributeDescription(0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(Gear::Vertex, position)), // Location 0 : Position
|
|
vks::initializers::vertexInputAttributeDescription(0, 1, VK_FORMAT_R32G32B32_SFLOAT, offsetof(Gear::Vertex, normal)), // Location 1 : Normal
|
|
vks::initializers::vertexInputAttributeDescription(0, 2, VK_FORMAT_R32G32B32_SFLOAT, offsetof(Gear::Vertex, color)), // Location 2 : Color
|
|
};
|
|
VkPipelineVertexInputStateCreateInfo vertexInputStateCI = vks::initializers::pipelineVertexInputStateCreateInfo();
|
|
vertexInputStateCI.vertexBindingDescriptionCount = 1;
|
|
vertexInputStateCI.pVertexBindingDescriptions = &vertexInputBinding;
|
|
vertexInputStateCI.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexInputAttributes.size());
|
|
vertexInputStateCI.pVertexAttributeDescriptions = vertexInputAttributes.data();
|
|
|
|
VkGraphicsPipelineCreateInfo pipelineCreateInfo = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);
|
|
pipelineCreateInfo.pVertexInputState = &vertexInputStateCI;
|
|
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
|
|
pipelineCreateInfo.pRasterizationState = &rasterizationState;
|
|
pipelineCreateInfo.pColorBlendState = &colorBlendState;
|
|
pipelineCreateInfo.pMultisampleState = &multisampleState;
|
|
pipelineCreateInfo.pViewportState = &viewportState;
|
|
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
|
|
pipelineCreateInfo.pDynamicState = &dynamicState;
|
|
pipelineCreateInfo.stageCount = static_cast<uint32_t>(shaderStages.size());
|
|
pipelineCreateInfo.pStages = shaderStages.data();
|
|
|
|
VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipeline));
|
|
}
|
|
|
|
void buildCommandBuffers()
|
|
{
|
|
VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
|
|
|
|
VkClearValue clearValues[2];
|
|
clearValues[0].color = defaultClearColor;
|
|
clearValues[1].depthStencil = { 1.0f, 0 };
|
|
|
|
VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();
|
|
renderPassBeginInfo.renderPass = renderPass;
|
|
renderPassBeginInfo.renderArea.offset.x = 0;
|
|
renderPassBeginInfo.renderArea.offset.y = 0;
|
|
renderPassBeginInfo.renderArea.extent.width = width;
|
|
renderPassBeginInfo.renderArea.extent.height = height;
|
|
renderPassBeginInfo.clearValueCount = 2;
|
|
renderPassBeginInfo.pClearValues = clearValues;
|
|
|
|
for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
|
|
{
|
|
renderPassBeginInfo.framebuffer = frameBuffers[i];
|
|
|
|
VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
|
|
|
|
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
|
|
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
|
|
|
|
VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
|
|
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
|
|
|
|
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
|
|
|
|
// Vertices, indices and uniform data for all gears are stored in single buffers, so we only need to bind one buffer of each type and then index/offset into that for each separate gear
|
|
VkDeviceSize offsets[1] = { 0 };
|
|
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);
|
|
vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &vertexBuffer.buffer, offsets);
|
|
vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
|
|
for (auto j = 0; j < numGears; j++) {
|
|
// We use the instance index (last argument) to pass the index of the triangle to the shader
|
|
// With this we can index into the model matrices array of the uniform buffer like this (see gears.vert):
|
|
// ubo.model[gl_InstanceIndex];
|
|
vkCmdDrawIndexed(drawCmdBuffers[i], gears[j].indexCount, 1, gears[j].indexStart, 0, j);
|
|
}
|
|
|
|
drawUI(drawCmdBuffers[i]);
|
|
|
|
vkCmdEndRenderPass(drawCmdBuffers[i]);
|
|
|
|
VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
|
|
}
|
|
}
|
|
|
|
void prepareUniformBuffers()
|
|
{
|
|
// Create the vertex shader uniform buffer block
|
|
VK_CHECK_RESULT(vulkanDevice->createBuffer(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &uniformBuffer, sizeof(UniformData)));
|
|
// Map persistent
|
|
VK_CHECK_RESULT(uniformBuffer.map());
|
|
}
|
|
|
|
void updateUniformBuffers()
|
|
{
|
|
float degree = timer * 360.0f;
|
|
|
|
// Camera specific global matrices
|
|
uniformData.projection = camera.matrices.perspective;
|
|
uniformData.view = camera.matrices.view;
|
|
uniformData.lightPos = glm::vec4(0.0f, 0.0f, 2.5f, 1.0f);
|
|
|
|
// Update the model matrix for each gear that contains it's position and rotation
|
|
for (auto i = 0; i < numGears; i++) {
|
|
Gear gear = gears[i];
|
|
uniformData.model[i] = glm::mat4(1.0f);
|
|
uniformData.model[i] = glm::translate(uniformData.model[i], gear.pos);
|
|
uniformData.model[i] = glm::rotate(uniformData.model[i], glm::radians((gear.rotSpeed * degree) + gear.rotOffset), glm::vec3(0.0f, 0.0f, 1.0f));
|
|
}
|
|
|
|
memcpy(uniformBuffer.mapped, &uniformData, sizeof(UniformData));
|
|
}
|
|
|
|
void prepare()
|
|
{
|
|
VulkanExampleBase::prepare();
|
|
prepareGears();
|
|
prepareUniformBuffers();
|
|
setupDescriptors();
|
|
preparePipelines();
|
|
buildCommandBuffers();
|
|
prepared = true;
|
|
}
|
|
|
|
void draw()
|
|
{
|
|
VulkanExampleBase::prepareFrame();
|
|
submitInfo.commandBufferCount = 1;
|
|
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
|
|
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
|
|
VulkanExampleBase::submitFrame();
|
|
}
|
|
|
|
virtual void render()
|
|
{
|
|
if (!prepared)
|
|
return;
|
|
updateUniformBuffers();
|
|
draw();
|
|
}
|
|
|
|
};
|
|
|
|
VULKAN_EXAMPLE_MAIN() |