upload_image_data() [2/2]

void MayaFlux::Core::BackendResourceManager::upload_image_data	(	std::shared_ptr< VKImage >	image,
		const void *	data,
		size_t	size,
		const std::shared_ptr< Buffers::VKBuffer > &	staging,
		bool	deferred = false
	)

Upload image data using a caller-supplied persistent staging buffer.

Identical to upload_image_data() but skips the per-call VkBuffer allocation. The staging buffer must be host-visible and at least size bytes. Intended for high-frequency streaming uploads.

Parameters

image	Target VKImage.
data	Source pixel data pointer.
size	Byte count.
staging	Pre-allocated host-visible staging buffer.
deferred	If true, command recording will be deferred and must be flushed

Definition at line 773 of file BackendResoureManager.cpp.

{
    if (!image || !data || !staging) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Invalid parameters for upload_image_data_with_staging");
        return;
    }
 
    void* mapped = staging->get_mapped_ptr();
    if (!mapped) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "upload_image_data_with_staging: staging buffer has no mapped pointer");
        return;
    }
 
    std::memcpy(mapped, data, size);
    staging->mark_dirty_range(0, size);
 
    auto& resources = staging->get_buffer_resources();
    vk::MappedMemoryRange range { resources.memory, 0, VK_WHOLE_SIZE };
 
    if (auto result = m_context.get_device().flushMappedMemoryRanges(1, &range);
        result != vk::Result::eSuccess) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "upload_image_data_with_staging: flush failed: {}", vk::to_string(result));
    }
 
    auto record_command = [&](vk::CommandBuffer cmd) {
        vk::ImageMemoryBarrier barrier {};
        barrier.oldLayout = image->get_current_layout();
        barrier.newLayout = vk::ImageLayout::eTransferDstOptimal;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.image = image->get_image();
        barrier.subresourceRange = {
            image->get_aspect_flags(), 0,
            image->get_mip_levels(), 0,
            image->get_array_layers()
        };
        barrier.srcAccessMask = vk::AccessFlagBits::eShaderRead;
        barrier.dstAccessMask = vk::AccessFlagBits::eTransferWrite;
 
        cmd.pipelineBarrier(
            vk::PipelineStageFlagBits::eFragmentShader,
            vk::PipelineStageFlagBits::eTransfer,
            {}, 0, nullptr, 0, nullptr, 1, &barrier);
 
        vk::BufferImageCopy region {};
        region.imageSubresource.aspectMask = image->get_aspect_flags();
        region.imageSubresource.layerCount = image->get_array_layers();
        region.imageOffset = vk::Offset3D { 0, 0, 0 };
        region.imageExtent = vk::Extent3D {
            image->get_width(),
            image->get_height(),
            image->get_depth()
        };
 
        cmd.copyBufferToImage(
            staging->get_buffer(),
            image->get_image(),
            vk::ImageLayout::eTransferDstOptimal,
            1, &region);
 
        barrier.oldLayout = vk::ImageLayout::eTransferDstOptimal;
        barrier.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
        barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
        barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
 
        cmd.pipelineBarrier(
            vk::PipelineStageFlagBits::eTransfer,
            vk::PipelineStageFlagBits::eFragmentShader,
            {}, 0, nullptr, 0, nullptr, 1, &barrier);
    };
 
    if (deferred) {
        record_deferred_commands(record_command);
    } else {
        execute_immediate_commands(record_command);
    }
 
    image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
 
    MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "upload_image_data_with_staging: {} bytes to image {}x{}",
        size, image->get_width(), image->get_height());
}

References cmd, MayaFlux::Journal::Core, execute_immediate_commands(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsBackend, image, m_context, MF_DEBUG, MF_ERROR, and record_deferred_commands().

Here is the call graph for this function: