vulkano 0.4.1

// Copyright (c) 2016 The vulkano developers
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
// at your option. All files in the project carrying such
// notice may not be copied, modified, or distributed except
// according to those terms.

use std::sync::Arc;

use device::Queue;
use format::ClearValue;
use format::Format;
use format::FormatDesc;
use image::ImageDimensions;
use image::Dimensions;
use image::ViewType;
use image::traits::ImageAccess;
use image::traits::ImageClearValue;
use image::traits::ImageContent;
use image::traits::ImageViewAccess;
use image::traits::Image;
use image::traits::ImageView;
use image::ImageLayout;
use image::sys::UnsafeImage;
use image::sys::UnsafeImageView;
use swapchain::Swapchain;
use sync::AccessError;

use OomError;

/// An image that is part of a swapchain.
///
/// Creating a `SwapchainImage` is automatically done when creating a swapchain.
///
/// A swapchain image is special in the sense that it can only be used after being acquired by
/// calling the `acquire` method on the swapchain. You have no way to know in advance which
/// swapchain image is going to be acquired, so you should keep all of them alive.
///
/// After a swapchain image has been acquired, you are free to perform all the usual operations
/// on it. When you are done you can then *present* the image (by calling the corresponding
/// method on the swapchain), which will have the effect of showing the content of the image to
/// the screen. Once an image has been presented, it can no longer be used unless it is acquired
/// again.
// TODO: #[derive(Debug)]
pub struct SwapchainImage {
    swapchain: Arc<Swapchain>,
    image_offset: usize,
    view: UnsafeImageView,
}

impl SwapchainImage {
    /// Builds a `SwapchainImage` from raw components.
    ///
    /// This is an internal method that you shouldn't call.
    pub unsafe fn from_raw(swapchain: Arc<Swapchain>, id: usize)
                           -> Result<Arc<SwapchainImage>, OomError>
    {
        let image = swapchain.raw_image(id).unwrap();
        let view = try!(UnsafeImageView::raw(&image, ViewType::Dim2d, 0 .. 1, 0 .. 1));

        Ok(Arc::new(SwapchainImage {
            swapchain: swapchain.clone(),
            image_offset: id,
            view: view,
        }))
    }

    /// Returns the dimensions of the image.
    ///
    /// A `SwapchainImage` is always two-dimensional.
    #[inline]
    pub fn dimensions(&self) -> [u32; 2] {
        let dims = self.my_image().dimensions();
        [dims.width(), dims.height()]
    }

    /// Returns the swapchain this image belongs to.
    #[inline]
    pub fn swapchain(&self) -> &Arc<Swapchain> {
        &self.swapchain
    }

    #[inline]
    fn my_image(&self) -> &UnsafeImage {
        self.swapchain.raw_image(self.image_offset).unwrap()
    }
}

unsafe impl ImageAccess for SwapchainImage {
    #[inline]
    fn inner(&self) -> &UnsafeImage {
        self.my_image()
    }

    #[inline]
    fn initial_layout_requirement(&self) -> ImageLayout {
        ImageLayout::PresentSrc
    }

    #[inline]
    fn final_layout_requirement(&self) -> ImageLayout {
        ImageLayout::PresentSrc
    }

    #[inline]
    fn conflict_key(&self, _: u32, _: u32, _: u32, _: u32) -> u64 {
        self.my_image().key()
    }

    #[inline]
    fn try_gpu_lock(&self, _: bool, _: &Queue) -> Result<(), AccessError> {
        // Swapchain image are only accessible after being acquired.
        Err(AccessError::SwapchainImageAcquireOnly)
    }

    #[inline]
    unsafe fn increase_gpu_lock(&self) {
    }
}

unsafe impl ImageClearValue<<Format as FormatDesc>::ClearValue> for SwapchainImage
{
    #[inline]
    fn decode(&self, value: <Format as FormatDesc>::ClearValue) -> Option<ClearValue> {
        Some(self.swapchain.format().decode_clear_value(value))
    }
}

unsafe impl<P> ImageContent<P> for SwapchainImage {
    #[inline]
    fn matches_format(&self) -> bool {
        true        // FIXME:
    }
}

unsafe impl ImageViewAccess for SwapchainImage {
    #[inline]
    fn parent(&self) -> &ImageAccess {
        self
    }

    #[inline]
    fn dimensions(&self) -> Dimensions {
        let dims = self.swapchain.dimensions();
        Dimensions::Dim2d { width: dims[0], height: dims[1] }
    }

    #[inline]
    fn inner(&self) -> &UnsafeImageView {
        &self.view
    }

    #[inline]
    fn descriptor_set_storage_image_layout(&self) -> ImageLayout {
        ImageLayout::ShaderReadOnlyOptimal
    }

    #[inline]
    fn descriptor_set_combined_image_sampler_layout(&self) -> ImageLayout {
        ImageLayout::ShaderReadOnlyOptimal
    }

    #[inline]
    fn descriptor_set_sampled_image_layout(&self) -> ImageLayout {
        ImageLayout::ShaderReadOnlyOptimal
    }

    #[inline]
    fn descriptor_set_input_attachment_layout(&self) -> ImageLayout {
        ImageLayout::ShaderReadOnlyOptimal
    }

    #[inline]
    fn identity_swizzle(&self) -> bool {
        true
    }
}

unsafe impl Image for SwapchainImage {
    type Access = SwapchainImage;

    #[inline]
    fn access(self) -> Self::Access {
        self
    }

    #[inline]
    fn format(&self) -> Format {
        self.my_image().format()
    }

    #[inline]
    fn samples(&self) -> u32 {
        self.my_image().samples()
    }

    #[inline]
    fn dimensions(&self) -> ImageDimensions {
        self.my_image().dimensions()
    }
}

unsafe impl ImageView for SwapchainImage {
    type Access = SwapchainImage;

    fn access(self) -> Self::Access {
        self
    }
}

unsafe impl Image for Arc<SwapchainImage> {
    type Access = Arc<SwapchainImage>;

    #[inline]
    fn access(self) -> Self::Access {
        self
    }

    #[inline]
    fn format(&self) -> Format {
        self.my_image().format()
    }

    #[inline]
    fn samples(&self) -> u32 {
        self.my_image().samples()
    }

    #[inline]
    fn dimensions(&self) -> ImageDimensions {
        self.my_image().dimensions()
    }
}

unsafe impl ImageView for Arc<SwapchainImage> {
    type Access = Arc<SwapchainImage>;

    fn access(self) -> Self::Access {
        self
    }
}