monolith

use crate::image::{ImageInner, color_range};

use ash::vk;

use std::sync::Arc;

/// Layout changes recorded into a command buffer that has not been submitted.

/// Images keep their old layout until `commit`, so a failed submit leaves the

/// tracking true to what the GPU has done.

#[derive(Default)]

pub(crate) struct LayoutLog(Vec<(Arc<ImageInner>, vk::ImageLayout)>);

impl LayoutLog {

    fn current(&self, image: &Arc<ImageInner>) -> vk::ImageLayout {

        self.0

            .iter()

            .rev()

            .find(|(i, _)| Arc::ptr_eq(i, image))

            .map_or_else(|| image.layout(), |(_, layout)| *layout)

    }

    pub fn commit(self) {

        for (image, layout) in self.0 {

            image.set_layout(layout);

        }

    }

}

/// A full barrier between all earlier and later work on the image, optionally

/// transferring ownership between queue families. Coarse, but correct for

/// every transition the renderer makes.

pub(crate) unsafe fn barrier(

    d: &ash::Device,

    cmd: vk::CommandBuffer,

    image: vk::Image,

    old: vk::ImageLayout,

    new: vk::ImageLayout,

    src_family: u32,

    dst_family: u32,

) {

    let b = [vk::ImageMemoryBarrier2::default()

        .src_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)

        .src_access_mask(vk::AccessFlags2::MEMORY_WRITE)

        .dst_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)

        .dst_access_mask(vk::AccessFlags2::MEMORY_READ | vk::AccessFlags2::MEMORY_WRITE)

        .old_layout(old)

        .new_layout(new)

        .src_queue_family_index(src_family)

        .dst_queue_family_index(dst_family)

        .image(image)

        .subresource_range(color_range())];

    unsafe {

        d.cmd_pipeline_barrier2(

            cmd,

            &vk::DependencyInfo::default().image_memory_barriers(&b),

        )

    };

}

/// Moves an image into `layout` for use on this queue. Dmabuf images come

/// from the foreign queue family in the general layout, others continue from

/// their tracked layout.

pub(crate) unsafe fn acquire(

    d: &ash::Device,

    cmd: vk::CommandBuffer,

    family: u32,

    image: &Arc<ImageInner>,

    layout: vk::ImageLayout,

    log: &mut LayoutLog,

) {

    if image.external {

        unsafe {

            barrier(

                d,

                cmd,

                image.image,

                vk::ImageLayout::GENERAL,

                layout,

                vk::QUEUE_FAMILY_FOREIGN_EXT,

                family,

            )

        };

    } else {

        let old = log.current(image);

        if old != layout {

            unsafe {

                barrier(

                    d,

                    cmd,

                    image.image,

                    old,

                    layout,

                    vk::QUEUE_FAMILY_IGNORED,

                    vk::QUEUE_FAMILY_IGNORED,

                )

            };

            log.0.push((image.clone(), layout));

        }

    }

}

/// Hands a dmabuf image back to the foreign queue family after use.

pub(crate) unsafe fn release(

    d: &ash::Device,

    cmd: vk::CommandBuffer,

    family: u32,

    image: &ImageInner,

    layout: vk::ImageLayout,

) {

    if image.external {

        unsafe {

            barrier(

                d,

                cmd,

                image.image,

                layout,

                vk::ImageLayout::GENERAL,

                family,

                vk::QUEUE_FAMILY_FOREIGN_EXT,

            )

        };

    }

}