initialize_buffer()

void MayaFlux::Core::BackendResourceManager::initialize_buffer

(

const std::shared_ptr< Buffers::VKBuffer > &

buffer

)

Initialize a buffer for use with the graphics backend.

Parameters

buffer

Shared pointer to the buffer to initialize

Definition at line 167 of file BackendResoureManager.cpp.

{
    if (!buffer) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Attempted to initialize null VulkanBuffer");
        return;
    }
 
    if (buffer->is_initialized()) {
        MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "VulkanBuffer already initialized, skipping");
        return;
    }
 
    vk::BufferCreateInfo buffer_info {};
    buffer_info.size = buffer->get_size_bytes();
    buffer_info.usage = buffer->get_usage_flags();
    buffer_info.sharingMode = vk::SharingMode::eExclusive;
 
    vk::Buffer vk_buffer;
    try {
        vk_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 VkBuffer: " + std::string(e.what()));
    }
 
    vk::MemoryRequirements mem_requirements;
    mem_requirements = m_context.get_device().getBufferMemoryRequirements(vk_buffer);
 
    vk::MemoryAllocateInfo alloc_info;
    alloc_info.allocationSize = mem_requirements.size;
 
    alloc_info.memoryTypeIndex = find_memory_type(
        mem_requirements.memoryTypeBits,
        vk::MemoryPropertyFlags(buffer->get_memory_properties()));
 
    vk::DeviceMemory memory;
    try {
        memory = m_context.get_device().allocateMemory(alloc_info);
    } catch (const vk::SystemError& e) {
        m_context.get_device().destroyBuffer(vk_buffer);
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to allocate VkDeviceMemory: " + std::string(e.what()));
    }
 
    try {
        m_context.get_device().bindBufferMemory(vk_buffer, memory, 0);
    } catch (const vk::SystemError& e) {
        m_context.get_device().freeMemory(memory);
        m_context.get_device().destroyBuffer(vk_buffer);
 
        error_rethrow(
            Journal::Component::Core,
            Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to bind buffer memory: " + std::string(e.what()));
    }
 
    void* mapped_ptr = nullptr;
    if (buffer->is_host_visible()) {
        try {
            mapped_ptr = m_context.get_device().mapMemory(memory, 0, buffer->get_size_bytes());
        } catch (const vk::SystemError& e) {
            m_context.get_device().freeMemory(memory);
            m_context.get_device().destroyBuffer(vk_buffer);
 
            error_rethrow(
                Journal::Component::Core,
                Journal::Context::GraphicsBackend,
                std::source_location::current(),
                "Failed to map buffer memory: " + std::string(e.what()));
        }
    }
 
    Buffers::VKBufferResources resources { .buffer = vk_buffer, .memory = memory, .mapped_ptr = mapped_ptr };
    buffer->set_buffer_resources(resources);
    m_managed_buffers.push_back(buffer);
 
    MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "VulkanBuffer initialized: {} bytes, modality: {}, VkBuffer: {:p}",
        buffer->get_size_bytes(),
        Kakshya::modality_to_string(buffer->get_modality()),
        (void*)buffer->get_buffer());
}

References MayaFlux::Buffers::VKBufferResources::buffer, MayaFlux::Journal::Core, find_memory_type(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsBackend, m_context, m_managed_buffers, MF_ERROR, MF_INFO, MF_WARN, and MayaFlux::Kakshya::modality_to_string().

Referenced by download_image_data(), setup_backend_service(), and upload_image_data().

Here is the call graph for this function:

Here is the caller graph for this function: