benjamin
/
VulkanSimulation
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: benjamin:9e0b0af5e81ca6aa89aff4a88f8e4f773e79a1af
Branches Tags
benjamin:feature/softbody-runtime-control
benjamin:main
..
compare: benjamin:405411337cb798d07addd7886d876a6b6e7cf1d6
Branches Tags
benjamin:feature/softbody-runtime-control
benjamin:main

No commits in common. '9e0b0af5e81ca6aa89aff4a88f8e4f773e79a1af' and '405411337cb798d07addd7886d876a6b6e7cf1d6' have entirely different histories.
9e0b0af5e8 ... 405411337c

10 changed files with 98 additions and 253 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats
  1. 8
      shaders/shader.vert
  2. 1
      src/main.cpp
  3. 144
      src/vulkan/application.cpp
  4. 12
      src/vulkan/application.hpp
  5. 22
      src/vulkan/buffer.cpp
  6. 15
      src/vulkan/buffer.hpp
  7. 76
      src/vulkan/pipeline.cpp
  8. 22
      src/vulkan/pipeline.hpp
  9. 24
      src/vulkan/vertex.cpp
  10. 25
      src/vulkan/vertex.hpp

8
shaders/shader.vert
Unescape View File

@ -5,13 +5,7 @@ layout (location = 1) in vec3 inColor;
layout (location = 0) out vec3 fragColor; layout (location = 0) out vec3 fragColor;
layout (binding = 0) uniform UniformBufferObject {
mat4 model;
mat4 view;
mat4 projection;
} ubo;
void main() { void main() {
gl_Position = ubo.projection * ubo.view * ubo.model * vec4(inPosition, 0.0, 1.0); gl_Position = vec4(inPosition, 0.0, 1.0);
fragColor = inColor; fragColor = inColor;
} }

1
src/main.cpp
Unescape View File

@ -4,5 +4,4 @@
int main() { int main() {
Application application; Application application;
application.mainLoop();
} }

144
src/vulkan/application.cpp
Unescape View File

@ -9,95 +9,24 @@ Application::Application() {
instance = new Instance; instance = new Instance;
swapchain = new Swapchain(instance); swapchain = new Swapchain(instance);
pipeline = new Pipeline(instance, swapchain->renderPass); pipeline = new Pipeline(instance, swapchain->renderPass);
auto stagedVertexBuffer = Buffer::createStagedVertexBuffer(instance); stagingBuffer = Buffer::createStagingBuffer(instance);
vertexBuffer = new Buffer(instance, stagedVertexBuffer->size, vertexBuffer = new Buffer(instance, stagingBuffer->size,
VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
auto stagedIndexBuffer = Buffer::createStagedIndexBuffer(instance);
indexBuffer = new Buffer(instance, stagedIndexBuffer->size,
VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
VkDeviceSize bufferSize = sizeof(UniformBufferObject);
uniformBuffer = new Buffer(instance, bufferSize,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkMapMemory(instance->device, uniformBuffer->memory, 0, bufferSize, 0, &uniformBufferMapped);
pipeline->createDescriptorSet(uniformBuffer);
commandPool = new CommandPool(instance); commandPool = new CommandPool(instance);
stagingBuffer->copyTo(vertexBuffer, commandPool);
stagedVertexBuffer->copyTo(vertexBuffer, commandPool);
stagedIndexBuffer->copyTo(indexBuffer, commandPool);
delete stagedVertexBuffer;
delete stagedIndexBuffer;
createSyncObjects(); createSyncObjects();
}
void Application::updateUniformBuffer() {
static float elapsed = 0;
elapsed += 0.007;
UniformBufferObject ubo {}; mainLoop();
ubo.model = glm::rotate(glm::mat4(1), elapsed * glm::radians(90.f), glm::vec3(0, 0, 1));
ubo.view = glm::lookAt(glm::vec3(2), glm::vec3(0), glm::vec3(0, 0, 1));
ubo.projection = glm::perspective(glm::radians(45.f),
static_cast<float>(swapchain->extent.width) / static_cast<float>(swapchain->extent.height),
0.1f, 10.f);
ubo.projection[1][1] *= -1;
memcpy(uniformBufferMapped, &ubo, sizeof(UniformBufferObject));
} }
void Application::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) { void Application::mainLoop() {
VkCommandBufferBeginInfo beginInfo {}; while (!glfwWindowShouldClose(instance->window)){
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; glfwPollEvents();
drawFrame();
vkBeginCommandBuffer(commandBuffer, &beginInfo); }
vkDeviceWaitIdle(instance->device);
VkRenderPassBeginInfo renderPassInfo {};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = swapchain->renderPass;
renderPassInfo.framebuffer = swapchain->frameBuffers[imageIndex];
renderPassInfo.renderArea.offset = {0, 0};
renderPassInfo.renderArea.extent = swapchain->extent;
VkClearValue clearColor = {{{0, 0, 0, 1}}};
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->handle);
VkViewport viewport {};
viewport.x = 0;
viewport.y = 0;
viewport.width = static_cast<float>(swapchain->extent.width);
viewport.height = static_cast<float>(swapchain->extent.height);
viewport.minDepth = 0;
viewport.maxDepth = 1;
vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
VkRect2D scissor {};
scissor.offset = {0, 0};
scissor.extent = swapchain->extent;
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
VkBuffer buffers[] = {vertexBuffer->handle};
VkDeviceSize offsets[] = {0};
vkCmdBindVertexBuffers(commandBuffer, 0, 1, buffers, offsets);
vkCmdBindIndexBuffer(commandBuffer, indexBuffer->handle, 0, VK_INDEX_TYPE_UINT32);
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->layout, 0, 1, &pipeline->descriptorSet, 0, nullptr);
vkCmdDrawIndexed(commandBuffer, indices.size(), 1, 0, 0, 0);
vkCmdEndRenderPass(commandBuffer);
vkEndCommandBuffer(commandBuffer);
} }
void Application::drawFrame() { void Application::drawFrame() {
@ -115,8 +44,6 @@ void Application::drawFrame() {
vkResetCommandBuffer(commandPool->buffers[currentFrame], 0); vkResetCommandBuffer(commandPool->buffers[currentFrame], 0);
recordCommandBuffer(commandPool->buffers[currentFrame], imageIndex); recordCommandBuffer(commandPool->buffers[currentFrame], imageIndex);
updateUniformBuffer();
VkSubmitInfo submitInfo {}; VkSubmitInfo submitInfo {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@ -172,12 +99,48 @@ void Application::createSyncObjects() {
} }
} }
void Application::mainLoop() { void Application::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
while (!glfwWindowShouldClose(instance->window)){ VkCommandBufferBeginInfo beginInfo {};
glfwPollEvents(); beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
drawFrame();
} vkBeginCommandBuffer(commandBuffer, &beginInfo);
vkDeviceWaitIdle(instance->device);
VkRenderPassBeginInfo renderPassInfo {};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassInfo.renderPass = swapchain->renderPass;
renderPassInfo.framebuffer = swapchain->frameBuffers[imageIndex];
renderPassInfo.renderArea.offset = {0, 0};
renderPassInfo.renderArea.extent = swapchain->extent;
VkClearValue clearColor = {{{0, 0, 0, 1}}};
renderPassInfo.clearValueCount = 1;
renderPassInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->graphicsPipeline);
VkViewport viewport {};
viewport.x = 0;
viewport.y = 0;
viewport.width = static_cast<float>(swapchain->extent.width);
viewport.height = static_cast<float>(swapchain->extent.height);
viewport.minDepth = 0;
viewport.maxDepth = 1;
vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
VkRect2D scissor {};
scissor.offset = {0, 0};
scissor.extent = swapchain->extent;
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
VkBuffer buffers[] = {vertexBuffer->handle};
VkDeviceSize offsets[] = {0};
vkCmdBindVertexBuffers(commandBuffer, 0, 1, buffers, offsets);
vkCmdDraw(commandBuffer, 3, 1, 0, 0);
vkCmdEndRenderPass(commandBuffer);
vkEndCommandBuffer(commandBuffer);
} }
Application::~Application() { Application::~Application() {
@ -188,9 +151,8 @@ Application::~Application() {
vkDestroyFence(instance->device, inFlightFences[i], nullptr); vkDestroyFence(instance->device, inFlightFences[i], nullptr);
} }
delete commandPool; delete commandPool;
delete stagingBuffer;
delete vertexBuffer; delete vertexBuffer;
delete indexBuffer;
delete uniformBuffer;
delete pipeline; delete pipeline;
delete instance; delete instance;
} }

12
src/vulkan/application.hpp
Unescape View File

