module;

#include <vulkan/vulkan.h>

#include <span>

#include <array>

export module vk:vertex_buffer;

export import :types;

export import :utilities;

export import :command_buffer;

export import :buffer_streams;

export namespace vk {

inline namespace v1 {

/**

* @brief vulkan implementation for loading in vertices to a vulkan buffer handle

*

* This implementation automates handle in loading the vertices and its memories for it

*/

class vertex_buffer {

public:

vertex_buffer() = default;

vertex_buffer(const VkDevice& p_device,

const vertex_params& p_vertex_info) : m_device(p_device) {

m_size = p_vertex_info.vertices.size();

m_size_bytes = p_vertex_info.vertices.size_bytes();

VkBufferUsageFlags usage =

VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;

// 1. creating staging buffer

uint32_t property_flags =

memory_property::host_visible_bit | memory_property::host_cached_bit;

buffer_parameters new_staging_buffer_settings = {

.device_size = m_size_bytes,

.physical_memory_properties =

p_vertex_info.phsyical_memory_properties,

.property_flags = (memory_property)property_flags,

.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT |

VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,

.debug_name = p_vertex_info.debug_name.c_str(),

.vkSetDebugUtilsObjectNameEXT = p_vertex_info.vkSetDebugUtilsObjectNameEXT

};

buffer_stream staging_buffer(m_device, new_staging_buffer_settings);

std::span<const vertex_input> vertices = p_vertex_info.vertices;

staging_buffer.write(vertices);

// 3.) Now creating our actual vertex buffer handler

buffer_parameters vertex_params = {

.device_size = m_size_bytes,

.physical_memory_properties =

p_vertex_info.phsyical_memory_properties,

.property_flags = memory_property::device_local_bit,

.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT |

VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,

};

m_vertex_handler = buffer_stream(m_device, vertex_params);

// 4. Copy data from staging buffer to the actual vertex buffer itself!

buffer_copy_info info = { .src = staging_buffer,

.dst = m_vertex_handler };

// copy(m_device, info, m_size_bytes);

// 1. Retrieve the first queue

// TODO: Use vk::device_queue for this

VkQueue temp_graphics_queue = nullptr;

uint32_t queue_family_index = 0;

uint32_t queue_index = 0;

vkGetDeviceQueue(

p_device, queue_family_index, queue_index, &temp_graphics_queue);

// command_buffer_info

command_params enumerate_command_info = {

.levels = command_levels::primary,

.queue_index = 0,

};

command_buffer copy_command_buffer(p_device, enumerate_command_info);

copy_command_buffer.begin(command_usage::one_time_submit);

// VkBufferCopy copy_region{};

// copy_region.size = (VkDeviceSize)m_size_bytes;

// vkCmdCopyBuffer(

// copy_command_buffer, staging_buffer, m_vertex_handler, 1, &copy_region);

copy_command_buffer.copy_buffer(staging_buffer, m_vertex_handler, m_size_bytes);

copy_command_buffer.end();

VkCommandBuffer temp = copy_command_buffer;

VkSubmitInfo submit_info{};

submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

submit_info.commandBufferCount = 1;

submit_info.pCommandBuffers = &temp;

vkQueueSubmit(temp_graphics_queue, 1, &submit_info, nullptr);

vkQueueWaitIdle(temp_graphics_queue);

// vkFreeCommandBuffers(, command_pool, 1, &copy_cmd_buffer);

// vkDestroyCommandPool(driver, command_pool, nullptr);

copy_command_buffer.destroy();

// 5. cleanup staging buffer -- no longer used

staging_buffer.destroy();

}

[[nodiscard]] uint32_t size_bytes() const { return m_size_bytes; }

[[nodiscard]] uint32_t size() const { return m_size; }

[[nodiscard]] bool alive() const { return m_vertex_handler; }

void bind(const VkCommandBuffer& p_current) {

std::array<VkBuffer, 1> handlers = { m_vertex_handler };

VkDeviceSize offsets[] = { 0 };

vkCmdBindVertexBuffers(p_current, 0, 1, handlers.data(), offsets);

}

operator VkBuffer() const { return m_vertex_handler; }

operator VkBuffer() { return m_vertex_handler; }

void destroy() {

m_vertex_handler.destroy();

}

private:

VkDevice m_device = nullptr;

uint32_t m_size_bytes = 0;

uint32_t m_size = 0;

buffer_stream m_vertex_handler;

};

};

};