monolith

use crate::device::Shared;

use ash::vk;

use smithay::backend::renderer::sync::{Fence, Interrupted};

use std::fmt;

use std::sync::Arc;

pub(crate) struct FenceInner {

    pub shared: Arc<Shared>,

    pub fence: vk::Fence,

}

impl FenceInner {

    pub fn new(shared: &Arc<Shared>) -> Result<Arc<Self>, vk::Result> {

        let fence = unsafe {

            shared

                .device

                .device

                .create_fence(&vk::FenceCreateInfo::default(), None)?

        };

        Ok(Arc::new(Self {

            shared: shared.clone(),

            fence,

        }))

    }

    pub fn signaled(&self) -> bool {

        unsafe { self.shared.device.device.get_fence_status(self.fence) }.unwrap_or(true)

    }

    pub fn wait(&self) -> Result<(), vk::Result> {

        unsafe {

            self.shared

                .device

                .device

                .wait_for_fences(&[self.fence], true, u64::MAX)

        }

    }

}

impl Drop for FenceInner {

    fn drop(&mut self) {

        unsafe { self.shared.device.device.destroy_fence(self.fence, None) };

    }

}

impl fmt::Debug for FenceInner {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        f.debug_tuple("FenceInner").field(&self.fence).finish()

    }

}

#[derive(Debug)]

pub(crate) struct VkFence(pub Arc<FenceInner>);

impl Fence for VkFence {

    fn is_signaled(&self) -> bool {

        self.0.signaled()

    }

    fn wait(&self) -> Result<(), Interrupted> {

        self.0.wait().map_err(|_| Interrupted)

    }

    fn is_exportable(&self) -> bool {

        false

    }

    fn export(&self) -> Option<std::os::fd::OwnedFd> {

        None

    }

}