download_image_data()

void MayaFlux::Core::BackendResourceManager::download_image_data	(	std::shared_ptr< VKImage >	image,
		void *	data,
		size_t	size,
		vk::ImageLayout	restore_layout = vk::ImageLayout::eShaderReadOnlyOptimal,
		vk::PipelineStageFlags	restore_stage = vk::PipelineStageFlagBits::eFragmentShader
	)

Download data from an image into a caller-supplied buffer.

Transitions the image to eTransferSrcOptimal, copies to a staging buffer, then restores it to restore_layout using restore_stage.

The defaults cover the common case of a device-local texture in shader read-only layout. Pass ePresentSrcKHR / eBottomOfPipe for swapchain images.

Parameters

image	Source image.
data	Destination host pointer (must be at least size bytes).
size	Byte count to read.
restore_layout	Layout to transition back to after the copy. Defaults to eShaderReadOnlyOptimal.
restore_stage	Pipeline stage that will consume the image after restore. Defaults to eFragmentShader.

Definition at line 693 of file BackendResoureManager.cpp.

{
    if (!image || !data) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Invalid parameters for download_image_data");
        return;
    }
 
    auto staging = std::make_shared<Buffers::VKBuffer>(
        size,
        Buffers::VKBuffer::Usage::STAGING,
        Kakshya::DataModality::IMAGE_COLOR);
 
    initialize_buffer(staging);
 
    execute_immediate_commands([&](vk::CommandBuffer cmd) {
        vk::ImageMemoryBarrier barrier {};
        barrier.oldLayout = image->get_current_layout();
        barrier.newLayout = vk::ImageLayout::eTransferSrcOptimal;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.image = image->get_image();
        barrier.subresourceRange.aspectMask = image->get_aspect_flags();
        barrier.subresourceRange.baseMipLevel = 0;
        barrier.subresourceRange.levelCount = image->get_mip_levels();
        barrier.subresourceRange.baseArrayLayer = 0;
        barrier.subresourceRange.layerCount = image->get_array_layers();
        barrier.srcAccessMask = vk::AccessFlagBits::eShaderRead;
        barrier.dstAccessMask = vk::AccessFlagBits::eTransferRead;
 
        cmd.pipelineBarrier(
            vk::PipelineStageFlagBits::eFragmentShader,
            vk::PipelineStageFlagBits::eTransfer,
            vk::DependencyFlags {}, {}, {}, barrier);
 
        vk::BufferImageCopy region {};
        region.bufferOffset = 0;
        region.bufferRowLength = 0;
        region.bufferImageHeight = 0;
        region.imageSubresource.aspectMask = image->get_aspect_flags();
        region.imageSubresource.mipLevel = 0;
        region.imageSubresource.baseArrayLayer = 0;
        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.copyImageToBuffer(
            image->get_image(),
            vk::ImageLayout::eTransferSrcOptimal,
            staging->get_buffer(),
            1, &region);
 
        barrier.oldLayout = vk::ImageLayout::eTransferSrcOptimal;
        barrier.newLayout = restore_layout;
        barrier.srcAccessMask = vk::AccessFlagBits::eTransferRead;
        barrier.dstAccessMask = vk::AccessFlagBits::eMemoryRead;
 
        cmd.pipelineBarrier(
            vk::PipelineStageFlagBits::eTransfer,
            restore_stage,
            vk::DependencyFlags {}, {}, {}, barrier);
    });
 
    staging->mark_invalid_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().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));
    }
 
    if (void* mapped = staging->get_mapped_ptr()) {
        std::memcpy(data, mapped, size);
    }
 
    cleanup_buffer(staging);
 
    MF_DEBUG(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "Downloaded {} bytes from image {}x{}",
        size, image->get_width(), image->get_height());
}

References cleanup_buffer(), MayaFlux::Journal::Core, execute_immediate_commands(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsBackend, MayaFlux::Kakshya::IMAGE_COLOR, initialize_buffer(), m_context, MF_DEBUG, MF_ERROR, and MayaFlux::Buffers::VKBuffer::STAGING.

Referenced by MayaFlux::Portal::Graphics::TextureLoom::download_data(), and MayaFlux::Core::BackendWindowHandler::setup_backend_service().

Here is the call graph for this function:

Here is the caller graph for this function: