everyonecancode/RedScarfEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Enable multiple buffers

Browse Source 
Enables creation of multiple mesh objects in a single buffer. This is
still WIP.
This commit is contained in:
Piotr Krygier committed 2023-04-04 14:56:31 +02:00
1 parent c4734e99c2
commit e06288320d
6 files changed
+188 -123
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

graphics/src/vulkan_buffers.cpp
+141 -101
View File
@@ -14,6 +14,7 @@
namespace rse::graphics::vulkanbase
{
#define MAX_VERTEX_BUFFER_SIZE 33554432 /* 32 MB*/
using namespace locale::vulkan;
@@ -27,9 +28,9 @@ using namespace locale::vulkan;
// std::vector<uint16_t> indices = {0, 1, 2, 2, 3, 0};
/* GPU visible buffer */
Buffer gVertexBuffer = {};
Buffer gIndexBuffer = {};
Buffer gInstancesBuffer = {};
std::vector<Buffer> gVertexBuffers = {};
std::vector<Buffer> gIndexBuffers = {};
std::vector<Buffer> gInstanceBuffers = {};
/* CPU visible buffer. TODO: Do we need this global? */
VkCommandPool gCommandPool = VK_NULL_HANDLE;
@@ -37,8 +38,7 @@ VkCommandPool gCommandPool = VK_NULL_HANDLE;
static uint8_t createBuffer(VulkanState& vulkan_state, const VkDeviceSize size, VkBufferUsageFlags bufferUsage, VmaMemoryUsage memoryUsage,
const VmaAllocationCreateFlags allocationFlags, Buffer& buffer);
static uint8_t copyBuffer(VulkanState& vulkan_state, VkBuffer src, VkBuffer dst, VkDeviceSize size);
static uint8_t copyBuffer(VulkanState& vulkan_state, VkBuffer src, VkBuffer dst, VkDeviceSize size, VkDeviceSize dest_offset = 0);
static uint8_t createCommandPools(VulkanState& vulkan_state);
static uint8_t createVertexBuffer(VulkanState& vulkan_state);
@@ -99,7 +99,7 @@ uint8_t createBuffer(VulkanState& vulkan_state, const VkDeviceSize size, VkBuffe
* @param size Size of buffer to copy
* @return uint8_t VULKAN_ERROR_NO_ERROR on success. Possible errors:
*/
uint8_t copyBuffer(VulkanState& vulkan_state, VkBuffer src, VkBuffer dst, VkDeviceSize size)
uint8_t copyBuffer(VulkanState& vulkan_state, VkBuffer src, VkBuffer dst, VkDeviceSize size, VkDeviceSize dest_offset)
{
/* Vulkan buffers can only be copied using command buffers */
VkBufferCopy copyRegion;
@@ -120,7 +120,7 @@ uint8_t copyBuffer(VulkanState& vulkan_state, VkBuffer src, VkBuffer dst, VkDevi
beginInfo.pInheritanceInfo = nullptr;
copyRegion.srcOffset = 0;
copyRegion.dstOffset = 0;
copyRegion.dstOffset = dest_offset;
copyRegion.size = size;
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
@@ -134,15 +134,19 @@ uint8_t copyBuffer(VulkanState& vulkan_state, VkBuffer src, VkBuffer dst, VkDevi
submitInfo.pSignalSemaphores = nullptr;
// FIXME: At result checks
vkAllocateCommandBuffers(vulkan_state.device, &allocInfo, &copyCommandBuffer);
vkBeginCommandBuffer(copyCommandBuffer, &beginInfo);
VkResult status;
status = vkAllocateCommandBuffers(vulkan_state.device, &allocInfo, &copyCommandBuffer);
status = vkBeginCommandBuffer(copyCommandBuffer, &beginInfo);
vkCmdCopyBuffer(copyCommandBuffer, src, dst, 1, &copyRegion);
vkEndCommandBuffer(copyCommandBuffer);
vkQueueSubmit(vulkan_state.graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
status = vkEndCommandBuffer(copyCommandBuffer);
status = vkQueueSubmit(vulkan_state.graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
/* TODO: Use fences to wait instead of idle */
vkQueueWaitIdle(vulkan_state.graphicsQueue);
status = vkQueueWaitIdle(vulkan_state.graphicsQueue);
vkFreeCommandBuffers(vulkan_state.device, gCommandPool, 1, &copyCommandBuffer);
if (status != VK_SUCCESS) {
return VULKAN_ERROR_NO_ERROR;
}
return VULKAN_ERROR_NO_ERROR;
}
@@ -181,41 +185,21 @@ uint8_t createCommandPools(VulkanState& vulkan_state)
*/
uint8_t createVertexBuffer(VulkanState& vulkan_state)
{
void* mappedData;
VkDeviceSize bufferSize;
Buffer staging_buffer;
Buffer vertex_buffer;
auto vertices = rse::graphics::mesh::get_mesh_vertices(0);
bufferSize = sizeof(vertices[0]) * vertices.size();
/* Creating staging buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state, bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT, staging_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
bufferSize = MAX_VERTEX_BUFFER_SIZE;
/* Create Vertex Buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state, bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE, 0, /* Will not be mapped with vmaMapMemory */
gVertexBuffer)) {
vertex_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
/* Fill staging buffer */
if (VK_SUCCESS != vmaMapMemory(vulkan_state.allocator, staging_buffer.allocation, &mappedData)) {
LOGF << vulkanErrorMesssages[VULKAN_VERTEX_BUFFER_MAPPING_FAILED];
return VULKAN_ERROR_VERTEX_BUFFER_MAPPING_FAILED;
}
memcpy(mappedData, vertices.data(), sizeof(Vertex) * vertices.size());
vmaUnmapMemory(vulkan_state.allocator, staging_buffer.allocation);
copyBuffer(vulkan_state, staging_buffer.buffer, gVertexBuffer.buffer, bufferSize);
vmaDestroyBuffer(vulkan_state.allocator, staging_buffer.buffer, staging_buffer.allocation);
vertex_buffer.allocated_size = 0;
gVertexBuffers.push_back(std::move(vertex_buffer));
return VULKAN_ERROR_NO_ERROR;
}
@@ -227,79 +211,43 @@ uint8_t createVertexBuffer(VulkanState& vulkan_state)
*/
uint8_t createIndexBuffer(VulkanState& vulkan_state)
{
void* mappedData;
VkDeviceSize bufferSize;
Buffer staging_buffer;
Buffer index_buffer;
auto indices = rse::graphics::mesh::get_mesh_indices(0);
bufferSize = MAX_VERTEX_BUFFER_SIZE;
bufferSize = sizeof(indices[0]) * indices.size();
/* Creating staging buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state, bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT, staging_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
/* Create Vertex Buffer*/
/* Create Index Buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state, bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE, 0, /* Will not be mapped with vmaMapMemory */
gIndexBuffer)) {
index_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
/* Fill staging buffer */
if (VK_SUCCESS != vmaMapMemory(vulkan_state.allocator, staging_buffer.allocation, &mappedData)) {
LOGF << vulkanErrorMesssages[VULKAN_VERTEX_BUFFER_MAPPING_FAILED];
return VULKAN_ERROR_VERTEX_BUFFER_MAPPING_FAILED;
}
memcpy(mappedData, indices.data(), static_cast<size_t>(bufferSize));
vmaUnmapMemory(vulkan_state.allocator, staging_buffer.allocation);
copyBuffer(vulkan_state, staging_buffer.buffer, gIndexBuffer.buffer, bufferSize);
vmaDestroyBuffer(vulkan_state.allocator, staging_buffer.buffer, staging_buffer.allocation);
index_buffer.allocated_size = 0;
gIndexBuffers.push_back(std::move(index_buffer));
return VULKAN_ERROR_NO_ERROR;
}
uint8_t createInstancesBuffer(VulkanState& vulkan_state)
uint8_t createInstanceBuffer(VulkanState& vulkan_state)
{
void* mappedData;
VkDeviceSize bufferSize;
Buffer staging_buffer;
Buffer instance_buffer;
auto instances = rse::graphics::mesh::get_instance_data_for_mesh(0);
bufferSize = sizeof(instances[0]) * instances.size();
bufferSize = MAX_VERTEX_BUFFER_SIZE;
/* Creating staging buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state, bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT, staging_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
/* Create Vertex Buffer*/
/* Create Instance Buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state, bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE, 0, /* Will not be mapped with vmaMapMemory */
gInstancesBuffer)) {
instance_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
/* Fill staging buffer */
if (VK_SUCCESS != vmaMapMemory(vulkan_state.allocator, staging_buffer.allocation, &mappedData)) {
LOGF << vulkanErrorMesssages[VULKAN_VERTEX_BUFFER_MAPPING_FAILED];
return VULKAN_ERROR_VERTEX_BUFFER_MAPPING_FAILED;
}
memcpy(mappedData, instances.data(), static_cast<size_t>(bufferSize));
vmaUnmapMemory(vulkan_state.allocator, staging_buffer.allocation);
copyBuffer(vulkan_state, staging_buffer.buffer, gInstancesBuffer.buffer, bufferSize);
vmaDestroyBuffer(vulkan_state.allocator, staging_buffer.buffer, staging_buffer.allocation);
instance_buffer.allocated_size = 0;
gInstanceBuffers.push_back(std::move(instance_buffer));
return VULKAN_ERROR_NO_ERROR;
}
@@ -342,7 +290,9 @@ uint8_t allocateCommandBuffers(VulkanState& vulkan_state)
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; /* TODO: When needed, add secondary command buffer */
allocateInfo.commandBufferCount = SWAP_BUFFER_COUNT;
if (VK_SUCCESS != vkAllocateCommandBuffers(vulkan_state.device, &allocateInfo, vulkan_state.pCommandBuffers.data())) {
if (VK_SUCCESS != vkAllocateCommandBuffers(vulkan_state.device,
&allocateInfo,
vulkan_state.pCommandBuffers.data())) {
LOGF << vulkanErrorMesssages[VULKAN_COMMAND_BUFFER_ALLOCATION_FAILED];
return VULKAN_ERROR_COMMAND_BUFFER_ALLOCATION_FAILED;
}
@@ -360,12 +310,95 @@ void updateUniformBuffer(VulkanState& vulkan_state)
// ubo.model = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f, 0.0f, 0.0f)) * glm::rotate(glm::mat4(1.0f), glm::radians(45.0f), glm::vec3(0.0f, 0.0f, 1.0f)) * glm::scale(glm::mat4(1.0f), glm::vec3(2, 1, 1));
ubo.model = glm::mat4(1.0f);
ubo.view = glm::lookAt(glm::vec3(0.0f, 0.0f, 5.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
ubo.proj =
glm::perspective(glm::radians(45.0f), vulkan_state.swapchainExtent.width / (float)vulkan_state.swapchainExtent.height, 0.1f, 20.0f);
ubo.proj = glm::perspective(glm::radians(45.0f),
vulkan_state.swapchainExtent.width / (float)vulkan_state.swapchainExtent.height,
0.1f,
20.0f);
ubo.proj[1][1] *= -1; /* GLM was developed for OpenGL, where Y coordinate of the clip is inverted */
memcpy(vulkan_state.uniformBuffers[vulkan_state.currentFrame].allocationInfo.pMappedData, &ubo, sizeof(ubo));
}
uint8_t update_mesh_buffers(VulkanState& vulkan_state,
const std::vector<rse::graphics::vulkanbase::Vertex>& vertices,
const std::vector<uint16_t>& indices)
{
// void* mapped_data;
Buffer staging_buffer;
auto vertices_size = sizeof(vertices[0]) * vertices.size();
auto indices_size = sizeof(indices[0]) * indices.size();
auto last_vertex_buffer = &gVertexBuffers[gVertexBuffers.size() - 1];
auto last_index_buffer = &gIndexBuffers[gIndexBuffers.size() - 1];
/* Creating staging buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state,
MAX_VERTEX_BUFFER_SIZE,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
VMA_ALLOCATION_CREATE_MAPPED_BIT
| VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
staging_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
/* Fill staging buffer with vertex data */
memset(staging_buffer.allocationInfo.pMappedData, 0, MAX_VERTEX_BUFFER_SIZE);
memcpy(staging_buffer.allocationInfo.pMappedData, vertices.data(), vertices_size);
copyBuffer(vulkan_state,
staging_buffer.buffer,
last_vertex_buffer->buffer,
vertices_size,
last_vertex_buffer->allocated_size);
/* Fill staging buffer with index data */
memset(staging_buffer.allocationInfo.pMappedData, 0, MAX_VERTEX_BUFFER_SIZE);
memcpy(staging_buffer.allocationInfo.pMappedData, indices.data(), indices_size);
copyBuffer(vulkan_state,
staging_buffer.buffer,
last_index_buffer->buffer,
indices_size,
last_index_buffer->allocated_size);
vmaDestroyBuffer(vulkan_state.allocator, staging_buffer.buffer, staging_buffer.allocation);
return VULKAN_ERROR_NO_ERROR;
}
uint8_t update_mesh_instances(VulkanState& vulkan_state,
rse::graphics::mesh::InstanceData& instance_data)
{
Buffer staging_buffer;
auto last_instance_buffer = &gInstanceBuffers[gInstanceBuffers.size() - 1];
auto instance_size = sizeof(instance_data);
/* Creating staging buffer*/
if (VK_SUCCESS != createBuffer(vulkan_state,
MAX_VERTEX_BUFFER_SIZE,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
VMA_ALLOCATION_CREATE_MAPPED_BIT
| VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
staging_buffer)) {
LOGF << vulkanErrorMesssages[VULKAN_BUFFER_CREATION_FAILED];
return VULKAN_ERROR_BUFFER_CREATION_FAILED;
}
memcpy(staging_buffer.allocationInfo.pMappedData, &instance_data, instance_size);
copyBuffer(vulkan_state,
staging_buffer.buffer,
last_instance_buffer->buffer,
instance_size,
last_instance_buffer->allocated_size);
vmaDestroyBuffer(vulkan_state.allocator, staging_buffer.buffer, staging_buffer.allocation);
last_instance_buffer->allocated_size += instance_size;
return VULKAN_ERROR_NO_ERROR;
}
/**
* @brief Records commands for provided command buffer
*
@@ -382,8 +415,6 @@ uint8_t recordCommandBuffer(VulkanState& vulkan_state, uint32_t imageIndex)
VkRenderPassBeginInfo renderPassInfo{};
VkViewport viewport{};
VkRect2D scissor{};
VkBuffer vertexBuffers[] = {gVertexBuffer.buffer};
VkBuffer instanceBuffers[] = {gInstancesBuffer.buffer};
VkDeviceSize offsets[] = {0};
auto indices = rse::graphics::mesh::get_mesh_indices(0);
@@ -421,13 +452,20 @@ uint8_t recordCommandBuffer(VulkanState& vulkan_state, uint32_t imageIndex)
scissor.extent = vulkan_state.swapchainExtent;
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
vkCmdBindVertexBuffers(commandBuffer, 1, 1, instanceBuffers, offsets);
vkCmdBindIndexBuffer(commandBuffer, gIndexBuffer.buffer, 0, VK_INDEX_TYPE_UINT16);
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vulkan_state.pipelineLayout, 0, 1,
&vulkan_state.descriptorSets[vulkan_state.currentFrame], 0, nullptr);
for (size_t i = 0; i < gVertexBuffers.size(); ++i) {
VkBuffer vertexBuffers[] = {gVertexBuffers[i].buffer};
VkBuffer indexBuffer = {gIndexBuffers[i].buffer};
VkBuffer instanceBuffers[] = {gInstanceBuffers[i].buffer};
vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(indices.size()), instances.size(), 0, 0, 0);
/* TODO: Figure out the offset */
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
vkCmdBindVertexBuffers(commandBuffer, 1, 1, instanceBuffers, offsets);
vkCmdBindIndexBuffer(commandBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT16);
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vulkan_state.pipelineLayout, 0, 1,
&vulkan_state.descriptorSets[vulkan_state.currentFrame], 0, nullptr);
vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(indices.size()), instances.size(), 0, 0, 0);
}
vkCmdEndRenderPass(commandBuffer);
@@ -446,7 +484,7 @@ uint8_t create_buffers(VulkanState& vulkan_state)
STATUS_CHECK(createCommandPools(vulkan_state));
STATUS_CHECK(createVertexBuffer(vulkan_state));
STATUS_CHECK(createIndexBuffer(vulkan_state));
STATUS_CHECK(createInstancesBuffer(vulkan_state));
STATUS_CHECK(createInstanceBuffer(vulkan_state));
STATUS_CHECK(createUniformBuffers(vulkan_state));
STATUS_CHECK(allocateCommandBuffers(vulkan_state));
@@ -464,9 +502,11 @@ void destroy_buffers(VulkanState& vulkan_state)
vmaDestroyBuffer(vulkan_state.allocator, vulkan_state.uniformBuffers[i].buffer, vulkan_state.uniformBuffers[i].allocation);
}
vmaDestroyBuffer(vulkan_state.allocator, gVertexBuffer.buffer, gVertexBuffer.allocation);
vmaDestroyBuffer(vulkan_state.allocator, gIndexBuffer.buffer, gIndexBuffer.allocation);
vmaDestroyBuffer(vulkan_state.allocator, gInstancesBuffer.buffer, gInstancesBuffer.allocation);
for (size_t i = 0; i < gVertexBuffers.size(); ++i) {
vmaDestroyBuffer(vulkan_state.allocator, gVertexBuffers[i].buffer, gVertexBuffers[i].allocation);
vmaDestroyBuffer(vulkan_state.allocator, gIndexBuffers[i].buffer, gIndexBuffers[i].allocation);
vmaDestroyBuffer(vulkan_state.allocator, gInstanceBuffers[i].buffer, gInstanceBuffers[i].allocation);
}
vkDestroyCommandPool(vulkan_state.device, gCommandPool, nullptr);
}