buffer.c

#include <kiba/renderer/vulkan/buffer.h>
 
#include <kiba/renderer/vulkan/command_buffer.h>
 
b8 vulkan_buffer_create(vulkan_context       *context,
                        VkDeviceSize          size,
                        VkBufferUsageFlags    usage_flags,
                        VkMemoryPropertyFlags property_flags,
                        vulkan_buffer        *buffer) {
    VkBufferCreateInfo create_info = {
        .sType       = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size        = size,
        .usage       = usage_flags,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
    };
    VK_CALL_B8(
        vkCreateBuffer(context->device.logical, &create_info, &context->alloc.vulkan_callbacks, &buffer->buffer));
    VkMemoryRequirements memory_requirements;
    vkGetBufferMemoryRequirements(context->device.logical, buffer->buffer, &memory_requirements);
 
    // coherent flag is used to ensure data is actually copied when we say so, alternative:
    // call vkFlushMappedMemoryRanges before writing to mapped data
    // call vkInvalidateMappedMemoryRanges before reading to mapped data
    u32 type_index = vulkan_get_memory_type(context, memory_requirements.memoryTypeBits, property_flags);
    if (type_index == U32_MAX) {
        KB_ERROR("could not find memory type matching the buffers requirements");
        return false;
    }
    VkMemoryAllocateInfo alloc_info = {
        .sType           = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .allocationSize  = memory_requirements.size,
        .memoryTypeIndex = type_index,
    };
    VK_CALL_B8(
        vkAllocateMemory(context->device.logical, &alloc_info, &context->alloc.vulkan_callbacks, &buffer->memory));
    VK_CALL_B8(vkBindBufferMemory(context->device.logical, buffer->buffer, buffer->memory, 0));
    return true;
}
 
b8 vulkan_buffer_copy(vulkan_context *context, vulkan_buffer *src, vulkan_buffer *dst, VkDeviceSize size) {
    VkCommandBuffer command_buffer;
    if (!vulkan_command_buffer_start_single_time_command(context, &command_buffer)) {
        return false;
    }
    VkBufferCopy copy_info = {
        .srcOffset = 0,
        .dstOffset = 0,
        .size      = size,
    };
    vkCmdCopyBuffer(command_buffer, src->buffer, dst->buffer, 1, &copy_info);
 
    return vulkan_command_buffer_end_single_time_command(context, &command_buffer);
}
 
void vulkan_buffer_destroy(vulkan_context *context, vulkan_buffer *buffer) {
    vkDestroyBuffer(context->device.logical, buffer->buffer, &context->alloc.vulkan_callbacks);
    vkFreeMemory(context->device.logical, buffer->memory, &context->alloc.vulkan_callbacks);
}
 
u32 vulkan_get_memory_type(vulkan_context *context, u32 type_filter, VkMemoryPropertyFlags flags) {
    VkPhysicalDeviceMemoryProperties memory_properties;
    vkGetPhysicalDeviceMemoryProperties(context->device.physical, &memory_properties);
    for (u32 i = 0; i < memory_properties.memoryTypeCount; ++i) {
        if (type_filter & KB_UBIT(i) && KB_FLAGS_ALL_SET(memory_properties.memoryTypes[i].propertyFlags, flags)) {
            return i;
        }
    }
    return U32_MAX;
}