blit_image()

bool MayaFlux::Core::BackendResourceManager::blit_image	(	const std::shared_ptr< VKImage > &	src,
		const std::shared_ptr< VKImage > &	dst,
		const vk::ImageBlit &	region,
		vk::Filter	filter,
		bool	deferred = false
	)

Blit a region of one image into a region of another.

Scales with filter and converts between supported formats. The subresources in region choose the array layers. Both images are returned to the layout they held, or shader read when it was transient.

Parameters

src	Source image.
dst	Destination image, distinct from src.
region	Subresources and offsets.
filter	Nearest or linear.
deferred	Record for deferred submission.

Returns

True if the blit was recorded or executed.

Definition at line 1140 of file BackendResoureManager.cpp.

{
    if (!src || !dst || src == dst) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "blit_image: source and destination must be two distinct initialised images");
        return false;
    }
 
    if (!supports_blit(src->get_format(), dst->get_format(), filter)) {
        MF_ERROR(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "blit_image: formats {} to {} do not support a {} blit",
            vk::to_string(src->get_format()), vk::to_string(dst->get_format()), vk::to_string(filter));
        return false;
    }
 
    const auto settled_layout = [](const std::shared_ptr<VKImage>& image) {
        const auto layout = image->get_current_layout();
        const bool transient = layout == vk::ImageLayout::eUndefined
            || layout == vk::ImageLayout::eTransferSrcOptimal
            || layout == vk::ImageLayout::eTransferDstOptimal;
        return transient ? vk::ImageLayout::eShaderReadOnlyOptimal : layout;
    };
    const auto src_restore = settled_layout(src);
    const auto dst_restore = settled_layout(dst);
 
    auto record_command = [&](vk::CommandBuffer cmd) {
        const auto transition = [&cmd](
                                    const std::shared_ptr<VKImage>& image,
                                    vk::ImageLayout from,
                                    vk::ImageLayout to,
                                    vk::AccessFlags src_access,
                                    vk::AccessFlags dst_access,
                                    vk::PipelineStageFlags src_stage,
                                    vk::PipelineStageFlags dst_stage) {
            vk::ImageMemoryBarrier barrier {};
            barrier.oldLayout = from;
            barrier.newLayout = to;
            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 = src_access;
            barrier.dstAccessMask = dst_access;
            cmd.pipelineBarrier(src_stage, dst_stage, vk::DependencyFlags {}, {}, {}, barrier);
        };
 
        constexpr auto any_access = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
 
        transition(src, src->get_current_layout(), vk::ImageLayout::eTransferSrcOptimal,
            any_access, vk::AccessFlagBits::eTransferRead,
            vk::PipelineStageFlagBits::eAllCommands, vk::PipelineStageFlagBits::eTransfer);
        transition(dst, dst->get_current_layout(), vk::ImageLayout::eTransferDstOptimal,
            any_access, vk::AccessFlagBits::eTransferWrite,
            vk::PipelineStageFlagBits::eAllCommands, vk::PipelineStageFlagBits::eTransfer);
 
        cmd.blitImage(
            src->get_image(), vk::ImageLayout::eTransferSrcOptimal,
            dst->get_image(), vk::ImageLayout::eTransferDstOptimal,
            1, &region, filter);
 
        transition(src, vk::ImageLayout::eTransferSrcOptimal, src_restore,
            vk::AccessFlagBits::eTransferRead, any_access,
            vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eAllCommands);
        transition(dst, vk::ImageLayout::eTransferDstOptimal, dst_restore,
            vk::AccessFlagBits::eTransferWrite, any_access,
            vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eAllCommands);
    };
 
    if (deferred) {
        record_deferred_commands(record_command);
    } else {
        execute_immediate_commands(record_command);
    }
 
    src->set_current_layout(src_restore);
    dst->set_current_layout(dst_restore);
 
    return true;
}

References cmd, MayaFlux::Journal::Core, dst, execute_immediate_commands(), MayaFlux::Journal::GraphicsBackend, image, MF_ERROR, record_deferred_commands(), src, and supports_blit().

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

Here is the call graph for this function:

Here is the caller graph for this function: