upload_image_layer()

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

Upload pixel data into one layer of an array image.

The other layers keep their contents. size must equal one layer's byte count. With staging null a per-call staging buffer is made and released; a deferred upload needs a caller staging buffer.

Parameters

image	Target array image.
layer	Layer index.
data	Source pixels.
size	Byte count of one layer.
staging	Persistent host-visible staging buffer, or nullptr.
deferred	Record for deferred submission (requires staging).

Returns

True if the upload was recorded or executed.

Definition at line 1006 of file BackendResoureManager.cpp.

{
    if (!image || !data || layer >= image->get_array_layers()) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "upload_image_layer: invalid image, data or layer");
        return false;
    }
 
    const size_t layer_bytes = image->get_size_bytes() / image->get_array_layers();
    if (size != layer_bytes) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "upload_image_layer: {} bytes given, layer needs {}", size, layer_bytes);
        return false;
    }
 
    if (deferred && !staging) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "upload_image_layer: a deferred upload needs a caller staging buffer");
        return false;
    }
 
    std::shared_ptr<Buffers::VKBuffer> local_staging;
    if (!staging) {
        local_staging = std::make_shared<Buffers::VKBuffer>(
            size,
            Buffers::VKBuffer::Usage::STAGING,
            Kakshya::DataModality::IMAGE_COLOR);
        initialize_buffer(local_staging);
    }
    const auto& active_staging = staging ? staging : local_staging;
 
    void* mapped = active_staging->get_mapped_ptr();
    if (!mapped) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "upload_image_layer: staging buffer has no mapped pointer");
        if (local_staging) {
            cleanup_buffer(local_staging);
        }
        return false;
    }
 
    std::memcpy(mapped, data, size);
    active_staging->mark_dirty_range(0, size);
 
    vk::MappedMemoryRange range { active_staging->get_buffer_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_layer: 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,
            vk::DependencyFlags {}, {}, {}, barrier);
 
        vk::BufferImageCopy region {};
        region.imageSubresource = { image->get_aspect_flags(), 0, layer, 1 };
        region.imageOffset = vk::Offset3D { 0, 0, 0 };
        region.imageExtent = vk::Extent3D {
            image->get_width(),
            image->get_height(),
            image->get_depth()
        };
 
        cmd.copyBufferToImage(
            active_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,
            vk::DependencyFlags {}, {}, {}, barrier);
    };
 
    if (deferred) {
        record_deferred_commands(record_command);
    } else {
        execute_immediate_commands(record_command);
    }
 
    image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
 
    if (local_staging) {
        cleanup_buffer(local_staging);
    }
 
    return true;
}

References cleanup_buffer(), cmd, MayaFlux::Journal::Core, execute_immediate_commands(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsBackend, image, MayaFlux::Kakshya::IMAGE_COLOR, initialize_buffer(), m_context, MF_ERROR, record_deferred_commands(), and size.

Referenced by MayaFlux::Portal::Graphics::TextureLoom::upload_layer().

Here is the call graph for this function:

Here is the caller graph for this function: