Complete rework of the sample
Simplified, added comments and only use single buffers to show best practices
This commit is contained in:
Sascha Willems
parent
f5cddbd207
commit
eff719099a
7 changed files with 435 additions and 626 deletions
|
|
@ -1,55 +1,416 @@
|
|||
/*
|
||||
* Vulkan Example - Animated gears using multiple uniform buffers
|
||||
*
|
||||
* 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 "vulkangear.h"
|
||||
#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:
|
||||
struct {
|
||||
VkPipelineVertexInputStateCreateInfo inputState;
|
||||
std::vector<VkVertexInputBindingDescription> bindingDescriptions;
|
||||
std::vector<VkVertexInputAttributeDescription> attributeDescriptions;
|
||||
} vertices;
|
||||
|
||||
std::vector<VulkanGear*> gears;
|
||||
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(-23.75f, 41.25f, 21.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()
|
||||
{
|
||||
// Clean up used Vulkan resources
|
||||
// Note : Inherited destructor cleans up resources stored in base class
|
||||
vkDestroyPipeline(device, pipeline, nullptr);
|
||||
|
||||
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
||||
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
|
||||
|
||||
for (auto& gear : gears)
|
||||
{
|
||||
delete(gear);
|
||||
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();
|
||||
|
|
@ -83,9 +444,16 @@ public:
|
|||
|
||||
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
|
||||
|
||||
for (auto& gear : gears)
|
||||
{
|
||||
gear->draw(drawCmdBuffers[i], pipelineLayout);
|
||||
// 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]);
|
||||
|
|
@ -96,194 +464,43 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
void prepareVertices()
|
||||
void prepareUniformBuffers()
|
||||
{
|
||||
// Gear definitions
|
||||
std::vector<float> innerRadiuses = { 1.0f, 0.5f, 1.3f };
|
||||
std::vector<float> outerRadiuses = { 4.0f, 2.0f, 2.0f };
|
||||
std::vector<float> widths = { 1.0f, 2.0f, 0.5f };
|
||||
std::vector<int32_t> toothCount = { 20, 10, 10 };
|
||||
std::vector<float> toothDepth = { 0.7f, 0.7f, 0.7f };
|
||||
std::vector<glm::vec3> colors = {
|
||||
glm::vec3(1.0f, 0.0f, 0.0f),
|
||||
glm::vec3(0.0f, 1.0f, 0.2f),
|
||||
glm::vec3(0.0f, 0.0f, 1.0f)
|
||||
};
|
||||
std::vector<glm::vec3> positions = {
|
||||
glm::vec3(-3.0, 0.0, 0.0),
|
||||
glm::vec3(3.1, 0.0, 0.0),
|
||||
glm::vec3(-3.1, -6.2, 0.0)
|
||||
};
|
||||
std::vector<float> rotationSpeeds = { 1.0f, -2.0f, -2.0f };
|
||||
std::vector<float> rotationOffsets = { 0.0f, -9.0f, -30.0f };
|
||||
|
||||
gears.resize(positions.size());
|
||||
for (int32_t i = 0; i < gears.size(); ++i)
|
||||
{
|
||||
GearInfo gearInfo = {};
|
||||
gearInfo.innerRadius = innerRadiuses[i];
|
||||
gearInfo.outerRadius = outerRadiuses[i];
|
||||
gearInfo.width = widths[i];
|
||||
gearInfo.numTeeth = toothCount[i];
|
||||
gearInfo.toothDepth = toothDepth[i];
|
||||
gearInfo.color = colors[i];
|
||||
gearInfo.pos = positions[i];
|
||||
gearInfo.rotSpeed = rotationSpeeds[i];
|
||||
gearInfo.rotOffset = rotationOffsets[i];
|
||||
|
||||
gears[i] = new VulkanGear(vulkanDevice);
|
||||
gears[i]->generate(&gearInfo, queue);
|
||||
}
|
||||
|
||||
// Binding and attribute descriptions are shared across all gears
|
||||
vertices.bindingDescriptions.resize(1);
|
||||
vertices.bindingDescriptions[0] =
|
||||
vks::initializers::vertexInputBindingDescription(
|
||||
0,
|
||||
sizeof(Vertex),
|
||||
VK_VERTEX_INPUT_RATE_VERTEX);
|
||||
|
||||
// Attribute descriptions
|
||||
// Describes memory layout and shader positions
|
||||
vertices.attributeDescriptions.resize(3);
|
||||
// Location 0 : Position
|
||||
vertices.attributeDescriptions[0] =
|
||||
vks::initializers::vertexInputAttributeDescription(
|
||||
0,
|
||||
0,
|
||||
VK_FORMAT_R32G32B32_SFLOAT,
|
||||
0);
|
||||
// Location 1 : Normal
|
||||
vertices.attributeDescriptions[1] =
|
||||
vks::initializers::vertexInputAttributeDescription(
|
||||
0,
|
||||
1,
|
||||
VK_FORMAT_R32G32B32_SFLOAT,
|
||||
sizeof(float) * 3);
|
||||
// Location 2 : Color
|
||||
vertices.attributeDescriptions[2] =
|
||||
vks::initializers::vertexInputAttributeDescription(
|
||||
0,
|
||||
2,
|
||||
VK_FORMAT_R32G32B32_SFLOAT,
|
||||
sizeof(float) * 6);
|
||||
|
||||
vertices.inputState = vks::initializers::pipelineVertexInputStateCreateInfo();
|
||||
vertices.inputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertices.bindingDescriptions.size());
|
||||
vertices.inputState.pVertexBindingDescriptions = vertices.bindingDescriptions.data();
|
||||
vertices.inputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertices.attributeDescriptions.size());
|
||||
vertices.inputState.pVertexAttributeDescriptions = vertices.attributeDescriptions.data();
|
||||
}
|
||||
|
||||
void setupDescriptorPool()
|
||||
{
|
||||
// One UBO for each gear
|
||||
std::vector<VkDescriptorPoolSize> poolSizes = {
|
||||
vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3),
|
||||
};
|
||||
VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, static_cast<uint32_t>(gears.size()));
|
||||
VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
|
||||
}
|
||||
|
||||
void setupDescriptorSetLayout()
|
||||
{
|
||||
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));
|
||||
|
||||
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);
|
||||
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout));
|
||||
}
|
||||
|
||||
void setupDescriptorSets()
|
||||
{
|
||||
for (auto& gear : gears)
|
||||
{
|
||||
gear->setupDescriptorSet(descriptorPool, descriptorSetLayout);
|
||||
}
|
||||
}
|
||||
|
||||
void preparePipelines()
|
||||
{
|
||||
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.data(),
|
||||
static_cast<uint32_t>(dynamicStateEnables.size()),
|
||||
0);
|
||||
|
||||
// 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);
|
||||
|
||||
VkGraphicsPipelineCreateInfo pipelineCreateInfo = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);
|
||||
pipelineCreateInfo.pVertexInputState = &vertices.inputState;
|
||||
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));
|
||||
// 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()
|
||||
{
|
||||
for (auto& gear : gears)
|
||||
{
|
||||
gear->updateUniformBuffer(camera.matrices.perspective, camera.matrices.view, timer * 360.0f);
|
||||
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()
|
||||
|
|
@ -295,19 +512,6 @@ public:
|
|||
VulkanExampleBase::submitFrame();
|
||||
}
|
||||
|
||||
void prepare()
|
||||
{
|
||||
VulkanExampleBase::prepare();
|
||||
prepareVertices();
|
||||
setupDescriptorSetLayout();
|
||||
preparePipelines();
|
||||
setupDescriptorPool();
|
||||
setupDescriptorSets();
|
||||
updateUniformBuffers();
|
||||
buildCommandBuffers();
|
||||
prepared = true;
|
||||
}
|
||||
|
||||
virtual void render()
|
||||
{
|
||||
if (!prepared)
|
||||
|
|
@ -316,10 +520,6 @@ public:
|
|||
draw();
|
||||
}
|
||||
|
||||
virtual void viewChanged()
|
||||
{
|
||||
updateUniformBuffers();
|
||||
}
|
||||
};
|
||||
|
||||
VULKAN_EXAMPLE_MAIN()
|
||||
Loading…
Add table
Add a link
Reference in a new issue