download_image_data()

void MayaFlux::Core::BackendResourceManager::download_image_data	(	std::shared_ptr< VKImage >	image,
		void *	data,
		size_t	size
	)

Download data from an image (creates staging buffer internally)

Parameters

image	Source VKImage
data	Destination buffer pointer
size	Buffer size in bytes

Definition at line 603 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 {},
            0, nullptr, 0, nullptr, 1, &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 = image->get_current_layout();
        barrier.srcAccessMask = vk::AccessFlagBits::eTransferRead;
        barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
 
        cmd.pipelineBarrier(
            vk::PipelineStageFlagBits::eTransfer,
            vk::PipelineStageFlagBits::eFragmentShader,
            vk::DependencyFlags {},
            0, nullptr, 0, nullptr, 1, &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));
    }
 
    void* mapped = staging->get_mapped_ptr();
    if (mapped) {
        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().

Here is the call graph for this function:

Here is the caller graph for this function: