setup_backend_service()

void MayaFlux::Core::BackendResourceManager::setup_backend_service

(

const std::shared_ptr< Registry::Service::BufferService > &

buffer_service

)

Definition at line 26 of file BackendResoureManager.cpp.

{
    buffer_service->initialize_buffer = [this](const std::shared_ptr<void>& vk_buf) -> void {
        auto buffer = std::static_pointer_cast<Buffers::VKBuffer>(vk_buf);
        this->initialize_buffer(buffer);
    };
 
    buffer_service->allocate_raw_buffer = [this](
                                              size_t size_bytes,
                                              uint32_t usage_flags,
                                              uint32_t memory_property_flags,
                                              bool host_visible,
                                              void*& out_buffer,
                                              void*& out_memory,
                                              void*& out_mapped_ptr) -> void {
        vk::Buffer buf;
        vk::DeviceMemory mem;
        void* mapped = nullptr;
        this->allocate_raw_buffer(
            size_bytes,
            vk::BufferUsageFlags(usage_flags),
            vk::MemoryPropertyFlags(memory_property_flags),
            host_visible,
            buf, mem, mapped);
        out_buffer = static_cast<VkBuffer>(buf);
        out_memory = static_cast<VkDeviceMemory>(mem);
        out_mapped_ptr = mapped;
    };
 
    buffer_service->destroy_buffer = [this](const std::shared_ptr<void>& vk_buf) {
        auto buffer = std::static_pointer_cast<Buffers::VKBuffer>(vk_buf);
        this->cleanup_buffer(buffer);
    };
 
    buffer_service->get_buffer_device_address = [this](const std::shared_ptr<void>& vk_buf) -> uint64_t {
        auto buffer = std::static_pointer_cast<Buffers::VKBuffer>(vk_buf);
        auto address = this->get_buffer_device_address(buffer);
        return static_cast<uint64_t>(address);
    };
 
    buffer_service->execute_immediate = [this](const std::function<void(void*)>& recorder) {
        this->execute_immediate_commands([recorder](vk::CommandBuffer cmd) {
            recorder(static_cast<void*>(cmd));
        });
    };
 
    buffer_service->record_deferred = [this](const std::function<void(void*)>& recorder) {
        this->record_deferred_commands([recorder](vk::CommandBuffer cmd) {
            recorder(static_cast<void*>(cmd));
        });
    };
 
    buffer_service->flush_range = [this](void* memory, size_t offset, size_t size) {
        vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
        vk::MappedMemoryRange range { mem, offset, size == 0 ? VK_WHOLE_SIZE : size };
        if (auto result = m_context.get_device().flushMappedMemoryRanges(1, &range); result != vk::Result::eSuccess) {
            MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Failed to flush mapped memory range: {}", vk::to_string(result));
        }
    };
 
    buffer_service->invalidate_range = [this](void* memory, size_t offset, size_t size) {
        vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
        vk::MappedMemoryRange range { mem, offset, size == 0 ? VK_WHOLE_SIZE : size };
        if (auto result = m_context.get_device().invalidateMappedMemoryRanges(1, &range); result != vk::Result::eSuccess) {
            MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "Failed to invalidate mapped memory range: {}", vk::to_string(result));
        }
    };
 
    buffer_service->map_buffer = [this](void* memory, size_t offset, size_t size) -> void* {
        vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
        return m_context.get_device().mapMemory(mem, offset, size == 0 ? VK_WHOLE_SIZE : size);
    };
 
    buffer_service->unmap_buffer = [this](void* memory) {
        vk::DeviceMemory mem(reinterpret_cast<VkDeviceMemory>(memory));
        m_context.get_device().unmapMemory(mem);
    };
 
    buffer_service->copy_buffer = [this](void* src, void* dst, size_t size, size_t src_off, size_t dst_off) {
        vk::Buffer s(static_cast<VkBuffer>(src));
        vk::Buffer d(static_cast<VkBuffer>(dst));
        execute_immediate_commands([&](vk::CommandBuffer cmd) {
            vk::BufferCopy region { src_off, dst_off, size };
            cmd.copyBuffer(s, d, 1, &region);
        });
    };
 
    buffer_service->execute_fenced = [this](const std::function<void(void*)>& recorder)
        -> std::shared_ptr<void> {
        vk::CommandBuffer cmd = m_command_manager.begin_single_time_commands();
 
        recorder(static_cast<void*>(cmd));
 
        cmd.end();
 
        auto device = m_context.get_device();
        vk::FenceCreateInfo fence_info {};
        vk::Fence fence = device.createFence(fence_info);
 
        vk::SubmitInfo submit_info {};
        submit_info.commandBufferCount = 1;
        submit_info.pCommandBuffers = &cmd;
 
        if (auto result = m_context.get_graphics_queue().submit(1, &submit_info, fence);
            result != vk::Result::eSuccess) {
            MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "execute_fenced: queue submit failed: {}", vk::to_string(result));
            device.destroyFence(fence);
            m_command_manager.free_command_buffer(cmd);
            return nullptr;
        }
 
        auto handle = std::make_shared<FencedSubmission>();
        handle->cmd = cmd;
        handle->fence = fence;
        return handle;
    };
 
    buffer_service->wait_fenced = [this](const std::shared_ptr<void>& handle) {
        if (!handle)
            return;
        auto sub = std::static_pointer_cast<FencedSubmission>(handle);
        if (!sub->fence)
            return;
 
        auto device = m_context.get_device();
        if (auto result = device.waitForFences(1, &sub->fence, VK_TRUE, UINT64_MAX);
            result != vk::Result::eSuccess) {
            MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "wait_fenced: waitForFences failed: {}", vk::to_string(result));
        }
    };
 
    buffer_service->release_fenced = [this](const std::shared_ptr<void>& handle) {
        if (!handle)
            return;
        auto sub = std::static_pointer_cast<FencedSubmission>(handle);
 
        auto device = m_context.get_device();
        if (sub->fence) {
            device.destroyFence(sub->fence);
            sub->fence = nullptr;
        }
        if (sub->cmd) {
            m_command_manager.free_command_buffer(sub->cmd);
            sub->cmd = nullptr;
        }
    };
 
    buffer_service->copy_buffer_fenced = [this, buffer_service](void* src, void* dst, size_t size, size_t src_off, size_t dst_off)
        -> std::shared_ptr<void> {
        vk::Buffer s(static_cast<VkBuffer>(src));
        vk::Buffer d(static_cast<VkBuffer>(dst));
        return buffer_service->execute_fenced([&](void* cmd_ptr) {
            vk::CommandBuffer cmd(static_cast<VkCommandBuffer>(cmd_ptr));
            vk::BufferCopy region { src_off, dst_off, static_cast<vk::DeviceSize>(size) };
            cmd.copyBuffer(s, d, 1, &region);
        });
    };
}

References allocate_raw_buffer(), MayaFlux::Core::VKCommandManager::begin_single_time_commands(), cleanup_buffer(), cmd, MayaFlux::Journal::Core, execute_immediate_commands(), fence, MayaFlux::Core::VKCommandManager::free_command_buffer(), get_buffer_device_address(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Core::VKContext::get_graphics_queue(), MayaFlux::Journal::GraphicsBackend, initialize_buffer(), m_command_manager, m_context, MF_ERROR, offset, and record_deferred_commands().

Here is the call graph for this function: