download_from_gpu_async()

MAYAFLUX_API void MayaFlux::Buffers::download_from_gpu_async	(	const std::shared_ptr< VKBuffer > &	source,
		void *	data,
		size_t	size,
		std::shared_ptr< VKBuffer > &	staging
	)

Download from a device-local GPU buffer without stalling the graphics queue.

Records a buffer copy into a fenced command buffer, waits on the fence from the calling thread, then memcpys from the mapped staging buffer into data. Unlike download_from_gpu, this does not call queue.waitIdle, making it safe to call from any thread that is not the graphics thread itself.

staging is allocated and cached by the caller to avoid per-call Vulkan object churn. Pass the same staging buffer each frame; it is resized if size exceeds its current capacity.

Parameters

source	Device-local source buffer.
data	Destination host pointer, at least size bytes.
size	Byte count to copy.
staging	Persistent host-visible staging buffer. Created via create_staging_buffer(). Resized in-place if too small.

Definition at line 390 of file StagingUtils.cpp.

{
    if (!source || !data || size == 0)
        return;
 
    auto buffer_service = Registry::BackendRegistry::instance()
                              .get_service<Registry::Service::BufferService>();
 
    if (!buffer_service
        || !buffer_service->execute_fenced
        || !buffer_service->wait_fenced
        || !buffer_service->release_fenced
        || !buffer_service->invalidate_range) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "download_from_gpu_async: BufferService unavailable");
    }
 
    if (!staging || staging->get_size_bytes() < size)
        staging = create_staging_buffer(size);
 
    auto handle = buffer_service->copy_buffer_fenced(
        static_cast<void*>(source->get_buffer()),
        static_cast<void*>(staging->get_buffer()),
        size, 0, 0);
 
    if (!handle) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "download_from_gpu_async: execute_fenced returned null");
    }
 
    buffer_service->wait_fenced(handle);
 
    auto& resources = staging->get_buffer_resources();
    buffer_service->invalidate_range(resources.memory, 0, size);
 
    void* ptr = staging->get_mapped_ptr();
    if (!ptr) {
        buffer_service->release_fenced(handle);
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "download_from_gpu_async: staging buffer has no mapped pointer");
    }
 
    std::memcpy(data, ptr, size);
    buffer_service->release_fenced(handle);
}

References MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, create_staging_buffer(), MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Registry::BackendRegistry::instance(), and ptr.

Referenced by MayaFlux::Nodes::GpuSync::GeometryReadbackNode::compute_frame().

Here is the call graph for this function:

Here is the caller graph for this function: