module;

#include <vulkan/vulkan.h>

#include <span>

#include <array>

#include <cstring>

export module vk:buffer_streams32;

export import :types;

export import :utilities;

export import :command_buffer;

export namespace vk {

inline namespace v1 {

/**

* @brief buffer stream for streaming arbitrary buffers of 32-bytes

*/

class buffer_stream32 {

public:

buffer_stream32() = default;

buffer_stream32(const VkDevice& p_device, const buffer_parameters& p_params) : m_device(p_device) {

VkBufferCreateInfo buffer_ci = {

.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,

.pNext = nullptr,

.flags = 0,

.size = p_params.device_size, // size in bytes

.usage = p_params.usage,

.sharingMode = p_params.share_mode,

};

vk_check(vkCreateBuffer(p_device, &buffer_ci, nullptr, &m_handle),

"vkCreateBuffer");

// 2. retrieving buffer memory requirements

VkMemoryRequirements memory_requirements = {};

vkGetBufferMemoryRequirements(p_device, m_handle, &memory_requirements);

// 3. selects the required memory requirements for this specific buffer

// allocations

uint32_t memory_index =

select_memory_requirements(p_params.physical_memory_properties,

memory_requirements,

p_params.property_flags);

// 4. allocatring the necessary memory based on memory requirements for

// the buffer handles

VkMemoryAllocateInfo memory_alloc_info = {

.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,

.allocationSize = memory_requirements.size,

.memoryTypeIndex = memory_index

};

#if _DEBUG

// 1. Define the structure

VkDebugUtilsObjectNameInfoEXT debug_info = {

.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,

.pNext = nullptr,

.objectType = VK_OBJECT_TYPE_BUFFER,

.objectHandle = (uint64_t)m_handle, // specify vulkan to what object handle this is

.pObjectName = p_params.debug_name // specify what type of buffer this is

};

if(p_params.vkSetDebugUtilsObjectNameEXT != nullptr) {

// vkSetDebugUtilsObjectNameEXT(m_device, &debug_info);

p_params.vkSetDebugUtilsObjectNameEXT(m_device, &debug_info);

}

#endif

vk_check(vkAllocateMemory(

p_device, &memory_alloc_info, nullptr, &m_device_memory),

"vkAllocateMemory");

// 5. bind memory resource of this buffer handle

vk_check(vkBindBufferMemory(p_device, m_handle, m_device_memory, 0),

"vkBindBufferMemory");

}

/**

* @brief write arbitrary buffer of 32-bytes to GPU-memory

*/

void write(std::span<const uint32_t> p_data) {

void* mapped = nullptr;

vk_check(

vkMapMemory(

m_device, m_device_memory, 0, p_data.size_bytes(), 0, &mapped),

"vkMapMemory");

memcpy(mapped, p_data.data(), p_data.size_bytes());

vkUnmapMemory(m_device, m_device_memory);

}

void copy_to_image(const VkCommandBuffer& p_command, const VkImage& p_image, image_extent p_extent) {

VkBufferImageCopy buffer_image_copy = {

.bufferOffset = 0,

.bufferRowLength = 0,

.bufferImageHeight = 0,

.imageSubresource = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,

.mipLevel = 0,

.baseArrayLayer = 0,

.layerCount = 1 },

.imageOffset = { .x = 0, .y = 0, .z = 0 },

.imageExtent = { .width = p_extent.width, .height = p_extent.height, .depth = 1 }

};

vkCmdCopyBufferToImage(p_command,

m_handle,

p_image,

VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,

1,

&buffer_image_copy);

}

void destroy() {

if (m_handle != nullptr) {

vkDestroyBuffer(m_device, m_handle, nullptr);

}

if (m_device_memory != nullptr) {

vkFreeMemory(m_device, m_device_memory, nullptr);

}

}

operator VkBuffer() { return m_handle; }

operator VkBuffer() const { return m_handle; }

private:

VkDevice m_device=nullptr;

VkDeviceMemory m_device_memory=nullptr;

VkBuffer m_handle=nullptr;

};

};

};