// Copyright (c) 2021 The vulkano developers
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or https://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.

//! Image views.
//!
//! This module contains types related to image views. An image view wraps around
//! an image and describes how the GPU should interpret the data. It is needed when an image is
//! to be used in a shader descriptor or as a framebuffer attachment.

use super::{
    sys::Image, ImageAccess, ImageDimensions, ImageFormatInfo, ImageSubresourceRange, ImageUsage,
};
use crate::{
    device::{Device, DeviceOwned},
    format::{ChromaSampling, Format, FormatFeatures},
    image::{ImageAspects, ImageCreateFlags, ImageTiling, ImageType, SampleCount},
    macros::{impl_id_counter, vulkan_enum},
    sampler::{ycbcr::SamplerYcbcrConversion, ComponentMapping},
    OomError, RequirementNotMet, RequiresOneOf, Version, VulkanError, VulkanObject,
};
use std::{
    error::Error,
    fmt::{Debug, Display, Error as FmtError, Formatter},
    hash::{Hash, Hasher},
    mem::MaybeUninit,
    num::NonZeroU64,
    ptr,
    sync::Arc,
};

/// A wrapper around an image that makes it available to shaders or framebuffers.
#[derive(Debug)]
pub struct ImageView<I>
where
    I: ImageAccess + ?Sized,
{
    handle: ash::vk::ImageView,
    image: Arc<I>,
    id: NonZeroU64,

    component_mapping: ComponentMapping,
    format: Option<Format>,
    format_features: FormatFeatures,
    sampler_ycbcr_conversion: Option<Arc<SamplerYcbcrConversion>>,
    subresource_range: ImageSubresourceRange,
    usage: ImageUsage,
    view_type: ImageViewType,

    filter_cubic: bool,
    filter_cubic_minmax: bool,
}

impl<I> ImageView<I>
where
    I: ImageAccess + ?Sized,
{
    /// Creates a new `ImageView`.
    ///
    /// # Panics
    ///
    /// - Panics if `create_info.array_layers` is empty.
    /// - Panics if `create_info.mip_levels` is empty.
    /// - Panics if `create_info.aspects` contains any aspects other than `color`, `depth`,
    ///   `stencil`, `plane0`, `plane1` or `plane2`.
    /// - Panics if `create_info.aspects` contains more more than one aspect, unless `depth` and
    ///   `stencil` are the only aspects selected.
    pub fn new(
        image: Arc<I>,
        create_info: ImageViewCreateInfo,
    ) -> Result<Arc<ImageView<I>>, ImageViewCreationError> {
        let format_features = Self::validate_new(&image, &create_info)?;

        unsafe {
            Ok(Self::new_unchecked_with_format_features(
                image,
                create_info,
                format_features,
            )?)
        }
    }

    fn validate_new(
        image: &I,
        create_info: &ImageViewCreateInfo,
    ) -> Result<FormatFeatures, ImageViewCreationError> {
        let &ImageViewCreateInfo {
            view_type,
            format,
            component_mapping,
            ref subresource_range,
            mut usage,
            ref sampler_ycbcr_conversion,
            _ne: _,
        } = create_info;

        let image_inner = image.inner().image;
        let device = image_inner.device();
        let format = format.unwrap();

        let level_count = subresource_range.mip_levels.end - subresource_range.mip_levels.start;
        let layer_count = subresource_range.array_layers.end - subresource_range.array_layers.start;

        // VUID-VkImageSubresourceRange-aspectMask-requiredbitmask
        assert!(!subresource_range.aspects.is_empty());

        // VUID-VkImageSubresourceRange-levelCount-01720
        assert!(level_count != 0);

        // VUID-VkImageSubresourceRange-layerCount-01721
        assert!(layer_count != 0);

        let default_usage = Self::get_default_usage(subresource_range.aspects, image_inner);

        let has_non_default_usage = if usage.is_empty() {
            usage = default_usage;
            false
        } else {
            usage == default_usage
        };

        // VUID-VkImageViewCreateInfo-viewType-parameter
        view_type.validate_device(device)?;

        // VUID-VkImageViewCreateInfo-format-parameter
        format.validate_device(device)?;

        // VUID-VkComponentMapping-r-parameter
        component_mapping.r.validate_device(device)?;

        // VUID-VkComponentMapping-g-parameter
        component_mapping.g.validate_device(device)?;

        // VUID-VkComponentMapping-b-parameter
        component_mapping.b.validate_device(device)?;

        // VUID-VkComponentMapping-a-parameter
        component_mapping.a.validate_device(device)?;

        // VUID-VkImageSubresourceRange-aspectMask-parameter
        subresource_range.aspects.validate_device(device)?;

        assert!(!subresource_range.aspects.intersects(
            ImageAspects::METADATA
                | ImageAspects::MEMORY_PLANE_0
                | ImageAspects::MEMORY_PLANE_1
                | ImageAspects::MEMORY_PLANE_2
        ));
        assert!({
            subresource_range.aspects.count() == 1
                || subresource_range
                    .aspects
                    .contains(ImageAspects::DEPTH | ImageAspects::STENCIL)
                    && !subresource_range.aspects.intersects(
                        ImageAspects::COLOR
                            | ImageAspects::PLANE_0
                            | ImageAspects::PLANE_1
                            | ImageAspects::PLANE_2,
                    )
        });

        // Get format features
        let format_features = unsafe { Self::get_format_features(format, image_inner) };

        // No VUID apparently, but this seems like something we want to check?
        if !image_inner
            .format()
            .unwrap()
            .aspects()
            .contains(subresource_range.aspects)
        {
            return Err(ImageViewCreationError::ImageAspectsNotCompatible {
                aspects: subresource_range.aspects,
                image_aspects: image_inner.format().unwrap().aspects(),
            });
        }

        // VUID-VkImageViewCreateInfo-None-02273
        if format_features == FormatFeatures::default() {
            return Err(ImageViewCreationError::FormatNotSupported);
        }

        // Check for compatibility with the image
        let image_type = image.dimensions().image_type();

        // VUID-VkImageViewCreateInfo-subResourceRange-01021
        if !view_type.is_compatible_with(image_type) {
            return Err(ImageViewCreationError::ImageTypeNotCompatible);
        }

        // VUID-VkImageViewCreateInfo-image-01003
        if (view_type == ImageViewType::Cube || view_type == ImageViewType::CubeArray)
            && !image_inner
                .flags()
                .intersects(ImageCreateFlags::CUBE_COMPATIBLE)
        {
            return Err(ImageViewCreationError::ImageNotCubeCompatible);
        }

        // VUID-VkImageViewCreateInfo-viewType-01004
        if view_type == ImageViewType::CubeArray && !device.enabled_features().image_cube_array {
            return Err(ImageViewCreationError::RequirementNotMet {
                required_for: "`create_info.viewtype` is `ImageViewType::CubeArray`",
                requires_one_of: RequiresOneOf {
                    features: &["image_cube_array"],
                    ..Default::default()
                },
            });
        }

        // VUID-VkImageViewCreateInfo-subresourceRange-01718
        if subresource_range.mip_levels.end > image_inner.mip_levels() {
            return Err(ImageViewCreationError::MipLevelsOutOfRange {
                range_end: subresource_range.mip_levels.end,
                max: image_inner.mip_levels(),
            });
        }

        if image_type == ImageType::Dim3d
            && (view_type == ImageViewType::Dim2d || view_type == ImageViewType::Dim2dArray)
        {
            // VUID-VkImageViewCreateInfo-image-01005
            if !image_inner
                .flags()
                .intersects(ImageCreateFlags::ARRAY_2D_COMPATIBLE)
            {
                return Err(ImageViewCreationError::ImageNotArray2dCompatible);
            }

            // VUID-VkImageViewCreateInfo-image-04970
            if level_count != 1 {
                return Err(ImageViewCreationError::Array2dCompatibleMultipleMipLevels);
            }

            // VUID-VkImageViewCreateInfo-image-02724
            // VUID-VkImageViewCreateInfo-subresourceRange-02725
            // We're using the depth dimension as array layers, but because of mip scaling, the
            // depth, and therefore number of layers available, shrinks as the mip level gets
            // higher.
            let max = image_inner
                .dimensions()
                .mip_level_dimensions(subresource_range.mip_levels.start)
                .unwrap()
                .depth();
            if subresource_range.array_layers.end > max {
                return Err(ImageViewCreationError::ArrayLayersOutOfRange {
                    range_end: subresource_range.array_layers.end,
                    max,
                });
            }
        } else {
            // VUID-VkImageViewCreateInfo-image-01482
            // VUID-VkImageViewCreateInfo-subresourceRange-01483
            if subresource_range.array_layers.end > image_inner.dimensions().array_layers() {
                return Err(ImageViewCreationError::ArrayLayersOutOfRange {
                    range_end: subresource_range.array_layers.end,
                    max: image_inner.dimensions().array_layers(),
                });
            }
        }

        // VUID-VkImageViewCreateInfo-image-04972
        if image_inner.samples() != SampleCount::Sample1
            && !(view_type == ImageViewType::Dim2d || view_type == ImageViewType::Dim2dArray)
        {
            return Err(ImageViewCreationError::MultisamplingNot2d);
        }

        /* Check usage requirements */

        if has_non_default_usage {
            if !(device.api_version() >= Version::V1_1
                || device.enabled_extensions().khr_maintenance2)
            {
                return Err(ImageViewCreationError::RequirementNotMet {
                    required_for: "`create_info.usage` is not the default value",
                    requires_one_of: RequiresOneOf {
                        api_version: Some(Version::V1_1),
                        device_extensions: &["khr_maintenance2"],
                        ..Default::default()
                    },
                });
            }

            // VUID-VkImageViewUsageCreateInfo-usage-parameter
            usage.validate_device(device)?;

            // VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask
            assert!(!usage.is_empty());

            // VUID-VkImageViewCreateInfo-pNext-02662
            // VUID-VkImageViewCreateInfo-pNext-02663
            // VUID-VkImageViewCreateInfo-pNext-02664
            if !default_usage.contains(usage) {
                return Err(ImageViewCreationError::UsageNotSupportedByImage {
                    usage,
                    supported_usage: default_usage,
                });
            }
        }

        // VUID-VkImageViewCreateInfo-image-04441
        if !image_inner.usage().intersects(
            ImageUsage::SAMPLED
                | ImageUsage::STORAGE
                | ImageUsage::COLOR_ATTACHMENT
                | ImageUsage::DEPTH_STENCIL_ATTACHMENT
                | ImageUsage::INPUT_ATTACHMENT
                | ImageUsage::TRANSIENT_ATTACHMENT,
        ) {
            return Err(ImageViewCreationError::ImageMissingUsage);
        }

        // VUID-VkImageViewCreateInfo-usage-02274
        if usage.intersects(ImageUsage::SAMPLED)
            && !format_features.intersects(FormatFeatures::SAMPLED_IMAGE)
        {
            return Err(ImageViewCreationError::FormatUsageNotSupported { usage: "sampled" });
        }

        // VUID-VkImageViewCreateInfo-usage-02275
        if usage.intersects(ImageUsage::STORAGE)
            && !format_features.intersects(FormatFeatures::STORAGE_IMAGE)
        {
            return Err(ImageViewCreationError::FormatUsageNotSupported { usage: "storage" });
        }

        // VUID-VkImageViewCreateInfo-usage-02276
        if usage.intersects(ImageUsage::COLOR_ATTACHMENT)
            && !format_features.intersects(FormatFeatures::COLOR_ATTACHMENT)
        {
            return Err(ImageViewCreationError::FormatUsageNotSupported {
                usage: "color_attachment",
            });
        }

        // VUID-VkImageViewCreateInfo-usage-02277
        if usage.intersects(ImageUsage::DEPTH_STENCIL_ATTACHMENT)
            && !format_features.intersects(FormatFeatures::DEPTH_STENCIL_ATTACHMENT)
        {
            return Err(ImageViewCreationError::FormatUsageNotSupported {
                usage: "depth_stencil_attachment",
            });
        }

        // VUID-VkImageViewCreateInfo-usage-02652
        if usage.intersects(ImageUsage::INPUT_ATTACHMENT)
            && !format_features.intersects(
                FormatFeatures::COLOR_ATTACHMENT | FormatFeatures::DEPTH_STENCIL_ATTACHMENT,
            )
        {
            return Err(ImageViewCreationError::FormatUsageNotSupported {
                usage: "input_attachment",
            });
        }

        /* Check flags requirements */

        if Some(format) != image_inner.format() {
            // VUID-VkImageViewCreateInfo-image-01762
            if !image_inner
                .flags()
                .intersects(ImageCreateFlags::MUTABLE_FORMAT)
                || !image_inner.format().unwrap().planes().is_empty()
                    && subresource_range.aspects.intersects(ImageAspects::COLOR)
            {
                return Err(ImageViewCreationError::FormatNotCompatible);
            }

            // VUID-VkImageViewCreateInfo-imageViewFormatReinterpretation-04466
            // TODO: it is unclear what the number of bits is for compressed formats.
            // See https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/2361
            if device.enabled_extensions().khr_portability_subset
                && !device.enabled_features().image_view_format_reinterpretation
                && format.components() != image_inner.format().unwrap().components()
            {
                return Err(ImageViewCreationError::RequirementNotMet {
                    required_for: "this device is a portability subset device, and the format of \
                        the image view does not have the same components and number of bits per \
                        component as the parent image",
                    requires_one_of: RequiresOneOf {
                        features: &["image_view_format_reinterpretation"],
                        ..Default::default()
                    },
                });
            }

            if image_inner
                .flags()
                .intersects(ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE)
            {
                // VUID-VkImageViewCreateInfo-image-01583
                if !(format.compatibility() == image_inner.format().unwrap().compatibility()
                    || format.block_size() == image_inner.format().unwrap().block_size())
                {
                    return Err(ImageViewCreationError::FormatNotCompatible);
                }

                if format.compression().is_none() {
                    // VUID-VkImageViewCreateInfo-image-01584
                    if layer_count != 1 {
                        return Err(
                            ImageViewCreationError::BlockTexelViewCompatibleMultipleArrayLayers,
                        );
                    }

                    // VUID-VkImageViewCreateInfo-image-01584
                    if level_count != 1 {
                        return Err(
                            ImageViewCreationError::BlockTexelViewCompatibleMultipleMipLevels,
                        );
                    }
                }
            } else {
                if image_inner.format().unwrap().planes().is_empty() {
                    // VUID-VkImageViewCreateInfo-image-01761
                    if format.compatibility() != image_inner.format().unwrap().compatibility() {
                        return Err(ImageViewCreationError::FormatNotCompatible);
                    }
                } else {
                    let plane = if subresource_range.aspects.intersects(ImageAspects::PLANE_0) {
                        0
                    } else if subresource_range.aspects.intersects(ImageAspects::PLANE_1) {
                        1
                    } else if subresource_range.aspects.intersects(ImageAspects::PLANE_2) {
                        2
                    } else {
                        unreachable!()
                    };
                    let plane_format = image_inner.format().unwrap().planes()[plane];

                    // VUID-VkImageViewCreateInfo-image-01586
                    if format.compatibility() != plane_format.compatibility() {
                        return Err(ImageViewCreationError::FormatNotCompatible);
                    }
                }
            }
        }

        // VUID-VkImageViewCreateInfo-imageViewType-04973
        if (view_type == ImageViewType::Dim1d
            || view_type == ImageViewType::Dim2d
            || view_type == ImageViewType::Dim3d)
            && layer_count != 1
        {
            return Err(ImageViewCreationError::TypeNonArrayedMultipleArrayLayers);
        }
        // VUID-VkImageViewCreateInfo-viewType-02960
        else if view_type == ImageViewType::Cube && layer_count != 6 {
            return Err(ImageViewCreationError::TypeCubeNot6ArrayLayers);
        }
        // VUID-VkImageViewCreateInfo-viewType-02961
        else if view_type == ImageViewType::CubeArray && layer_count % 6 != 0 {
            return Err(ImageViewCreationError::TypeCubeArrayNotMultipleOf6ArrayLayers);
        }

        // VUID-VkImageViewCreateInfo-imageViewFormatSwizzle-04465
        if device.enabled_extensions().khr_portability_subset
            && !device.enabled_features().image_view_format_swizzle
            && !component_mapping.is_identity()
        {
            return Err(ImageViewCreationError::RequirementNotMet {
                required_for: "this device is a portability subset device, and \
                    `create_info.component_mapping` is not the identity mapping",
                requires_one_of: RequiresOneOf {
                    features: &["image_view_format_swizzle"],
                    ..Default::default()
                },
            });
        }

        // VUID-VkImageViewCreateInfo-format-04714
        // VUID-VkImageViewCreateInfo-format-04715
        match format.ycbcr_chroma_sampling() {
            Some(ChromaSampling::Mode422) => {
                if image_inner.dimensions().width() % 2 != 0 {
                    return Err(
                        ImageViewCreationError::FormatChromaSubsamplingInvalidImageDimensions,
                    );
                }
            }
            Some(ChromaSampling::Mode420) => {
                if image_inner.dimensions().width() % 2 != 0
                    || image_inner.dimensions().height() % 2 != 0
                {
                    return Err(
                        ImageViewCreationError::FormatChromaSubsamplingInvalidImageDimensions,
                    );
                }
            }
            _ => (),
        }

        // Don't need to check features because you can't create a conversion object without the
        // feature anyway.
        if let Some(conversion) = &sampler_ycbcr_conversion {
            assert_eq!(device, conversion.device());

            // VUID-VkImageViewCreateInfo-pNext-01970
            if !component_mapping.is_identity() {
                return Err(
                    ImageViewCreationError::SamplerYcbcrConversionComponentMappingNotIdentity {
                        component_mapping,
                    },
                );
            }
        } else {
            // VUID-VkImageViewCreateInfo-format-06415
            if format.ycbcr_chroma_sampling().is_some() {
                return Err(
                    ImageViewCreationError::FormatRequiresSamplerYcbcrConversion { format },
                );
            }
        }

        Ok(format_features)
    }

    #[cfg_attr(not(feature = "document_unchecked"), doc(hidden))]
    pub unsafe fn new_unchecked(
        image: Arc<I>,
        create_info: ImageViewCreateInfo,
    ) -> Result<Arc<Self>, VulkanError> {
        let format_features =
            Self::get_format_features(create_info.format.unwrap(), image.inner().image);
        Self::new_unchecked_with_format_features(image, create_info, format_features)
    }

    unsafe fn new_unchecked_with_format_features(
        image: Arc<I>,
        create_info: ImageViewCreateInfo,
        format_features: FormatFeatures,
    ) -> Result<Arc<Self>, VulkanError> {
        let &ImageViewCreateInfo {
            view_type,
            format,
            component_mapping,
            ref subresource_range,
            mut usage,
            ref sampler_ycbcr_conversion,
            _ne: _,
        } = &create_info;

        let image_inner = image.inner().image;
        let device = image_inner.device();

        let default_usage = Self::get_default_usage(subresource_range.aspects, image_inner);

        let has_non_default_usage = if usage.is_empty() {
            usage = default_usage;
            false
        } else {
            usage == default_usage
        };

        let mut info_vk = ash::vk::ImageViewCreateInfo {
            flags: ash::vk::ImageViewCreateFlags::empty(),
            image: image_inner.handle(),
            view_type: view_type.into(),
            format: format.unwrap().into(),
            components: component_mapping.into(),
            subresource_range: subresource_range.clone().into(),
            ..Default::default()
        };
        let mut image_view_usage_info_vk = None;
        let mut sampler_ycbcr_conversion_info_vk = None;

        if has_non_default_usage {
            let next = image_view_usage_info_vk.insert(ash::vk::ImageViewUsageCreateInfo {
                usage: usage.into(),
                ..Default::default()
            });

            next.p_next = info_vk.p_next;
            info_vk.p_next = next as *const _ as *const _;
        }

        if let Some(conversion) = sampler_ycbcr_conversion {
            let next =
                sampler_ycbcr_conversion_info_vk.insert(ash::vk::SamplerYcbcrConversionInfo {
                    conversion: conversion.handle(),
                    ..Default::default()
                });

            next.p_next = info_vk.p_next;
            info_vk.p_next = next as *const _ as *const _;
        }

        let handle = {
            let fns = device.fns();
            let mut output = MaybeUninit::uninit();
            (fns.v1_0.create_image_view)(
                device.handle(),
                &info_vk,
                ptr::null(),
                output.as_mut_ptr(),
            )
            .result()
            .map_err(VulkanError::from)?;
            output.assume_init()
        };

        Self::from_handle_with_format_features(image, handle, create_info, format_features)
    }

    /// Creates a default `ImageView`. Equivalent to
    /// `ImageView::new(image, ImageViewCreateInfo::from_image(image))`.
    pub fn new_default(image: Arc<I>) -> Result<Arc<ImageView<I>>, ImageViewCreationError> {
        let create_info = ImageViewCreateInfo::from_image(&image);
        Self::new(image, create_info)
    }

    /// Creates a new `ImageView` from a raw object handle.
    ///
    /// # Safety
    ///
    /// - `handle` must be a valid Vulkan object handle created from `image`.
    /// - `create_info` must match the info used to create the object.
    pub unsafe fn from_handle(
        image: Arc<I>,
        handle: ash::vk::ImageView,
        create_info: ImageViewCreateInfo,
    ) -> Result<Arc<Self>, VulkanError> {
        let format_features =
            Self::get_format_features(create_info.format.unwrap(), image.inner().image);
        Self::from_handle_with_format_features(image, handle, create_info, format_features)
    }

    unsafe fn from_handle_with_format_features(
        image: Arc<I>,
        handle: ash::vk::ImageView,
        create_info: ImageViewCreateInfo,
        format_features: FormatFeatures,
    ) -> Result<Arc<Self>, VulkanError> {
        let ImageViewCreateInfo {
            view_type,
            format,
            component_mapping,
            subresource_range,
            mut usage,
            sampler_ycbcr_conversion,
            _ne: _,
        } = create_info;

        let image_inner = image.inner().image;
        let device = image_inner.device();

        if usage.is_empty() {
            usage = Self::get_default_usage(subresource_range.aspects, image_inner);
        }

        let mut filter_cubic = false;
        let mut filter_cubic_minmax = false;

        if device
            .physical_device()
            .supported_extensions()
            .ext_filter_cubic
        {
            // Use unchecked, because all validation has been done above or is validated by the
            // image.
            let properties =
                device
                    .physical_device()
                    .image_format_properties_unchecked(ImageFormatInfo {
                        flags: image_inner.flags(),
                        format: image_inner.format(),
                        image_type: image.dimensions().image_type(),
                        tiling: image_inner.tiling(),
                        usage: image_inner.usage(),
                        image_view_type: Some(view_type),
                        ..Default::default()
                    })?;

            if let Some(properties) = properties {
                filter_cubic = properties.filter_cubic;
                filter_cubic_minmax = properties.filter_cubic_minmax;
            }
        }

        Ok(Arc::new(ImageView {
            handle,
            image,
            id: Self::next_id(),
            view_type,
            format,
            format_features,
            component_mapping,
            subresource_range,
            usage,
            sampler_ycbcr_conversion,
            filter_cubic,
            filter_cubic_minmax,
        }))
    }

    // https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateInfo.html#_description
    fn get_default_usage(aspects: ImageAspects, image: &Image) -> ImageUsage {
        let has_stencil_aspect = aspects.intersects(ImageAspects::STENCIL);
        let has_non_stencil_aspect = !(aspects - ImageAspects::STENCIL).is_empty();

        if has_stencil_aspect && has_non_stencil_aspect {
            image.usage() & image.stencil_usage()
        } else if has_stencil_aspect {
            image.stencil_usage()
        } else if has_non_stencil_aspect {
            image.usage()
        } else {
            unreachable!()
        }
    }

    // https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/chap12.html#resources-image-view-format-features
    unsafe fn get_format_features(format: Format, image: &Image) -> FormatFeatures {
        let device = image.device();

        let mut format_features = if Some(format) != image.format() {
            // Use unchecked, because all validation should have been done before calling.
            let format_properties = device.physical_device().format_properties_unchecked(format);

            match image.tiling() {
                ImageTiling::Optimal => format_properties.optimal_tiling_features,
                ImageTiling::Linear => format_properties.linear_tiling_features,
                ImageTiling::DrmFormatModifier => format_properties.linear_tiling_features,
            }
        } else {
            image.format_features()
        };

        if !device.enabled_extensions().khr_format_feature_flags2 {
            if format.type_color().is_none()
                && format_features.intersects(FormatFeatures::SAMPLED_IMAGE)
            {
                format_features |= FormatFeatures::SAMPLED_IMAGE_DEPTH_COMPARISON;
            }

            if format.shader_storage_image_without_format() {
                if device
                    .enabled_features()
                    .shader_storage_image_read_without_format
                {
                    format_features |= FormatFeatures::STORAGE_READ_WITHOUT_FORMAT;
                }

                if device
                    .enabled_features()
                    .shader_storage_image_write_without_format
                {
                    format_features |= FormatFeatures::STORAGE_WRITE_WITHOUT_FORMAT;
                }
            }
        }

        format_features
    }

    /// Returns the wrapped image that this image view was created from.
    pub fn image(&self) -> &Arc<I> {
        &self.image
    }
}

impl<I> Drop for ImageView<I>
where
    I: ImageAccess + ?Sized,
{
    fn drop(&mut self) {
        unsafe {
            let device = self.device();
            let fns = device.fns();
            (fns.v1_0.destroy_image_view)(device.handle(), self.handle, ptr::null());
        }
    }
}

unsafe impl<I> VulkanObject for ImageView<I>
where
    I: ImageAccess + ?Sized,
{
    type Handle = ash::vk::ImageView;

    fn handle(&self) -> Self::Handle {
        self.handle
    }
}

unsafe impl<I> DeviceOwned for ImageView<I>
where
    I: ImageAccess + ?Sized,
{
    fn device(&self) -> &Arc<Device> {
        self.image.inner().image.device()
    }
}

impl_id_counter!(ImageView<I: ImageAccess + ?Sized>);

/// Parameters to create a new `ImageView`.
#[derive(Debug)]
pub struct ImageViewCreateInfo {
    /// The image view type.
    ///
    /// The view type must be compatible with the dimensions of the image and the selected array
    /// layers.
    ///
    /// The default value is [`ImageViewType::Dim2d`].
    pub view_type: ImageViewType,

    /// The format of the image view.
    ///
    /// If this is set to a format that is different from the image, the image must be created with
    /// the `mutable_format` flag.
    ///
    /// On [portability subset](crate::instance#portability-subset-devices-and-the-enumerate_portability-flag)
    /// devices, if `format` does not have the same number of components and bits per component as
    /// the parent image's format, the
    /// [`image_view_format_reinterpretation`](crate::device::Features::image_view_format_reinterpretation)
    /// feature must be enabled on the device.
    ///
    /// The default value is `None`, which must be overridden.
    pub format: Option<Format>,

    /// How to map components of each pixel.
    ///
    /// On [portability subset](crate::instance#portability-subset-devices-and-the-enumerate_portability-flag)
    /// devices, if `component_mapping` is not the identity mapping, the
    /// [`image_view_format_swizzle`](crate::device::Features::image_view_format_swizzle)
    /// feature must be enabled on the device.
    ///
    /// The default value is [`ComponentMapping::identity()`].
    pub component_mapping: ComponentMapping,

    /// The subresource range of the image that the view should cover.
    ///
    /// The default value is empty, which must be overridden.
    pub subresource_range: ImageSubresourceRange,

    /// How the image view is going to be used.
    ///
    /// If `usage` is empty, then a default value is used based on the parent image's usages.
    /// Depending on the image aspects selected in `subresource_range`,
    /// the default `usage` will be equal to the parent image's `usage`, its `stencil_usage`,
    /// or the intersection of the two.
    ///
    /// If you set `usage` to a different value from the default, then the device API version must
    /// be at least 1.1, or the [`khr_maintenance2`](crate::device::DeviceExtensions::khr_maintenance2)
    /// extension must be enabled on the device. The specified `usage` must be a subset of the
    /// default value; usages that are not set for the parent image are not allowed.
    ///
    /// The default value is [`ImageUsage::empty()`].
    pub usage: ImageUsage,

    /// The sampler YCbCr conversion to be used with the image view.
    ///
    /// If set to `Some`, several restrictions apply:
    /// - The `component_mapping` must be the identity swizzle for all components.
    /// - If the image view is to be used in a shader, it must be in a combined image sampler
    ///   descriptor, a separate sampled image descriptor is not allowed.
    /// - The corresponding sampler must have the same sampler YCbCr object or an identically
    ///   created one, and must be used as an immutable sampler within a descriptor set layout.
    ///
    /// The default value is `None`.
    pub sampler_ycbcr_conversion: Option<Arc<SamplerYcbcrConversion>>,

    pub _ne: crate::NonExhaustive,
}

impl Default for ImageViewCreateInfo {
    #[inline]
    fn default() -> Self {
        Self {
            view_type: ImageViewType::Dim2d,
            format: None,
            component_mapping: ComponentMapping::identity(),
            subresource_range: ImageSubresourceRange {
                aspects: ImageAspects::empty(),
                array_layers: 0..0,
                mip_levels: 0..0,
            },
            usage: ImageUsage::empty(),
            sampler_ycbcr_conversion: None,
            _ne: crate::NonExhaustive(()),
        }
    }
}

impl ImageViewCreateInfo {
    /// Returns an `ImageViewCreateInfo` with the `view_type` determined from the image type and
    /// array layers, and `subresource_range` determined from the image format and covering the
    /// whole image.
    pub fn from_image(image: &(impl ImageAccess + ?Sized)) -> Self {
        Self {
            view_type: match image.dimensions() {
                ImageDimensions::Dim1d {
                    array_layers: 1, ..
                } => ImageViewType::Dim1d,
                ImageDimensions::Dim1d { .. } => ImageViewType::Dim1dArray,
                ImageDimensions::Dim2d {
                    array_layers: 1, ..
                } => ImageViewType::Dim2d,
                ImageDimensions::Dim2d { .. } => ImageViewType::Dim2dArray,
                ImageDimensions::Dim3d { .. } => ImageViewType::Dim3d,
            },
            format: Some(image.format()),
            subresource_range: image.subresource_range(),
            ..Default::default()
        }
    }
}

/// Error that can happen when creating an image view.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ImageViewCreationError {
    /// Allocating memory failed.
    OomError(OomError),

    RequirementNotMet {
        required_for: &'static str,
        requires_one_of: RequiresOneOf,
    },

    /// A 2D image view was requested from a 3D image, but a range of multiple mip levels was
    /// specified.
    Array2dCompatibleMultipleMipLevels,

    /// The specified range of array layers was not a subset of those in the image.
    ArrayLayersOutOfRange { range_end: u32, max: u32 },

    /// The image has the `block_texel_view_compatible` flag, but a range of multiple array layers
    /// was specified.
    BlockTexelViewCompatibleMultipleArrayLayers,

    /// The image has the `block_texel_view_compatible` flag, but a range of multiple mip levels
    /// was specified.
    BlockTexelViewCompatibleMultipleMipLevels,

    /// The requested format has chroma subsampling, but the width and/or height of the image was
    /// not a multiple of 2.
    FormatChromaSubsamplingInvalidImageDimensions,

    /// The requested format was not compatible with the image.
    FormatNotCompatible,

    /// The given format was not supported by the device.
    FormatNotSupported,

    /// The format requires a sampler YCbCr conversion, but none was provided.
    FormatRequiresSamplerYcbcrConversion { format: Format },

    /// A requested usage flag was not supported by the given format.
    FormatUsageNotSupported { usage: &'static str },

    /// An aspect was selected that was not present in the image.
    ImageAspectsNotCompatible {
        aspects: ImageAspects,
        image_aspects: ImageAspects,
    },

    /// The image was not created with
    /// [one of the required usages](https://registry.khronos.org/vulkan/specs/1.2-extensions/html/vkspec.html#valid-imageview-imageusage)
    /// for image views.
    ImageMissingUsage,

    /// A 2D image view was requested from a 3D image, but the image was not created with the
    /// `array_2d_compatible` flag.
    ImageNotArray2dCompatible,

    /// A cube image view type was requested, but the image was not created with the
    /// `cube_compatible` flag.
    ImageNotCubeCompatible,

    /// The given image view type was not compatible with the type of the image.
    ImageTypeNotCompatible,

    /// The requested [`ImageViewType`] was not compatible with the image, or with the specified
    /// ranges of array layers and mipmap levels.
    IncompatibleType,

    /// The specified range of mip levels was not a subset of those in the image.
    MipLevelsOutOfRange { range_end: u32, max: u32 },

    /// The image has multisampling enabled, but the image view type was not `Dim2d` or
    /// `Dim2dArray`.
    MultisamplingNot2d,

    /// Sampler YCbCr conversion was enabled, but `component_mapping` was not the identity mapping.
    SamplerYcbcrConversionComponentMappingNotIdentity { component_mapping: ComponentMapping },

    /// The `CubeArray` image view type was specified, but the range of array layers did not have a
    /// size that is a multiple 6.
    TypeCubeArrayNotMultipleOf6ArrayLayers,

    /// The `Cube` image view type was specified, but the range of array layers did not have a size
    /// of 6.
    TypeCubeNot6ArrayLayers,

    /// A non-arrayed image view type was specified, but a range of multiple array layers was
    /// specified.
    TypeNonArrayedMultipleArrayLayers,

    /// The provided `usage` is not supported by the parent image.
    UsageNotSupportedByImage {
        usage: ImageUsage,
        supported_usage: ImageUsage,
    },
}

impl Error for ImageViewCreationError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            ImageViewCreationError::OomError(err) => Some(err),
            _ => None,
        }
    }
}

impl Display for ImageViewCreationError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
        match self {
            Self::OomError(_) => write!(f, "allocating memory failed",),
            Self::RequirementNotMet {
                required_for,
                requires_one_of,
            } => write!(
                f,
                "a requirement was not met for: {}; requires one of: {}",
                required_for, requires_one_of,
            ),
            Self::Array2dCompatibleMultipleMipLevels => write!(
                f,
                "a 2D image view was requested from a 3D image, but a range of multiple mip levels \
                was specified",
            ),
            Self::ArrayLayersOutOfRange { .. } => write!(
                f,
                "the specified range of array layers was not a subset of those in the image",
            ),
            Self::BlockTexelViewCompatibleMultipleArrayLayers => write!(
                f,
                "the image has the `block_texel_view_compatible` flag, but a range of multiple \
                array layers was specified",
            ),
            Self::BlockTexelViewCompatibleMultipleMipLevels => write!(
                f,
                "the image has the `block_texel_view_compatible` flag, but a range of multiple mip \
                levels was specified",
            ),
            Self::FormatChromaSubsamplingInvalidImageDimensions => write!(
                f,
                "the requested format has chroma subsampling, but the width and/or height of the \
                image was not a multiple of 2",
            ),
            Self::FormatNotCompatible => {
                write!(f, "the requested format was not compatible with the image")
            }
            Self::FormatNotSupported => {
                write!(f, "the given format was not supported by the device")
            }
            Self::FormatRequiresSamplerYcbcrConversion { .. } => write!(
                f,
                "the format requires a sampler YCbCr conversion, but none was provided",
            ),
            Self::FormatUsageNotSupported { .. } => write!(
                f,
                "a requested usage flag was not supported by the given format",
            ),
            Self::ImageAspectsNotCompatible { .. } => write!(
                f,
                "an aspect was selected that was not present in the image",
            ),
            Self::ImageMissingUsage => write!(
                f,
                "the image was not created with one of the required usages for image views",
            ),
            Self::ImageNotArray2dCompatible => write!(
                f,
                "a 2D image view was requested from a 3D image, but the image was not created with \
                the `array_2d_compatible` flag",
            ),
            Self::ImageNotCubeCompatible => write!(
                f,
                "a cube image view type was requested, but the image was not created with the \
                `cube_compatible` flag",
            ),
            Self::ImageTypeNotCompatible => write!(
                f,
                "the given image view type was not compatible with the type of the image",
            ),
            Self::IncompatibleType => write!(
                f,
                "image view type is not compatible with image, array layers or mipmap levels",
            ),
            Self::MipLevelsOutOfRange { .. } => write!(
                f,
                "the specified range of mip levels was not a subset of those in the image",
            ),
            Self::MultisamplingNot2d => write!(
                f,
                "the image has multisampling enabled, but the image view type was not `Dim2d` or \
                `Dim2dArray`",
            ),
            Self::SamplerYcbcrConversionComponentMappingNotIdentity { .. } => write!(
                f,
                "sampler YCbCr conversion was enabled, but `component_mapping` was not the \
                identity mapping",
            ),
            Self::TypeCubeArrayNotMultipleOf6ArrayLayers => write!(
                f,
                "the `CubeArray` image view type was specified, but the range of array layers did \
                not have a size that is a multiple 6",
            ),
            Self::TypeCubeNot6ArrayLayers => write!(
                f,
                "the `Cube` image view type was specified, but the range of array layers did not \
                have a size of 6",
            ),
            Self::TypeNonArrayedMultipleArrayLayers => write!(
                f,
                "a non-arrayed image view type was specified, but a range of multiple array layers \
                was specified",
            ),
            Self::UsageNotSupportedByImage {
                usage: _,
                supported_usage: _,
            } => write!(
                f,
                "the provided `usage` is not supported by the parent image",
            ),
        }
    }
}

impl From<OomError> for ImageViewCreationError {
    fn from(err: OomError) -> ImageViewCreationError {
        ImageViewCreationError::OomError(err)
    }
}

impl From<VulkanError> for ImageViewCreationError {
    fn from(err: VulkanError) -> ImageViewCreationError {
        match err {
            err @ VulkanError::OutOfHostMemory => OomError::from(err).into(),
            err @ VulkanError::OutOfDeviceMemory => OomError::from(err).into(),
            _ => panic!("unexpected error: {:?}", err),
        }
    }
}

impl From<RequirementNotMet> for ImageViewCreationError {
    fn from(err: RequirementNotMet) -> Self {
        Self::RequirementNotMet {
            required_for: err.required_for,
            requires_one_of: err.requires_one_of,
        }
    }
}

vulkan_enum! {
    #[non_exhaustive]

    /// The geometry type of an image view.
    ImageViewType impl {
        /// Returns whether the type is arrayed.
        #[inline]
        pub fn is_arrayed(self) -> bool {
            match self {
                Self::Dim1d | Self::Dim2d | Self::Dim3d | Self::Cube => false,
                Self::Dim1dArray | Self::Dim2dArray | Self::CubeArray => true,
            }
        }

        /// Returns whether `self` is compatible with the given `image_type`.
        #[inline]
        pub fn is_compatible_with(self, image_type: ImageType) -> bool {
            matches!(
                (self, image_type,),
                (
                    ImageViewType::Dim1d | ImageViewType::Dim1dArray,
                    ImageType::Dim1d
                ) | (
                    ImageViewType::Dim2d | ImageViewType::Dim2dArray,
                    ImageType::Dim2d | ImageType::Dim3d
                ) | (
                    ImageViewType::Cube | ImageViewType::CubeArray,
                    ImageType::Dim2d
                ) | (ImageViewType::Dim3d, ImageType::Dim3d)
            )
        }
    }
    = ImageViewType(i32);

    // TODO: document
    Dim1d = TYPE_1D,

    // TODO: document
    Dim2d = TYPE_2D,

    // TODO: document
    Dim3d = TYPE_3D,

    // TODO: document
    Cube = CUBE,

    // TODO: document
    Dim1dArray = TYPE_1D_ARRAY,

    // TODO: document
    Dim2dArray = TYPE_2D_ARRAY,

    // TODO: document
    CubeArray = CUBE_ARRAY,
}

/// Trait for types that represent the GPU can access an image view.
pub unsafe trait ImageViewAbstract:
    VulkanObject<Handle = ash::vk::ImageView> + DeviceOwned + Debug + Send + Sync
{
    /// Returns the wrapped image that this image view was created from.
    fn image(&self) -> Arc<dyn ImageAccess>;

    /// Returns the component mapping of this view.
    fn component_mapping(&self) -> ComponentMapping;

    /// Returns the dimensions of this view.
    #[inline]
    fn dimensions(&self) -> ImageDimensions {
        let subresource_range = self.subresource_range();
        let array_layers =
            subresource_range.array_layers.end - subresource_range.array_layers.start;

        match self.image().dimensions() {
            ImageDimensions::Dim1d { width, .. } => ImageDimensions::Dim1d {
                width,
                array_layers,
            },
            ImageDimensions::Dim2d { width, height, .. } => ImageDimensions::Dim2d {
                width,
                height,
                array_layers,
            },
            ImageDimensions::Dim3d {
                width,
                height,
                depth,
            } => ImageDimensions::Dim3d {
                width,
                height,
                depth,
            },
        }
    }

    /// Returns whether the image view supports sampling with a
    /// [`Cubic`](crate::sampler::Filter::Cubic) `mag_filter` or `min_filter`.
    fn filter_cubic(&self) -> bool;

    /// Returns whether the image view supports sampling with a
    /// [`Cubic`](crate::sampler::Filter::Cubic) `mag_filter` or `min_filter`, and with a
    /// [`Min`](crate::sampler::SamplerReductionMode::Min) or
    /// [`Max`](crate::sampler::SamplerReductionMode::Max) `reduction_mode`.
    fn filter_cubic_minmax(&self) -> bool;

    /// Returns the format of this view. This can be different from the parent's format.
    fn format(&self) -> Option<Format>;

    /// Returns the features supported by the image view's format.
    fn format_features(&self) -> FormatFeatures;

    /// Returns the sampler YCbCr conversion that this image view was created with, if any.
    fn sampler_ycbcr_conversion(&self) -> Option<&Arc<SamplerYcbcrConversion>>;

    /// Returns the subresource range of the wrapped image that this view exposes.
    fn subresource_range(&self) -> &ImageSubresourceRange;

    /// Returns the usage of the image view.
    fn usage(&self) -> ImageUsage;

    /// Returns the [`ImageViewType`] of this image view.
    fn view_type(&self) -> ImageViewType;
}

unsafe impl<I> ImageViewAbstract for ImageView<I>
where
    I: ImageAccess + Debug + 'static,
{
    fn image(&self) -> Arc<dyn ImageAccess> {
        self.image.clone()
    }

    fn component_mapping(&self) -> ComponentMapping {
        self.component_mapping
    }

    fn filter_cubic(&self) -> bool {
        self.filter_cubic
    }

    fn filter_cubic_minmax(&self) -> bool {
        self.filter_cubic_minmax
    }

    fn format(&self) -> Option<Format> {
        self.format
    }

    fn format_features(&self) -> FormatFeatures {
        self.format_features
    }

    fn sampler_ycbcr_conversion(&self) -> Option<&Arc<SamplerYcbcrConversion>> {
        self.sampler_ycbcr_conversion.as_ref()
    }

    fn subresource_range(&self) -> &ImageSubresourceRange {
        &self.subresource_range
    }

    fn usage(&self) -> ImageUsage {
        self.usage
    }

    fn view_type(&self) -> ImageViewType {
        self.view_type
    }
}

unsafe impl ImageViewAbstract for ImageView<dyn ImageAccess> {
    #[inline]
    fn image(&self) -> Arc<dyn ImageAccess> {
        self.image.clone()
    }

    #[inline]
    fn component_mapping(&self) -> ComponentMapping {
        self.component_mapping
    }

    #[inline]
    fn filter_cubic(&self) -> bool {
        self.filter_cubic
    }

    #[inline]
    fn filter_cubic_minmax(&self) -> bool {
        self.filter_cubic_minmax
    }

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

    #[inline]
    fn format_features(&self) -> FormatFeatures {
        self.format_features
    }

    #[inline]
    fn sampler_ycbcr_conversion(&self) -> Option<&Arc<SamplerYcbcrConversion>> {
        self.sampler_ycbcr_conversion.as_ref()
    }

    #[inline]
    fn subresource_range(&self) -> &ImageSubresourceRange {
        &self.subresource_range
    }

    #[inline]
    fn usage(&self) -> ImageUsage {
        self.usage
    }

    #[inline]
    fn view_type(&self) -> ImageViewType {
        self.view_type
    }
}

impl PartialEq for dyn ImageViewAbstract {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.handle() == other.handle() && self.device() == other.device()
    }
}

impl Eq for dyn ImageViewAbstract {}

impl Hash for dyn ImageViewAbstract {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.handle().hash(state);
        self.device().hash(state);
    }
}