claude_code/procedural-3d-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Complete rework of the sample

Browse source 
Simplified, added comments and only use single buffers to show best practices
This commit is contained in:
Sascha Willems 2024-01-06 16:47:11 +01:00
parent f5cddbd207
commit eff719099a
7 changed files with 435 additions and 626 deletions
Download patch file Download diff file Expand all files Collapse all files

638
examples/gears/gears.cpp
View file

@ -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 * Copyright (C) 2016-2023 by Sascha Willems - www.saschawillems.de
* *
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT) * This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
*/ */
#include "vulkangear.h"
#include "vulkanexamplebase.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 class VulkanExample : public VulkanExampleBase
{ {
public: public:
struct { std::vector<Gear> gears{};
VkPipelineVertexInputStateCreateInfo inputState;
std::vector<VkVertexInputBindingDescription> bindingDescriptions;
std::vector<VkVertexInputAttributeDescription> attributeDescriptions;
} vertices;
std::vector<VulkanGear*> gears;
VkPipeline pipeline{ VK_NULL_HANDLE }; VkPipeline pipeline{ VK_NULL_HANDLE };
VkPipelineLayout pipelineLayout{ VK_NULL_HANDLE }; VkPipelineLayout pipelineLayout{ VK_NULL_HANDLE };
VkDescriptorSet descriptorSet{ VK_NULL_HANDLE };
VkDescriptorSetLayout descriptorSetLayout{ 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() VulkanExample() : VulkanExampleBase()
{ {
title = "Vulkan gears"; title = "Vulkan gears";
camera.type = Camera::CameraType::lookat; camera.type = Camera::CameraType::lookat;
camera.setPosition(glm::vec3(0.0f, 2.5f, -16.0f)); 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); camera.setPerspective(60.0f, (float)width / (float)height, 0.001f, 256.0f);
timerSpeed *= 0.25f; timerSpeed *= 0.25f;
} }
~VulkanExample() ~VulkanExample()
{ {
// Clean up used Vulkan resources if (device) {
// Note : Inherited destructor cleans up resources stored in base class
vkDestroyPipeline(device, pipeline, nullptr); vkDestroyPipeline(device, pipeline, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
indexBuffer.destroy();
for (auto& gear : gears) vertexBuffer.destroy();
{ uniformBuffer.destroy();
delete(gear);
} }
} }
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, &copyRegion);
copyRegion.size = indexBufferSize;
vkCmdCopyBuffer(copyCmd, indexStaging.buffer, indexBuffer.buffer, 1, &copyRegion);
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() void buildCommandBuffers()
{ {
VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo(); VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
@ -83,9 +444,16 @@ public:
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
for (auto& gear : gears) // 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 };
gear->draw(drawCmdBuffers[i], pipelineLayout); 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]); drawUI(drawCmdBuffers[i]);
@ -96,194 +464,43 @@ public:
} }
} }
void prepareVertices() void prepareUniformBuffers()
{ {
// Gear definitions // Create the vertex shader uniform buffer block
std::vector<float> innerRadiuses = { 1.0f, 0.5f, 1.3f }; 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)));
std::vector<float> outerRadiuses = { 4.0f, 2.0f, 2.0f }; // Map persistent
std::vector<float> widths = { 1.0f, 2.0f, 0.5f }; VK_CHECK_RESULT(uniformBuffer.map());
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));
} }
void updateUniformBuffers() void updateUniformBuffers()
{ {
for (auto& gear : gears) float degree = timer * 360.0f;
{
gear->updateUniformBuffer(camera.matrices.perspective, camera.matrices.view, 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() void draw()
@ -295,19 +512,6 @@ public:
VulkanExampleBase::submitFrame(); VulkanExampleBase::submitFrame();
} }
void prepare()
{
VulkanExampleBase::prepare();
prepareVertices();
setupDescriptorSetLayout();
preparePipelines();
setupDescriptorPool();
setupDescriptorSets();
updateUniformBuffers();
buildCommandBuffers();
prepared = true;
}
virtual void render() virtual void render()
{ {
if (!prepared) if (!prepared)
@ -316,10 +520,6 @@ public:
draw(); draw();
} }
virtual void viewChanged()
{
updateUniformBuffers();
}
}; };
VULKAN_EXAMPLE_MAIN() VULKAN_EXAMPLE_MAIN()

288
examples/gears/vulkangear.cpp
View file

@ -1,288 +0,0 @@
/*
* Vulkan Example - Animated gears using multiple uniform buffers
*
* 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"
int32_t VulkanGear::newVertex(std::vector<Vertex> *vBuffer, float x, float y, float z, const glm::vec3& normal)
{
Vertex v(glm::vec3(x, y, z), normal, color);
vBuffer->push_back(v);
return static_cast<int32_t>(vBuffer->size()) - 1;
}
void VulkanGear::newFace(std::vector<uint32_t> *iBuffer, int a, int b, int c)
{
iBuffer->push_back(a);
iBuffer->push_back(b);
iBuffer->push_back(c);
}
VulkanGear::~VulkanGear()
{
// Clean up vulkan resources
uniformBuffer.destroy();
vertexBuffer.destroy();
indexBuffer.destroy();
}
void VulkanGear::generate(GearInfo *gearinfo, VkQueue queue)
{
this->color = gearinfo->color;
this->pos = gearinfo->pos;
this->rotOffset = gearinfo->rotOffset;
this->rotSpeed = gearinfo->rotSpeed;
std::vector<Vertex> vBuffer;
std::vector<uint32_t> iBuffer;
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;
r0 = gearinfo->innerRadius;
r1 = gearinfo->outerRadius - gearinfo->toothDepth / 2.0f;
r2 = gearinfo->outerRadius + gearinfo->toothDepth / 2.0f;
da = static_cast < float>(2.0 * M_PI / gearinfo->numTeeth / 4.0);
glm::vec3 normal;
for (i = 0; i < gearinfo->numTeeth; i++)
{
ta = i * static_cast <float>(2.0 * M_PI / gearinfo->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 = newVertex(&vBuffer, r0 * cos_ta, r0 * sin_ta, gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r1 * cos_ta, r1 * sin_ta, gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r0 * cos_ta, r0 * sin_ta, gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, gearinfo->width * 0.5f, normal);
ix4 = newVertex(&vBuffer, r0 * cos_ta_4da, r0 * sin_ta_4da, gearinfo->width * 0.5f, normal);
ix5 = newVertex(&vBuffer, r1 * cos_ta_4da, r1 * sin_ta_4da, gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
newFace(&iBuffer, ix2, ix3, ix4);
newFace(&iBuffer, ix3, ix5, ix4);
// front sides of teeth
normal = glm::vec3(0.0f, 0.0f, 1.0f);
ix0 = newVertex(&vBuffer, r1 * cos_ta, r1 * sin_ta, gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r2 * cos_ta_1da, r2 * sin_ta_1da, gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r2 * cos_ta_2da, r2 * sin_ta_2da, gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
// back face
normal = glm::vec3(0.0f, 0.0f, -1.0f);
ix0 = newVertex(&vBuffer, r1 * cos_ta, r1 * sin_ta, -gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r0 * cos_ta, r0 * sin_ta, -gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, -gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r0 * cos_ta, r0 * sin_ta, -gearinfo->width * 0.5f, normal);
ix4 = newVertex(&vBuffer, r1 * cos_ta_4da, r1 * sin_ta_4da, -gearinfo->width * 0.5f, normal);
ix5 = newVertex(&vBuffer, r0 * cos_ta_4da, r0 * sin_ta_4da, -gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
newFace(&iBuffer, ix2, ix3, ix4);
newFace(&iBuffer, ix3, ix5, ix4);
// back sides of teeth
normal = glm::vec3(0.0f, 0.0f, -1.0f);
ix0 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, -gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r2 * cos_ta_2da, r2 * sin_ta_2da, -gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r1 * cos_ta, r1 * sin_ta, -gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r2 * cos_ta_1da, r2 * sin_ta_1da, -gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
// draw outward faces of teeth
normal = glm::vec3(v1, -u1, 0.0f);
ix0 = newVertex(&vBuffer, r1 * cos_ta, r1 * sin_ta, gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r1 * cos_ta, r1 * sin_ta, -gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r2 * cos_ta_1da, r2 * sin_ta_1da, gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r2 * cos_ta_1da, r2 * sin_ta_1da, -gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
normal = glm::vec3(cos_ta, sin_ta, 0.0f);
ix0 = newVertex(&vBuffer, r2 * cos_ta_1da, r2 * sin_ta_1da, gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r2 * cos_ta_1da, r2 * sin_ta_1da, -gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r2 * cos_ta_2da, r2 * sin_ta_2da, gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r2 * cos_ta_2da, r2 * sin_ta_2da, -gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
normal = glm::vec3(v2, -u2, 0.0f);
ix0 = newVertex(&vBuffer, r2 * cos_ta_2da, r2 * sin_ta_2da, gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r2 * cos_ta_2da, r2 * sin_ta_2da, -gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, -gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
normal = glm::vec3(cos_ta, sin_ta, 0.0f);
ix0 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, gearinfo->width * 0.5f, normal);
ix1 = newVertex(&vBuffer, r1 * cos_ta_3da, r1 * sin_ta_3da, -gearinfo->width * 0.5f, normal);
ix2 = newVertex(&vBuffer, r1 * cos_ta_4da, r1 * sin_ta_4da, gearinfo->width * 0.5f, normal);
ix3 = newVertex(&vBuffer, r1 * cos_ta_4da, r1 * sin_ta_4da, -gearinfo->width * 0.5f, normal);
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
// draw inside radius cylinder
ix0 = newVertex(&vBuffer, r0 * cos_ta, r0 * sin_ta, -gearinfo->width * 0.5f, glm::vec3(-cos_ta, -sin_ta, 0.0f));
ix1 = newVertex(&vBuffer, r0 * cos_ta, r0 * sin_ta, gearinfo->width * 0.5f, glm::vec3(-cos_ta, -sin_ta, 0.0f));
ix2 = newVertex(&vBuffer, r0 * cos_ta_4da, r0 * sin_ta_4da, -gearinfo->width * 0.5f, glm::vec3(-cos_ta_4da, -sin_ta_4da, 0.0f));
ix3 = newVertex(&vBuffer, r0 * cos_ta_4da, r0 * sin_ta_4da, gearinfo->width * 0.5f, glm::vec3(-cos_ta_4da, -sin_ta_4da, 0.0f));
newFace(&iBuffer, ix0, ix1, ix2);
newFace(&iBuffer, ix1, ix3, ix2);
}
size_t vertexBufferSize = vBuffer.size() * sizeof(Vertex);
size_t indexBufferSize = iBuffer.size() * sizeof(uint32_t);
vks::Buffer vertexStaging, indexStaging;
// Create staging buffers
// Vertex data
vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&vertexStaging,
vertexBufferSize,
vBuffer.data());
// Index data
vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&indexStaging,
indexBufferSize,
iBuffer.data());
// Create device local buffers
// Vertex buffer
vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&vertexBuffer,
vertexBufferSize);
// Index buffer
vulkanDevice->createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&indexBuffer,
indexBufferSize);
// Copy from staging buffers
VkCommandBuffer copyCmd = vulkanDevice->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
VkBufferCopy copyRegion = {};
copyRegion.size = vertexBufferSize;
vkCmdCopyBuffer(
copyCmd,
vertexStaging.buffer,
vertexBuffer.buffer,
1,
&copyRegion);
copyRegion.size = indexBufferSize;
vkCmdCopyBuffer(
copyCmd,
indexStaging.buffer,
indexBuffer.buffer,
1,
&copyRegion);
vulkanDevice->flushCommandBuffer(copyCmd, queue, true);
vkDestroyBuffer(vulkanDevice->logicalDevice, vertexStaging.buffer, nullptr);
vkFreeMemory(vulkanDevice->logicalDevice, vertexStaging.memory, nullptr);
vkDestroyBuffer(vulkanDevice->logicalDevice, indexStaging.buffer, nullptr);
vkFreeMemory(vulkanDevice->logicalDevice, indexStaging.memory, nullptr);
indexCount = static_cast<uint32_t>(iBuffer.size());
prepareUniformBuffer();
}
void VulkanGear::draw(VkCommandBuffer cmdbuffer, VkPipelineLayout pipelineLayout)
{
VkDeviceSize offsets[1] = { 0 };
vkCmdBindDescriptorSets(cmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);
vkCmdBindVertexBuffers(cmdbuffer, 0, 1, &vertexBuffer.buffer, offsets);
vkCmdBindIndexBuffer(cmdbuffer, indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(cmdbuffer, indexCount, 1, 0, 0, 1);
}
void VulkanGear::updateUniformBuffer(glm::mat4 perspective, glm::mat4 view, float timer)
{
ubo.projection = perspective;
ubo.view = view;
ubo.model = glm::mat4(1.0f);
ubo.model = glm::translate(ubo.model, pos);
ubo.model = glm::rotate(ubo.model, glm::radians((rotSpeed * timer) + rotOffset), glm::vec3(0.0f, 0.0f, 1.0f));
ubo.normal = glm::inverseTranspose(ubo.view * ubo.model);
ubo.lightPos = glm::vec3(0.0f, 0.0f, 2.5f);
ubo.lightPos.x = sin(glm::radians(timer)) * 8.0f;
ubo.lightPos.z = cos(glm::radians(timer)) * 8.0f;
memcpy(uniformBuffer.mapped, &ubo, sizeof(ubo));
}
void VulkanGear::setupDescriptorSet(VkDescriptorPool pool, VkDescriptorSetLayout descriptorSetLayout)
{
VkDescriptorSetAllocateInfo allocInfo =
vks::initializers::descriptorSetAllocateInfo(
pool,
&descriptorSetLayout,
1);
VK_CHECK_RESULT(vkAllocateDescriptorSets(vulkanDevice->logicalDevice, &allocInfo, &descriptorSet));
// Binding 0 : Vertex shader uniform buffer
VkWriteDescriptorSet writeDescriptorSet =
vks::initializers::writeDescriptorSet(
descriptorSet,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
0,
&uniformBuffer.descriptor);
vkUpdateDescriptorSets(vulkanDevice->logicalDevice, 1, &writeDescriptorSet, 0, NULL);
}
void VulkanGear::prepareUniformBuffer()
{
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(ubo)));
// Map persistent
VK_CHECK_RESULT(uniformBuffer.map());
}

102
examples/gears/vulkangear.h
View file

@ -1,102 +0,0 @@
/*
* Vulkan Example - Animated gears using multiple uniform buffers
*
* Copyright (C) 2016-2023 by Sascha Willems - www.saschawillems.de
*
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
*/
#pragma once
#include <math.h>
#include <vector>
#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include "vulkan/vulkan.h"
#include "VulkanTools.h"
#include "VulkanBuffer.h"
#include "VulkanDevice.h"
struct Vertex
{
float pos[3];
float normal[3];
float color[3];
Vertex(const glm::vec3& p, const glm::vec3& n, const glm::vec3& c)
{
pos[0] = p.x;
pos[1] = p.y;
pos[2] = p.z;
color[0] = c.x;
color[1] = c.y;
color[2] = c.z;
normal[0] = n.x;
normal[1] = n.y;
normal[2] = n.z;
}
};
struct GearInfo
{
float innerRadius;
float outerRadius;
float width;
int numTeeth;
float toothDepth;
glm::vec3 color;
glm::vec3 pos;
float rotSpeed;
float rotOffset;
};
class VulkanGear
{
private:
struct UBO
{
glm::mat4 projection;
glm::mat4 model;
glm::mat4 normal;
glm::mat4 view;
glm::vec3 lightPos;
};
vks::VulkanDevice *vulkanDevice;
glm::vec3 color;
glm::vec3 pos;
float rotSpeed;
float rotOffset;
vks::Buffer vertexBuffer;
vks::Buffer indexBuffer;
uint32_t indexCount;
UBO ubo;
vks::Buffer uniformBuffer;
int32_t newVertex(std::vector<Vertex> *vBuffer, float x, float y, float z, const glm::vec3& normal);
void newFace(std::vector<uint32_t> *iBuffer, int a, int b, int c);
void prepareUniformBuffer();
public:
VkDescriptorSet descriptorSet;
void draw(VkCommandBuffer cmdbuffer, VkPipelineLayout pipelineLayout);
void updateUniformBuffer(glm::mat4 perspective, glm::mat4 view, float timer);
void setupDescriptorSet(VkDescriptorPool pool, VkDescriptorSetLayout descriptorSetLayout);
VulkanGear(vks::VulkanDevice *vulkanDevice) : vulkanDevice(vulkanDevice) {};
~VulkanGear();
void generate(GearInfo *gearinfo, VkQueue queue);
};

11
shaders/glsl/gears/gears.vert
View file

@ -7,10 +7,9 @@ layout (location = 2) in vec3 inColor;
layout (binding = 0) uniform UBO layout (binding = 0) uniform UBO
{ {
mat4 projection; mat4 projection;
mat4 model;
mat4 normal;
mat4 view; mat4 view;
vec3 lightpos; vec4 lightpos;
mat4 model[3];
} ubo; } ubo;
layout (location = 0) out vec3 outNormal; layout (location = 0) out vec3 outNormal;
@ -20,12 +19,12 @@ layout (location = 3) out vec3 outLightVec;
void main() void main()
{ {
outNormal = normalize(mat3(ubo.normal) * inNormal); outNormal = normalize(mat3x3(ubo.model[gl_InstanceIndex]) * inNormal);
outColor = inColor; outColor = inColor;
mat4 modelView = ubo.view * ubo.model; mat4 modelView = ubo.view * ubo.model[gl_InstanceIndex];
vec4 pos = modelView * inPos; vec4 pos = modelView * inPos;
outEyePos = vec3(modelView * pos); outEyePos = vec3(modelView * pos);
vec4 lightPos = vec4(ubo.lightpos, 1.0) * modelView; vec4 lightPos = vec4(ubo.lightpos.xyz, 1.0) * modelView;
outLightVec = normalize(lightPos.xyz - outEyePos); outLightVec = normalize(lightPos.xyz - outEyePos);
gl_Position = ubo.projection * pos; gl_Position = ubo.projection * pos;
} }

BIN
shaders/glsl/gears/gears.vert.spv
View file

Binary file not shown.

14
shaders/hlsl/gears/gears.vert
View file

@ -1,4 +1,5 @@
// Copyright 2020 Google LLC // Copyright 2020 Google LLC
// Copyright 2023 Sascha Willems
struct VSInput struct VSInput
{ {
@ -10,10 +11,9 @@ struct VSInput
struct UBO struct UBO
{ {
float4x4 projection; float4x4 projection;
float4x4 model;
float4x4 normal;
float4x4 view; float4x4 view;
float3 lightpos; float4 lightpos;
float4x4 model[3];
}; };
cbuffer ubo : register(b0) { UBO ubo; } cbuffer ubo : register(b0) { UBO ubo; }
@ -27,15 +27,15 @@ struct VSOutput
[[vk::location(3)]] float3 LightVec : TEXCOORD2; [[vk::location(3)]] float3 LightVec : TEXCOORD2;
}; };
VSOutput main(VSInput input) VSOutput main(VSInput input, uint InstanceIndex : SV_InstanceID)
{ {
VSOutput output = (VSOutput)0; VSOutput output = (VSOutput)0;
output.Normal = normalize(mul((float4x3)ubo.normal, input.Normal).xyz); output.Normal = normalize(mul((float3x3)transpose(ubo.model[InstanceIndex]), input.Normal).xyz);
output.Color = input.Color; output.Color = input.Color;
float4x4 modelView = mul(ubo.view, ubo.model); float4x4 modelView = mul(ubo.view, ubo.model[InstanceIndex]);
float4 pos = mul(modelView, input.Pos); float4 pos = mul(modelView, input.Pos);
output.EyePos = mul(modelView, pos).xyz; output.EyePos = mul(modelView, pos).xyz;
float4 lightPos = mul(float4(ubo.lightpos, 1.0), modelView); float4 lightPos = mul(float4(ubo.lightpos.xyz, 1.0), modelView);
output.LightVec = normalize(lightPos.xyz - output.EyePos); output.LightVec = normalize(lightPos.xyz - output.EyePos);
output.Pos = mul(ubo.projection, pos); output.Pos = mul(ubo.projection, pos);
return output; return output;

BIN
shaders/hlsl/gears/gears.vert.spv
View file

Binary file not shown.