upload_back_buffer_async()

MAYAFLUX_API TransferHandle MayaFlux::Buffers::upload_back_buffer_async	(	const VKBufferResources::GenerationSlot &	slot,
		const void *	data,
		size_t	size,
		std::shared_ptr< VKBuffer > &	staging
	)

Upload to a back_buffers slot without waiting for completion.

Parameters

slot	Destination slot, typically from VKBuffer::get_back_buffer().
data	Source pointer, at least size bytes. Copied into staging before returning, so the caller may free it immediately.
size	Byte count to copy.
staging	Persistent staging buffer, grown if too small.

Returns

Handle to pass to resolve_transfer, or null for host-visible slots where the write was a direct memcpy.

The staging buffer is in use until the returned handle is resolved. Any further transfer through the same staging buffer must resolve this one first, or the copy source is overwritten mid-flight.

Definition at line 137 of file StagingUtils.cpp.

{
    if (!data || size == 0)
        return {};
 
    if (slot.mapped_ptr) {
        std::memcpy(slot.mapped_ptr, data, size);
        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->flush_range) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "upload_back_buffer_async: BufferService unavailable");
    }
 
    if (!staging || staging->get_size_bytes() < size)
        staging = create_staging_buffer(size);
 
    void* ptr = staging->get_mapped_ptr();
    if (!ptr) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "upload_back_buffer_async: staging buffer has no mapped pointer");
    }
 
    std::memcpy(ptr, data, size);
 
    auto& resources = staging->get_buffer_resources();
    buffer_service->flush_range(resources.memory, 0, size);
 
    auto handle = buffer_service->copy_buffer_fenced(
        static_cast<void*>(staging->get_buffer()),
        static_cast<void*>(slot.buffer),
        size, 0, 0);
 
    if (!handle) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "upload_back_buffer_async: copy_buffer_fenced returned null");
    }
 
    return handle;
}

References MayaFlux::Buffers::VKBufferResources::GenerationSlot::buffer, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, create_staging_buffer(), MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Registry::BackendRegistry::instance(), MayaFlux::Buffers::VKBufferResources::GenerationSlot::mapped_ptr, ptr, and size.

Referenced by MayaFlux::Buffers::VolumeGridBuffer::seed_raw(), and upload_back_buffer().

Here is the call graph for this function:

Here is the caller graph for this function: