erupt 0.23.0+213

// DO NOT EDIT: @generated by erupt's generator
///<s>Vulkan Manual Page</s> · Constant
#[doc(alias = "VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION")]
pub const EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION: u32 = 1;
///<s>Vulkan Manual Page</s> · Constant
#[doc(alias = "VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME")]
pub const EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
    "VK_EXT_image_compression_control"
);
///<s>Vulkan Manual Page</s> · Constant
pub const FN_GET_IMAGE_SUBRESOURCE_LAYOUT2_EXT: *const std::os::raw::c_char = crate::cstr!(
    "vkGetImageSubresourceLayout2EXT"
);
///Provided by [`crate::extensions::ext_image_compression_control`]
impl crate::vk1_0::Result {
    pub const ERROR_COMPRESSION_EXHAUSTED_EXT: Self = Self(-1000338000);
}
///Provided by [`crate::extensions::ext_image_compression_control`]
impl crate::vk1_0::StructureType {
    pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(
        1000338000,
    );
    pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1000338001);
    pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1000338002);
    pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1000338003);
    pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1000338004);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFlagsEXT.html) · Bitmask of [`ImageCompressionFlagBitsEXT`]"]
    #[doc(alias = "VkImageCompressionFlagsEXT")] #[derive(Default)] #[repr(transparent)]
    pub struct ImageCompressionFlagsEXT : u32 { const DEFAULT_EXT =
    ImageCompressionFlagBitsEXT::DEFAULT_EXT.0; const FIXED_RATE_DEFAULT_EXT =
    ImageCompressionFlagBitsEXT::FIXED_RATE_DEFAULT_EXT.0; const FIXED_RATE_EXPLICIT_EXT
    = ImageCompressionFlagBitsEXT::FIXED_RATE_EXPLICIT_EXT.0; const DISABLED_EXT =
    ImageCompressionFlagBitsEXT::DISABLED_EXT.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFlagBitsEXT.html) · Bits enum of [`ImageCompressionFlagsEXT`]
#[doc(alias = "VkImageCompressionFlagBitsEXT")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct ImageCompressionFlagBitsEXT(pub u32);
impl ImageCompressionFlagBitsEXT {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> ImageCompressionFlagsEXT {
        ImageCompressionFlagsEXT::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for ImageCompressionFlagBitsEXT {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::DEFAULT_EXT => "DEFAULT_EXT",
                &Self::FIXED_RATE_DEFAULT_EXT => "FIXED_RATE_DEFAULT_EXT",
                &Self::FIXED_RATE_EXPLICIT_EXT => "FIXED_RATE_EXPLICIT_EXT",
                &Self::DISABLED_EXT => "DISABLED_EXT",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::ext_image_compression_control`]
impl crate::extensions::ext_image_compression_control::ImageCompressionFlagBitsEXT {
    pub const DEFAULT_EXT: Self = Self(0);
    pub const FIXED_RATE_DEFAULT_EXT: Self = Self(1);
    pub const FIXED_RATE_EXPLICIT_EXT: Self = Self(2);
    pub const DISABLED_EXT: Self = Self(4);
}
bitflags::bitflags! {
    #[doc =
    "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFixedRateFlagsEXT.html) · Bitmask of [`ImageCompressionFixedRateFlagBitsEXT`]"]
    #[doc(alias = "VkImageCompressionFixedRateFlagsEXT")] #[derive(Default)]
    #[repr(transparent)] pub struct ImageCompressionFixedRateFlagsEXT : u32 { const
    NONE_EXT = ImageCompressionFixedRateFlagBitsEXT::NONE_EXT.0; const _1BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_1BPC_EXT.0; const _2BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_2BPC_EXT.0; const _3BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_3BPC_EXT.0; const _4BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_4BPC_EXT.0; const _5BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_5BPC_EXT.0; const _6BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_6BPC_EXT.0; const _7BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_7BPC_EXT.0; const _8BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_8BPC_EXT.0; const _9BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_9BPC_EXT.0; const _10BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_10BPC_EXT.0; const _11BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_11BPC_EXT.0; const _12BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_12BPC_EXT.0; const _13BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_13BPC_EXT.0; const _14BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_14BPC_EXT.0; const _15BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_15BPC_EXT.0; const _16BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_16BPC_EXT.0; const _17BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_17BPC_EXT.0; const _18BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_18BPC_EXT.0; const _19BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_19BPC_EXT.0; const _20BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_20BPC_EXT.0; const _21BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_21BPC_EXT.0; const _22BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_22BPC_EXT.0; const _23BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_23BPC_EXT.0; const _24BPC_EXT =
    ImageCompressionFixedRateFlagBitsEXT::_24BPC_EXT.0; }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFixedRateFlagBitsEXT.html) · Bits enum of [`ImageCompressionFixedRateFlagsEXT`]
#[doc(alias = "VkImageCompressionFixedRateFlagBitsEXT")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct ImageCompressionFixedRateFlagBitsEXT(pub u32);
impl ImageCompressionFixedRateFlagBitsEXT {
    #[inline]
    ///Converts this enum variant to the corresponding bitmask
    pub const fn bitmask(&self) -> ImageCompressionFixedRateFlagsEXT {
        ImageCompressionFixedRateFlagsEXT::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for ImageCompressionFixedRateFlagBitsEXT {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(
            match self {
                &Self::NONE_EXT => "NONE_EXT",
                &Self::_1BPC_EXT => "1BPC_EXT",
                &Self::_2BPC_EXT => "2BPC_EXT",
                &Self::_3BPC_EXT => "3BPC_EXT",
                &Self::_4BPC_EXT => "4BPC_EXT",
                &Self::_5BPC_EXT => "5BPC_EXT",
                &Self::_6BPC_EXT => "6BPC_EXT",
                &Self::_7BPC_EXT => "7BPC_EXT",
                &Self::_8BPC_EXT => "8BPC_EXT",
                &Self::_9BPC_EXT => "9BPC_EXT",
                &Self::_10BPC_EXT => "10BPC_EXT",
                &Self::_11BPC_EXT => "11BPC_EXT",
                &Self::_12BPC_EXT => "12BPC_EXT",
                &Self::_13BPC_EXT => "13BPC_EXT",
                &Self::_14BPC_EXT => "14BPC_EXT",
                &Self::_15BPC_EXT => "15BPC_EXT",
                &Self::_16BPC_EXT => "16BPC_EXT",
                &Self::_17BPC_EXT => "17BPC_EXT",
                &Self::_18BPC_EXT => "18BPC_EXT",
                &Self::_19BPC_EXT => "19BPC_EXT",
                &Self::_20BPC_EXT => "20BPC_EXT",
                &Self::_21BPC_EXT => "21BPC_EXT",
                &Self::_22BPC_EXT => "22BPC_EXT",
                &Self::_23BPC_EXT => "23BPC_EXT",
                &Self::_24BPC_EXT => "24BPC_EXT",
                _ => "(unknown variant)",
            },
        )
    }
}
///Provided by [`crate::extensions::ext_image_compression_control`]
impl crate::extensions::ext_image_compression_control::ImageCompressionFixedRateFlagBitsEXT {
    pub const NONE_EXT: Self = Self(0);
    pub const _1BPC_EXT: Self = Self(1);
    pub const _2BPC_EXT: Self = Self(2);
    pub const _3BPC_EXT: Self = Self(4);
    pub const _4BPC_EXT: Self = Self(8);
    pub const _5BPC_EXT: Self = Self(16);
    pub const _6BPC_EXT: Self = Self(32);
    pub const _7BPC_EXT: Self = Self(64);
    pub const _8BPC_EXT: Self = Self(128);
    pub const _9BPC_EXT: Self = Self(256);
    pub const _10BPC_EXT: Self = Self(512);
    pub const _11BPC_EXT: Self = Self(1024);
    pub const _12BPC_EXT: Self = Self(2048);
    pub const _13BPC_EXT: Self = Self(4096);
    pub const _14BPC_EXT: Self = Self(8192);
    pub const _15BPC_EXT: Self = Self(16384);
    pub const _16BPC_EXT: Self = Self(32768);
    pub const _17BPC_EXT: Self = Self(65536);
    pub const _18BPC_EXT: Self = Self(131072);
    pub const _19BPC_EXT: Self = Self(262144);
    pub const _20BPC_EXT: Self = Self(524288);
    pub const _21BPC_EXT: Self = Self(1048576);
    pub const _22BPC_EXT: Self = Self(2097152);
    pub const _23BPC_EXT: Self = Self(4194304);
    pub const _24BPC_EXT: Self = Self(8388608);
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSubresourceLayout2EXT.html) · Function
#[allow(non_camel_case_types)]
pub type PFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn(
    device: crate::vk1_0::Device,
    image: crate::vk1_0::Image,
    p_subresource: *const crate::extensions::ext_image_compression_control::ImageSubresource2EXT,
    p_layout: *mut crate::extensions::ext_image_compression_control::SubresourceLayout2EXT,
) -> ();
impl<'a> crate::ExtendableFrom<'a, PhysicalDeviceImageCompressionControlFeaturesEXT>
for crate::vk1_0::DeviceCreateInfoBuilder<'a> {}
impl<
    'a,
> crate::ExtendableFrom<'a, PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_>>
for crate::vk1_0::DeviceCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionControlEXT>
for crate::vk1_0::ImageCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionControlEXTBuilder<'_>>
for crate::vk1_0::ImageCreateInfoBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionControlEXT>
for crate::extensions::khr_swapchain::SwapchainCreateInfoKHRBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionControlEXTBuilder<'_>>
for crate::extensions::khr_swapchain::SwapchainCreateInfoKHRBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, PhysicalDeviceImageCompressionControlFeaturesEXT>
for crate::vk1_1::PhysicalDeviceFeatures2Builder<'a> {}
impl<
    'a,
> crate::ExtendableFrom<'a, PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_>>
for crate::vk1_1::PhysicalDeviceFeatures2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionPropertiesEXT>
for crate::vk1_1::ImageFormatProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionPropertiesEXTBuilder<'_>>
for crate::vk1_1::ImageFormatProperties2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionControlEXT>
for crate::vk1_1::PhysicalDeviceImageFormatInfo2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionControlEXTBuilder<'_>>
for crate::vk1_1::PhysicalDeviceImageFormatInfo2Builder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionPropertiesEXT>
for crate::extensions::khr_get_surface_capabilities2::SurfaceFormat2KHRBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionPropertiesEXTBuilder<'_>>
for crate::extensions::khr_get_surface_capabilities2::SurfaceFormat2KHRBuilder<'a> {}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionControlEXT.html) · Structure
#[doc(alias = "VkImageCompressionControlEXT")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct ImageCompressionControlEXT {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub flags: crate::extensions::ext_image_compression_control::ImageCompressionFlagsEXT,
    pub compression_control_plane_count: u32,
    pub p_fixed_rate_flags: *mut crate::extensions::ext_image_compression_control::ImageCompressionFixedRateFlagsEXT,
}
impl ImageCompressionControlEXT {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::IMAGE_COMPRESSION_CONTROL_EXT;
}
impl Default for ImageCompressionControlEXT {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null(),
            flags: Default::default(),
            compression_control_plane_count: Default::default(),
            p_fixed_rate_flags: std::ptr::null_mut(),
        }
    }
}
impl std::fmt::Debug for ImageCompressionControlEXT {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("ImageCompressionControlEXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .field(
                "compression_control_plane_count",
                &self.compression_control_plane_count,
            )
            .field("p_fixed_rate_flags", &self.p_fixed_rate_flags)
            .finish()
    }
}
impl ImageCompressionControlEXT {
    #[inline]
    pub fn into_builder<'a>(self) -> ImageCompressionControlEXTBuilder<'a> {
        ImageCompressionControlEXTBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionControlEXT.html) · Builder of [`ImageCompressionControlEXT`]
#[repr(transparent)]
pub struct ImageCompressionControlEXTBuilder<'a>(
    ImageCompressionControlEXT,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> ImageCompressionControlEXTBuilder<'a> {
    #[inline]
    pub fn new() -> ImageCompressionControlEXTBuilder<'a> {
        ImageCompressionControlEXTBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn flags(
        mut self,
        flags: crate::extensions::ext_image_compression_control::ImageCompressionFlagsEXT,
    ) -> Self {
        self.0.flags = flags as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn fixed_rate_flags(
        mut self,
        fixed_rate_flags: &'a mut [crate::extensions::ext_image_compression_control::ImageCompressionFixedRateFlagsEXT],
    ) -> Self {
        self.0.p_fixed_rate_flags = fixed_rate_flags.as_ptr() as _;
        self.0.compression_control_plane_count = fixed_rate_flags.len() as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> ImageCompressionControlEXT {
        self.0
    }
}
impl<'a> std::default::Default for ImageCompressionControlEXTBuilder<'a> {
    fn default() -> ImageCompressionControlEXTBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for ImageCompressionControlEXTBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for ImageCompressionControlEXTBuilder<'a> {
    type Target = ImageCompressionControlEXT;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for ImageCompressionControlEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html) · Structure
#[doc(alias = "VkPhysicalDeviceImageCompressionControlFeaturesEXT")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhysicalDeviceImageCompressionControlFeaturesEXT {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub image_compression_control: crate::vk1_0::Bool32,
}
impl PhysicalDeviceImageCompressionControlFeaturesEXT {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
}
impl Default for PhysicalDeviceImageCompressionControlFeaturesEXT {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            image_compression_control: Default::default(),
        }
    }
}
impl std::fmt::Debug for PhysicalDeviceImageCompressionControlFeaturesEXT {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("PhysicalDeviceImageCompressionControlFeaturesEXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("image_compression_control", &(self.image_compression_control != 0))
            .finish()
    }
}
impl PhysicalDeviceImageCompressionControlFeaturesEXT {
    #[inline]
    pub fn into_builder<'a>(
        self,
    ) -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
        PhysicalDeviceImageCompressionControlFeaturesEXTBuilder(
            self,
            std::marker::PhantomData,
        )
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html) · Builder of [`PhysicalDeviceImageCompressionControlFeaturesEXT`]
#[repr(transparent)]
pub struct PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a>(
    PhysicalDeviceImageCompressionControlFeaturesEXT,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn new() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
        PhysicalDeviceImageCompressionControlFeaturesEXTBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    #[must_use]
    pub fn image_compression_control(mut self, image_compression_control: bool) -> Self {
        self.0.image_compression_control = image_compression_control as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> PhysicalDeviceImageCompressionControlFeaturesEXT {
        self.0
    }
}
impl<'a> std::default::Default
for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    fn default() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug
for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref
for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceImageCompressionControlFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut
for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionPropertiesEXT.html) · Structure
#[doc(alias = "VkImageCompressionPropertiesEXT")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct ImageCompressionPropertiesEXT {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub image_compression_flags: crate::extensions::ext_image_compression_control::ImageCompressionFlagsEXT,
    pub image_compression_fixed_rate_flags: crate::extensions::ext_image_compression_control::ImageCompressionFixedRateFlagsEXT,
}
impl ImageCompressionPropertiesEXT {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT;
}
impl Default for ImageCompressionPropertiesEXT {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            image_compression_flags: Default::default(),
            image_compression_fixed_rate_flags: Default::default(),
        }
    }
}
impl std::fmt::Debug for ImageCompressionPropertiesEXT {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("ImageCompressionPropertiesEXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("image_compression_flags", &self.image_compression_flags)
            .field(
                "image_compression_fixed_rate_flags",
                &self.image_compression_fixed_rate_flags,
            )
            .finish()
    }
}
impl ImageCompressionPropertiesEXT {
    #[inline]
    pub fn into_builder<'a>(self) -> ImageCompressionPropertiesEXTBuilder<'a> {
        ImageCompressionPropertiesEXTBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionPropertiesEXT.html) · Builder of [`ImageCompressionPropertiesEXT`]
#[repr(transparent)]
pub struct ImageCompressionPropertiesEXTBuilder<'a>(
    ImageCompressionPropertiesEXT,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> ImageCompressionPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn new() -> ImageCompressionPropertiesEXTBuilder<'a> {
        ImageCompressionPropertiesEXTBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    #[must_use]
    pub fn image_compression_flags(
        mut self,
        image_compression_flags: crate::extensions::ext_image_compression_control::ImageCompressionFlagsEXT,
    ) -> Self {
        self.0.image_compression_flags = image_compression_flags as _;
        self
    }
    #[inline]
    #[must_use]
    pub fn image_compression_fixed_rate_flags(
        mut self,
        image_compression_fixed_rate_flags: crate::extensions::ext_image_compression_control::ImageCompressionFixedRateFlagsEXT,
    ) -> Self {
        self
            .0
            .image_compression_fixed_rate_flags = image_compression_fixed_rate_flags
            as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> ImageCompressionPropertiesEXT {
        self.0
    }
}
impl<'a> std::default::Default for ImageCompressionPropertiesEXTBuilder<'a> {
    fn default() -> ImageCompressionPropertiesEXTBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for ImageCompressionPropertiesEXTBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for ImageCompressionPropertiesEXTBuilder<'a> {
    type Target = ImageCompressionPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for ImageCompressionPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource2EXT.html) · Structure
#[doc(alias = "VkImageSubresource2EXT")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct ImageSubresource2EXT {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub image_subresource: crate::vk1_0::ImageSubresource,
}
impl ImageSubresource2EXT {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::IMAGE_SUBRESOURCE_2_EXT;
}
impl Default for ImageSubresource2EXT {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            image_subresource: Default::default(),
        }
    }
}
impl std::fmt::Debug for ImageSubresource2EXT {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("ImageSubresource2EXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("image_subresource", &self.image_subresource)
            .finish()
    }
}
impl ImageSubresource2EXT {
    #[inline]
    pub fn into_builder<'a>(self) -> ImageSubresource2EXTBuilder<'a> {
        ImageSubresource2EXTBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource2EXT.html) · Builder of [`ImageSubresource2EXT`]
#[repr(transparent)]
pub struct ImageSubresource2EXTBuilder<'a>(
    ImageSubresource2EXT,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> ImageSubresource2EXTBuilder<'a> {
    #[inline]
    pub fn new() -> ImageSubresource2EXTBuilder<'a> {
        ImageSubresource2EXTBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn image_subresource(
        mut self,
        image_subresource: crate::vk1_0::ImageSubresource,
    ) -> Self {
        self.0.image_subresource = image_subresource as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> ImageSubresource2EXT {
        self.0
    }
}
impl<'a> std::default::Default for ImageSubresource2EXTBuilder<'a> {
    fn default() -> ImageSubresource2EXTBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for ImageSubresource2EXTBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for ImageSubresource2EXTBuilder<'a> {
    type Target = ImageSubresource2EXT;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for ImageSubresource2EXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout2EXT.html) · Structure
#[doc(alias = "VkSubresourceLayout2EXT")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct SubresourceLayout2EXT {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub subresource_layout: crate::vk1_0::SubresourceLayout,
}
impl SubresourceLayout2EXT {
    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::SUBRESOURCE_LAYOUT_2_EXT;
}
impl Default for SubresourceLayout2EXT {
    fn default() -> Self {
        Self {
            s_type: Self::STRUCTURE_TYPE,
            p_next: std::ptr::null_mut(),
            subresource_layout: Default::default(),
        }
    }
}
impl std::fmt::Debug for SubresourceLayout2EXT {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("SubresourceLayout2EXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("subresource_layout", &self.subresource_layout)
            .finish()
    }
}
impl SubresourceLayout2EXT {
    #[inline]
    pub fn into_builder<'a>(self) -> SubresourceLayout2EXTBuilder<'a> {
        SubresourceLayout2EXTBuilder(self, std::marker::PhantomData)
    }
}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionPropertiesEXT>
for crate::extensions::ext_image_compression_control::SubresourceLayout2EXTBuilder<'a> {}
impl<'a> crate::ExtendableFrom<'a, ImageCompressionPropertiesEXTBuilder<'_>>
for crate::extensions::ext_image_compression_control::SubresourceLayout2EXTBuilder<'a> {}
#[derive(Copy, Clone)]
///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout2EXT.html) · Builder of [`SubresourceLayout2EXT`]
#[repr(transparent)]
pub struct SubresourceLayout2EXTBuilder<'a>(
    SubresourceLayout2EXT,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> SubresourceLayout2EXTBuilder<'a> {
    #[inline]
    pub fn new() -> SubresourceLayout2EXTBuilder<'a> {
        SubresourceLayout2EXTBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    #[must_use]
    pub fn subresource_layout(
        mut self,
        subresource_layout: crate::vk1_0::SubresourceLayout,
    ) -> Self {
        self.0.subresource_layout = subresource_layout as _;
        self
    }
    #[inline]
    /// Discards all lifetime information.
    /// Use the `Deref` and `DerefMut` implementations if possible.
    pub fn build_dangling(self) -> SubresourceLayout2EXT {
        self.0
    }
}
impl<'a> std::default::Default for SubresourceLayout2EXTBuilder<'a> {
    fn default() -> SubresourceLayout2EXTBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for SubresourceLayout2EXTBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for SubresourceLayout2EXTBuilder<'a> {
    type Target = SubresourceLayout2EXT;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for SubresourceLayout2EXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
///Provided by [`crate::extensions::ext_image_compression_control`]
impl crate::DeviceLoader {
    #[inline]
    #[track_caller]
    ///[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSubresourceLayout2EXT.html) · Function
    #[doc(alias = "vkGetImageSubresourceLayout2EXT")]
    pub unsafe fn get_image_subresource_layout2_ext(
        &self,
        image: crate::vk1_0::Image,
        subresource: &crate::extensions::ext_image_compression_control::ImageSubresource2EXT,
        layout: &mut crate::extensions::ext_image_compression_control::SubresourceLayout2EXT,
    ) -> () {
        let _function = self
            .get_image_subresource_layout2_ext
            .expect(crate::NOT_LOADED_MESSAGE);
        let _return = _function(self.handle, image as _, subresource as _, layout as _);
        ()
    }
}