@ -22,7 +22,7 @@ class Pipeline;
class Buffer; class Buffer;
class CommandPool; class CommandPool;
constexpr int MAX_FRAMES_IN_FLIGHT = 1; constexpr int MAX_FRAMES_IN_FLIGHT = 2;
class Timer { class Timer {
public: public:
@ -40,21 +40,15 @@ private:
class Application { class Application {
public: public:
explicit Application(); explicit Application();
void mainLoop();
~Application(); ~Application();
private: private:
Instance* instance = nullptr; Instance* instance = nullptr;
Swapchain* swapchain = nullptr; Swapchain* swapchain = nullptr;
Pipeline* pipeline = nullptr; Pipeline* pipeline = nullptr;
Buffer* stagingBuffer = nullptr;
Buffer* vertexBuffer = nullptr; Buffer* vertexBuffer = nullptr;
Buffer* indexBuffer = nullptr;
Buffer* uniformBuffer = nullptr;
CommandPool* commandPool = nullptr; CommandPool* commandPool = nullptr;
void* uniformBufferMapped = nullptr;
void updateUniformBuffer();
void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex); void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex);
std::vector<VkSemaphore> imageAvailableSemaphores; std::vector<VkSemaphore> imageAvailableSemaphores;
@ -65,4 +59,6 @@ private:
void drawFrame(); void drawFrame();
void createSyncObjects(); void createSyncObjects();
void mainLoop();
}; };

22
src/vulkan/buffer.cpp
Unescape View File

@ -5,6 +5,12 @@
#include "instance.hpp" #include "instance.hpp"
#include "command_pool.hpp" #include "command_pool.hpp"
const std::vector<Vertex> vertices = {
{{0.0, -0.5}, {1, 0, 0}},
{{0.5, 0.5}, {0, 1, 0}},
{{-0.5, 0.5}, {0, 0, 1}}
};
Buffer::Buffer(Instance* instance, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties) : instance(instance), size(size){ Buffer::Buffer(Instance* instance, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties) : instance(instance), size(size){
VkBufferCreateInfo bufferInfo{}; VkBufferCreateInfo bufferInfo{};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@ -45,7 +51,7 @@ Buffer::~Buffer() {
vkDestroyBuffer(instance->device, handle, nullptr); vkDestroyBuffer(instance->device, handle, nullptr);
} }
Buffer* Buffer::createStagedVertexBuffer(Instance* instance) { Buffer* Buffer::createStagingBuffer(Instance* instance) {
VkDeviceSize size = vertices.size() * sizeof(Vertex); VkDeviceSize size = vertices.size() * sizeof(Vertex);
VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
VkMemoryPropertyFlags properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; VkMemoryPropertyFlags properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
@ -60,20 +66,6 @@ Buffer* Buffer::createStagedVertexBuffer(Instance* instance) {
return stagingBuffer; return stagingBuffer;
} }
Buffer *Buffer::createStagedIndexBuffer(Instance *instance) {
VkDeviceSize size = indices.size() * sizeof(uint32_t);
VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
VkMemoryPropertyFlags properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
auto stagingBuffer = new Buffer(instance, size, usage, properties);
uint32_t *data;
vkMapMemory(instance->device, stagingBuffer->memory, 0, size, 0, reinterpret_cast<void**>(&data));
memcpy(data, indices.data(), sizeof(uint32_t) * indices.size());
vkUnmapMemory(instance->device, stagingBuffer->memory);
return stagingBuffer;
}
void Buffer::copyTo(Buffer *dst, CommandPool* commandPool) { void Buffer::copyTo(Buffer *dst, CommandPool* commandPool) {
VkCommandBufferAllocateInfo allocateInfo {}; VkCommandBufferAllocateInfo allocateInfo {};
allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;

15
src/vulkan/buffer.hpp
Unescape View File

@ -2,18 +2,6 @@
#include <vulkan/vulkan_core.h> #include <vulkan/vulkan_core.h>
#include <stdexcept> #include <stdexcept>
#include "vertex.hpp"
const std::vector<Vertex> vertices = {
{{0.0, -0.5}, {1, 0, 0}},
{{0.5, 0.5}, {0, 1, 0}},
{{-0.5, 0.5}, {0, 0, 1}},
{{0.8, -0.5}, {1, 1, 1}}
};
const std::vector<uint32_t> indices = {
0, 1, 2, 0, 3, 1
};
class Instance; class Instance;
class CommandPool; class CommandPool;
@ -26,8 +14,7 @@ public:
VkDeviceMemory memory = VK_NULL_HANDLE; VkDeviceMemory memory = VK_NULL_HANDLE;
VkDeviceSize size; VkDeviceSize size;
static Buffer* createStagedVertexBuffer(Instance* instance); static Buffer* createStagingBuffer(Instance* instance);
static Buffer* createStagedIndexBuffer(Instance* instance);
void copyTo(Buffer* dst, CommandPool* commandPool); void copyTo(Buffer* dst, CommandPool* commandPool);

76
src/vulkan/pipeline.cpp
Unescape View File

@ -3,7 +3,6 @@
#include "pipeline.hpp" #include "pipeline.hpp"
#include "vertex.hpp" #include "vertex.hpp"
#include "instance.hpp" #include "instance.hpp"
#include "buffer.hpp"
std::vector<char> readFile(const std::string& fileName){ std::vector<char> readFile(const std::string& fileName){
std::ifstream file(fileName, std::ios::ate | std::ios::binary); std::ifstream file(fileName, std::ios::ate | std::ios::binary);
@ -23,9 +22,6 @@ std::vector<char> readFile(const std::string& fileName){
} }
Pipeline::Pipeline(Instance* instance, VkRenderPass renderPass) : instance(instance) { Pipeline::Pipeline(Instance* instance, VkRenderPass renderPass) : instance(instance) {
createDescriptorSetLayout();
createDescriptorPool();
auto vertShaderCode = readFile("shaders/vert.spv"); auto vertShaderCode = readFile("shaders/vert.spv");
auto fragShaderCode = readFile("shaders/frag.spv"); auto fragShaderCode = readFile("shaders/frag.spv");
@ -84,7 +80,7 @@ Pipeline::Pipeline(Instance* instance, VkRenderPass renderPass) : instance(insta
rasterizer.polygonMode = VK_POLYGON_MODE_FILL; rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
rasterizer.lineWidth = 1; rasterizer.lineWidth = 1;
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT; rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
rasterizer.depthBiasClamp = VK_FALSE; rasterizer.depthBiasClamp = VK_FALSE;
VkPipelineMultisampleStateCreateInfo multisample {}; VkPipelineMultisampleStateCreateInfo multisample {};
@ -104,10 +100,8 @@ Pipeline::Pipeline(Instance* instance, VkRenderPass renderPass) : instance(insta
VkPipelineLayoutCreateInfo pipelineLayoutInfo {}; VkPipelineLayoutCreateInfo pipelineLayoutInfo {};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.setLayoutCount = 1;
pipelineLayoutInfo.pSetLayouts = &descriptorSetLayout;
vkCreatePipelineLayout(instance->device, &pipelineLayoutInfo, nullptr, &layout); vkCreatePipelineLayout(instance->device, &pipelineLayoutInfo, nullptr, &pipelineLayout);
VkGraphicsPipelineCreateInfo pipelineInfo {}; VkGraphicsPipelineCreateInfo pipelineInfo {};
{ {
@ -124,13 +118,13 @@ Pipeline::Pipeline(Instance* instance, VkRenderPass renderPass) : instance(insta
pipelineInfo.pColorBlendState = &colorBlending; pipelineInfo.pColorBlendState = &colorBlending;
pipelineInfo.pDynamicState = &dynamicState; pipelineInfo.pDynamicState = &dynamicState;
pipelineInfo.layout = layout; pipelineInfo.layout = pipelineLayout;
pipelineInfo.renderPass = renderPass; pipelineInfo.renderPass = renderPass;
pipelineInfo.subpass = 0; pipelineInfo.subpass = 0;
} }
vkCreateGraphicsPipelines(instance->device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &handle); vkCreateGraphicsPipelines(instance->device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline);
vkDestroyShaderModule(instance->device, vertShaderModule, nullptr); vkDestroyShaderModule(instance->device, vertShaderModule, nullptr);
vkDestroyShaderModule(instance->device, fragShaderModule, nullptr); vkDestroyShaderModule(instance->device, fragShaderModule, nullptr);
@ -148,65 +142,9 @@ VkShaderModule Pipeline::createShaderModule(const std::vector<char> &code) {
return shaderModule; return shaderModule;
} }
Pipeline::~Pipeline() {
vkDestroyDescriptorPool(instance->device, descriptorPool, nullptr);
vkDestroyDescriptorSetLayout(instance->device, descriptorSetLayout, nullptr);
vkDestroyPipeline(instance->device, handle, nullptr);
vkDestroyPipelineLayout(instance->device, layout, nullptr);
}
void Pipeline::createDescriptorSetLayout() {
VkDescriptorSetLayoutBinding uboLayoutBinding {};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
VkDescriptorSetLayoutCreateInfo layoutCreateInfo {};
layoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutCreateInfo.bindingCount = 1;
layoutCreateInfo.pBindings = &uboLayoutBinding;
vkCreateDescriptorSetLayout(instance->device, &layoutCreateInfo, nullptr, &descriptorSetLayout);
}
void Pipeline::createDescriptorPool() {
VkDescriptorPoolSize poolSize {};
poolSize.descriptorCount = 1;
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
VkDescriptorPoolCreateInfo poolInfo {};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.pPoolSizes = &poolSize;
poolInfo.poolSizeCount = 1;
poolInfo.maxSets = 1;
vkCreateDescriptorPool(instance->device, &poolInfo, nullptr, &descriptorPool); Pipeline::~Pipeline() {
} vkDestroyPipeline(instance->device, graphicsPipeline, nullptr);
vkDestroyPipelineLayout(instance->device, pipelineLayout, nullptr);
void Pipeline::createDescriptorSet(Buffer *buffer) {
VkDescriptorSetAllocateInfo allocateInfo {};
allocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocateInfo.descriptorPool = descriptorPool;
allocateInfo.descriptorSetCount = 1;
allocateInfo.pSetLayouts = &descriptorSetLayout;
vkAllocateDescriptorSets(instance->device, &allocateInfo, &descriptorSet);
VkDescriptorBufferInfo bufferInfo {};
bufferInfo.buffer = buffer->handle;
bufferInfo.offset = 0;
bufferInfo.range = sizeof(UniformBufferObject);
VkWriteDescriptorSet descriptorWrite {};
descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorWrite.dstSet = descriptorSet;
descriptorWrite.dstBinding = 0;
descriptorWrite.dstArrayElement = 0;
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptorWrite.descriptorCount = 1;
descriptorWrite.pBufferInfo = &bufferInfo;
vkUpdateDescriptorSets(instance->device, 1, &descriptorWrite, 0, nullptr);
} }

22
src/vulkan/pipeline.hpp
Unescape View File

@ -1,34 +1,16 @@
#pragma once #pragma once
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <glm/gtc/matrix_transform.hpp>
class Instance; class Instance;
class Buffer;
struct UniformBufferObject {
alignas(16) glm::mat4 model;
glm::mat4 view;
glm::mat4 projection;
};
class Pipeline { class Pipeline {
public: public:
explicit Pipeline(Instance* instance, VkRenderPass renderPass); explicit Pipeline(Instance* instance, VkRenderPass renderPass);
~Pipeline(); ~Pipeline();
VkPipeline handle = VK_NULL_HANDLE; VkPipeline graphicsPipeline = VK_NULL_HANDLE;
VkPipelineLayout layout = VK_NULL_HANDLE;
VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
void createDescriptorSet(Buffer* buffer);
private: private:
VkShaderModule createShaderModule(const std::vector<char> &code); VkShaderModule createShaderModule(const std::vector<char> &code);
VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
Instance* instance = nullptr; Instance* instance = nullptr;
void createDescriptorSetLayout();
void createDescriptorPool();
}; };

24
src/vulkan/vertex.cpp
Unescape View File

@ -1,25 +1 @@
#include "vertex.hpp" #include "vertex.hpp"
VkVertexInputBindingDescription Vertex::getBindingDescription() {
VkVertexInputBindingDescription bindingDescription {};
bindingDescription.binding = 0;
bindingDescription.stride = sizeof(Vertex);
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return bindingDescription;
}
std::array<VkVertexInputAttributeDescription, 2> Vertex::getAttributeDescriptions() {
std::array<VkVertexInputAttributeDescription, 2> attributeDescriptions {};
attributeDescriptions[0].binding = 0;
attributeDescriptions[0].location = 0;
attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
attributeDescriptions[0].offset = offsetof(Vertex, pos);
attributeDescriptions[1].binding = 0;
attributeDescriptions[1].location = 1;
attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
attributeDescriptions[1].offset = offsetof(Vertex, color);
return attributeDescriptions;
}

25
src/vulkan/vertex.hpp
Unescape View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include <array> #include <array>
@ -9,7 +8,27 @@ struct Vertex {
glm::vec2 pos; glm::vec2 pos;
glm::vec3 color; glm::vec3 color;
static VkVertexInputBindingDescription getBindingDescription(); static VkVertexInputBindingDescription getBindingDescription(){
VkVertexInputBindingDescription bindingDescription {};
bindingDescription.binding = 0;
bindingDescription.stride = sizeof(Vertex);
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return bindingDescription;
}
static std::array<VkVertexInputAttributeDescription, 2> getAttributeDescriptions(); static std::array<VkVertexInputAttributeDescription, 2> getAttributeDescriptions(){
std::array<VkVertexInputAttributeDescription, 2> attributeDescriptions {};
attributeDescriptions[0].binding = 0;
attributeDescriptions[0].location = 0;
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
attributeDescriptions[0].offset = offsetof(Vertex, pos);
attributeDescriptions[1].binding = 0;
attributeDescriptions[1].location = 1;
attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
attributeDescriptions[1].offset = offsetof(Vertex, color);
return attributeDescriptions;
}
}; };
Write Preview
Loading…
Cancel
Save