allocate_raw_buffer()

void MayaFlux::Core::BackendResourceManager::allocate_raw_buffer	(	size_t	size_bytes,
		vk::BufferUsageFlags	usage,
		vk::MemoryPropertyFlags	memory_properties,
		bool	host_visible,
		vk::Buffer &	out_buffer,
		vk::DeviceMemory &	out_memory,
		void *&	out_mapped_ptr
	)

Allocate a raw VkBuffer/VkDeviceMemory pair without an owning VKBuffer object.

Parameters

size_bytes	Buffer capacity in bytes.
usage	Vulkan buffer usage flags.
memory_properties	Vulkan memory property flags.
host_visible	When true, the allocation is mapped and out_mapped_ptr is populated; when false, out_mapped_ptr is left null.
out_buffer	Receives the created vk::Buffer.
out_memory	Receives the bound vk::DeviceMemory.
out_mapped_ptr	Receives the mapped host pointer, or nullptr if host_visible is false.

Same allocation sequence as initialize_buffer() (createBuffer, getBufferMemoryRequirements, allocateMemory, bindBufferMemory, optional mapMemory), without requiring or populating a VKBuffer. Intended for VKBuffer subclasses that own secondary raw handle pairs directly in VKBufferResources::back_buffers rather than as separate VKBuffer objects.

Definition at line 189 of file BackendResoureManager.cpp.

{
    vk::BufferCreateInfo buffer_info {};
    buffer_info.size = size_bytes;
    buffer_info.usage = usage;
    buffer_info.sharingMode = vk::SharingMode::eExclusive;
 
    try {
        out_buffer = m_context.get_device().createBuffer(buffer_info);
    } catch (const vk::SystemError& e) {
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to create raw VkBuffer: " + std::string(e.what()));
    }
 
    vk::MemoryRequirements mem_requirements = m_context.get_device().getBufferMemoryRequirements(out_buffer);
 
    vk::MemoryAllocateInfo alloc_info;
    alloc_info.allocationSize = mem_requirements.size;
    alloc_info.memoryTypeIndex = find_memory_type(mem_requirements.memoryTypeBits, memory_properties);
 
    try {
        out_memory = m_context.get_device().allocateMemory(alloc_info);
    } catch (const vk::SystemError& e) {
        m_context.get_device().destroyBuffer(out_buffer);
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to allocate raw VkDeviceMemory: " + std::string(e.what()));
    }
 
    try {
        m_context.get_device().bindBufferMemory(out_buffer, out_memory, 0);
    } catch (const vk::SystemError& e) {
        m_context.get_device().freeMemory(out_memory);
        m_context.get_device().destroyBuffer(out_buffer);
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to bind raw buffer memory: " + std::string(e.what()));
    }
 
    out_mapped_ptr = nullptr;
    if (host_visible) {
        try {
            out_mapped_ptr = m_context.get_device().mapMemory(out_memory, 0, size_bytes);
        } catch (const vk::SystemError& e) {
            m_context.get_device().freeMemory(out_memory);
            m_context.get_device().destroyBuffer(out_buffer);
            error_rethrow(
                Journal::Component::Core,
                Journal::Context::GraphicsBackend,
                std::source_location::current(),
                "Failed to map raw buffer memory: " + std::string(e.what()));
        }
    }
}

References MayaFlux::Journal::Core, find_memory_type(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsBackend, and m_context.

Referenced by initialize_buffer(), and setup_backend_service().

Here is the call graph for this function:

Here is the caller graph for this function: