upload_device_local()

MAYAFLUX_API void MayaFlux::Buffers::upload_device_local	(	const std::shared_ptr< VKBuffer > &	target,
		const std::shared_ptr< VKBuffer > &	staging_buffer,
		const Kakshya::DataVariant &	data,
		size_t	dst_offset = 0
	)

Upload data to a device-local buffer using a staging buffer.

Parameters

target	Target VKBuffer to upload data into
staging_buffer	Host-visible staging VKBuffer used for the upload
data	DataVariant containing the data to upload

This function handles uploading data from a Kakshya::DataVariant into a device-local VKBuffer by utilizing a staging buffer. It copies the data into the staging buffer, flushes it, and then issues a command to copy from the staging buffer to the target device-local buffer.

Parameters

dst_offset

Byte offset into target the staging copy lands at. The default 0 reproduces the whole-buffer overwrite exactly; a nonzero value writes a sub-range and leaves the rest untouched. The staging buffer itself only needs to hold data.

Definition at line 70 of file StagingUtils.cpp.

{
    Kakshya::DataAccess accessor(
        const_cast<Kakshya::DataVariant&>(data),
        {},
        target->get_modality());
 
    auto [ptr, bytes, format_hint] = accessor.gpu_buffer();
 
    if (dst_offset + bytes > target->get_size_bytes()) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "Upload data size {} at offset {} exceeds buffer capacity {}",
            bytes, dst_offset, target->get_size_bytes());
    }
 
    auto& staging_resources = staging_buffer->get_buffer_resources();
 
    void* staging_mapped = staging_resources.mapped_ptr;
    if (!staging_mapped) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "Staging buffer has no mapped pointer");
    }
 
    std::memcpy(staging_mapped, ptr, bytes);
    staging_buffer->mark_dirty_range(0, bytes);
 
    auto buffer_service = Registry::BackendRegistry::instance()
                              .get_service<Registry::Service::BufferService>();
 
    if (!buffer_service) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "upload_host_visible requires a valid buffer service");
    }
 
    auto dirty_ranges = staging_buffer->get_and_clear_dirty_ranges();
    for (auto& [offset, size] : dirty_ranges) {
        buffer_service->flush_range(
            staging_resources.memory,
            offset,
            size);
    }
 
    buffer_service->copy_buffer(
        static_cast<void*>(staging_buffer->get_buffer()),
        static_cast<void*>(target->get_buffer()),
        bytes, 0, dst_offset);
}

References MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Kakshya::DataAccess::gpu_buffer(), MayaFlux::Registry::BackendRegistry::instance(), offset, ptr, and size.

Referenced by MayaFlux::Buffers::VKBuffer::clone_to(), MayaFlux::Buffers::BufferUploadProcessor::upload_device_local(), and upload_to_gpu().

Here is the call graph for this function:

Here is the caller graph for this function: