kazan 0.3.9+1.4.359

#![allow(unused_imports)]
use crate::{vk::Result as VkResult, vk::*, *};
use core::ffi::{CStr, c_char, c_int, c_void};
use core::mem::transmute;
use core::ptr;

pub const API_VERSION: ApiVersion = ApiVersion::new(0, 1, 2, 0);

pub(super) mod defs {
    #![allow(non_camel_case_types, unused_imports)]
    use crate::{vk::*, *};
    use core::ffi::{CStr, c_char, c_int, c_void};
    use core::fmt;
    use core::marker::PhantomData;
    use core::ptr;

    pub const MAX_DRIVER_NAME_SIZE: u32 = 256;
    pub const MAX_DRIVER_INFO_SIZE: u32 = 256;

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkConformanceVersion.html>
    #[repr(C)]
    #[cfg_attr(feature = "debug", derive(Debug))]
    #[derive(Copy, Clone, Default)]
    #[must_use]
    pub struct ConformanceVersion {
        pub major: u8,
        pub minor: u8,
        pub subminor: u8,
        pub patch: u8,
    }

    impl ConformanceVersion {
        #[inline]
        pub fn major(mut self, major: u8) -> Self {
            self.major = major;
            self
        }

        #[inline]
        pub fn minor(mut self, minor: u8) -> Self {
            self.minor = minor;
            self
        }

        #[inline]
        pub fn subminor(mut self, subminor: u8) -> Self {
            self.subminor = subminor;
            self
        }

        #[inline]
        pub fn patch(mut self, patch: u8) -> Self {
            self.patch = patch;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDriverProperties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceDriverProperties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub driver_id: DriverId,
        pub driver_name: ArrayCStr<{ MAX_DRIVER_NAME_SIZE as usize }>,
        pub driver_info: ArrayCStr<{ MAX_DRIVER_INFO_SIZE as usize }>,
        pub conformance_version: ConformanceVersion,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceDriverProperties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceDriverProperties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("driver_id", &self.driver_id)
                .field("driver_name", &self.driver_name)
                .field("driver_info", &self.driver_info)
                .field("conformance_version", &self.conformance_version)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceDriverProperties<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>> for PhysicalDeviceDriverProperties<'_> {}

    impl Default for PhysicalDeviceDriverProperties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                driver_id: Default::default(),
                driver_name: Default::default(),
                driver_info: Default::default(),
                conformance_version: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceDriverProperties<'a> {
        #[inline]
        pub fn driver_id(mut self, driver_id: DriverId) -> Self {
            self.driver_id = driver_id;
            self
        }

        #[inline]
        pub fn driver_name(
            mut self,
            driver_name: &CStr,
        ) -> core::result::Result<Self, CStrTooLargeForStaticArray> {
            self.driver_name.write_c_str(driver_name)?;
            Ok(self)
        }

        #[inline]
        pub fn driver_info(
            mut self,
            driver_info: &CStr,
        ) -> core::result::Result<Self, CStrTooLargeForStaticArray> {
            self.driver_info.write_c_str(driver_info)?;
            Ok(self)
        }

        #[inline]
        pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
            self.conformance_version = conformance_version;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub shader_subgroup_extended_types: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceShaderSubgroupExtendedTypesFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "shader_subgroup_extended_types",
                    &self.shader_subgroup_extended_types,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>>
        for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_>
    {
    }
    unsafe impl Extends<DeviceCreateInfo<'_>>
        for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_>
    {
    }

    impl Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                shader_subgroup_extended_types: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> {
        #[inline]
        pub fn shader_subgroup_extended_types(
            mut self,
            shader_subgroup_extended_types: bool,
        ) -> Self {
            self.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceSamplerFilterMinmaxProperties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub filter_minmax_single_component_formats: Bool32,
        pub filter_minmax_image_component_mapping: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceSamplerFilterMinmaxProperties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceSamplerFilterMinmaxProperties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "filter_minmax_single_component_formats",
                    &self.filter_minmax_single_component_formats,
                )
                .field(
                    "filter_minmax_image_component_mapping",
                    &self.filter_minmax_image_component_mapping,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceSamplerFilterMinmaxProperties<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>>
        for PhysicalDeviceSamplerFilterMinmaxProperties<'_>
    {
    }

    impl Default for PhysicalDeviceSamplerFilterMinmaxProperties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                filter_minmax_single_component_formats: Default::default(),
                filter_minmax_image_component_mapping: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceSamplerFilterMinmaxProperties<'a> {
        #[inline]
        pub fn filter_minmax_single_component_formats(
            mut self,
            filter_minmax_single_component_formats: bool,
        ) -> Self {
            self.filter_minmax_single_component_formats =
                filter_minmax_single_component_formats.into();
            self
        }

        #[inline]
        pub fn filter_minmax_image_component_mapping(
            mut self,
            filter_minmax_image_component_mapping: bool,
        ) -> Self {
            self.filter_minmax_image_component_mapping =
                filter_minmax_image_component_mapping.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerReductionModeCreateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SamplerReductionModeCreateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub reduction_mode: SamplerReductionMode,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SamplerReductionModeCreateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SamplerReductionModeCreateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("reduction_mode", &self.reduction_mode)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SamplerReductionModeCreateInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO;
    }

    unsafe impl Extends<SamplerCreateInfo<'_>> for SamplerReductionModeCreateInfo<'_> {}

    impl Default for SamplerReductionModeCreateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                reduction_mode: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SamplerReductionModeCreateInfo<'a> {
        #[inline]
        pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self {
            self.reduction_mode = reduction_mode;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatListCreateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct ImageFormatListCreateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub view_format_count: u32,
        pub p_view_formats: *const Format,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for ImageFormatListCreateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("ImageFormatListCreateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("view_format_count", &self.view_format_count)
                .field("p_view_formats", &self.p_view_formats)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for ImageFormatListCreateInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_LIST_CREATE_INFO;
    }

    unsafe impl Extends<ImageCreateInfo<'_>> for ImageFormatListCreateInfo<'_> {}
    unsafe impl Extends<SwapchainCreateInfoKHR<'_>> for ImageFormatListCreateInfo<'_> {}
    unsafe impl Extends<PhysicalDeviceImageFormatInfo2<'_>> for ImageFormatListCreateInfo<'_> {}

    impl Default for ImageFormatListCreateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                view_format_count: Default::default(),
                p_view_formats: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> ImageFormatListCreateInfo<'a> {
        #[inline]
        pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
            self.view_format_count = view_formats.len().try_into().unwrap();
            self.p_view_formats = view_formats.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceShaderFloat16Int8Features<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub shader_float16: Bool32,
        pub shader_int8: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceShaderFloat16Int8Features<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceShaderFloat16Int8Features")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("shader_float16", &self.shader_float16)
                .field("shader_int8", &self.shader_int8)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderFloat16Int8Features<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceShaderFloat16Int8Features<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceShaderFloat16Int8Features<'_> {}

    impl Default for PhysicalDeviceShaderFloat16Int8Features<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                shader_float16: Default::default(),
                shader_int8: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceShaderFloat16Int8Features<'a> {
        #[inline]
        pub fn shader_float16(mut self, shader_float16: bool) -> Self {
            self.shader_float16 = shader_float16.into();
            self
        }

        #[inline]
        pub fn shader_int8(mut self, shader_int8: bool) -> Self {
            self.shader_int8 = shader_int8.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFloatControlsProperties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceFloatControlsProperties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub denorm_behavior_independence: ShaderFloatControlsIndependence,
        pub rounding_mode_independence: ShaderFloatControlsIndependence,
        pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
        pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
        pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
        pub shader_denorm_preserve_float16: Bool32,
        pub shader_denorm_preserve_float32: Bool32,
        pub shader_denorm_preserve_float64: Bool32,
        pub shader_denorm_flush_to_zero_float16: Bool32,
        pub shader_denorm_flush_to_zero_float32: Bool32,
        pub shader_denorm_flush_to_zero_float64: Bool32,
        pub shader_rounding_mode_rte_float16: Bool32,
        pub shader_rounding_mode_rte_float32: Bool32,
        pub shader_rounding_mode_rte_float64: Bool32,
        pub shader_rounding_mode_rtz_float16: Bool32,
        pub shader_rounding_mode_rtz_float32: Bool32,
        pub shader_rounding_mode_rtz_float64: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceFloatControlsProperties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceFloatControlsProperties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "denorm_behavior_independence",
                    &self.denorm_behavior_independence,
                )
                .field(
                    "rounding_mode_independence",
                    &self.rounding_mode_independence,
                )
                .field(
                    "shader_signed_zero_inf_nan_preserve_float16",
                    &self.shader_signed_zero_inf_nan_preserve_float16,
                )
                .field(
                    "shader_signed_zero_inf_nan_preserve_float32",
                    &self.shader_signed_zero_inf_nan_preserve_float32,
                )
                .field(
                    "shader_signed_zero_inf_nan_preserve_float64",
                    &self.shader_signed_zero_inf_nan_preserve_float64,
                )
                .field(
                    "shader_denorm_preserve_float16",
                    &self.shader_denorm_preserve_float16,
                )
                .field(
                    "shader_denorm_preserve_float32",
                    &self.shader_denorm_preserve_float32,
                )
                .field(
                    "shader_denorm_preserve_float64",
                    &self.shader_denorm_preserve_float64,
                )
                .field(
                    "shader_denorm_flush_to_zero_float16",
                    &self.shader_denorm_flush_to_zero_float16,
                )
                .field(
                    "shader_denorm_flush_to_zero_float32",
                    &self.shader_denorm_flush_to_zero_float32,
                )
                .field(
                    "shader_denorm_flush_to_zero_float64",
                    &self.shader_denorm_flush_to_zero_float64,
                )
                .field(
                    "shader_rounding_mode_rte_float16",
                    &self.shader_rounding_mode_rte_float16,
                )
                .field(
                    "shader_rounding_mode_rte_float32",
                    &self.shader_rounding_mode_rte_float32,
                )
                .field(
                    "shader_rounding_mode_rte_float64",
                    &self.shader_rounding_mode_rte_float64,
                )
                .field(
                    "shader_rounding_mode_rtz_float16",
                    &self.shader_rounding_mode_rtz_float16,
                )
                .field(
                    "shader_rounding_mode_rtz_float32",
                    &self.shader_rounding_mode_rtz_float32,
                )
                .field(
                    "shader_rounding_mode_rtz_float64",
                    &self.shader_rounding_mode_rtz_float64,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceFloatControlsProperties<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>> for PhysicalDeviceFloatControlsProperties<'_> {}

    impl Default for PhysicalDeviceFloatControlsProperties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                denorm_behavior_independence: Default::default(),
                rounding_mode_independence: Default::default(),
                shader_signed_zero_inf_nan_preserve_float16: Default::default(),
                shader_signed_zero_inf_nan_preserve_float32: Default::default(),
                shader_signed_zero_inf_nan_preserve_float64: Default::default(),
                shader_denorm_preserve_float16: Default::default(),
                shader_denorm_preserve_float32: Default::default(),
                shader_denorm_preserve_float64: Default::default(),
                shader_denorm_flush_to_zero_float16: Default::default(),
                shader_denorm_flush_to_zero_float32: Default::default(),
                shader_denorm_flush_to_zero_float64: Default::default(),
                shader_rounding_mode_rte_float16: Default::default(),
                shader_rounding_mode_rte_float32: Default::default(),
                shader_rounding_mode_rte_float64: Default::default(),
                shader_rounding_mode_rtz_float16: Default::default(),
                shader_rounding_mode_rtz_float32: Default::default(),
                shader_rounding_mode_rtz_float64: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceFloatControlsProperties<'a> {
        #[inline]
        pub fn denorm_behavior_independence(
            mut self,
            denorm_behavior_independence: ShaderFloatControlsIndependence,
        ) -> Self {
            self.denorm_behavior_independence = denorm_behavior_independence;
            self
        }

        #[inline]
        pub fn rounding_mode_independence(
            mut self,
            rounding_mode_independence: ShaderFloatControlsIndependence,
        ) -> Self {
            self.rounding_mode_independence = rounding_mode_independence;
            self
        }

        #[inline]
        pub fn shader_signed_zero_inf_nan_preserve_float16(
            mut self,
            shader_signed_zero_inf_nan_preserve_float16: bool,
        ) -> Self {
            self.shader_signed_zero_inf_nan_preserve_float16 =
                shader_signed_zero_inf_nan_preserve_float16.into();
            self
        }

        #[inline]
        pub fn shader_signed_zero_inf_nan_preserve_float32(
            mut self,
            shader_signed_zero_inf_nan_preserve_float32: bool,
        ) -> Self {
            self.shader_signed_zero_inf_nan_preserve_float32 =
                shader_signed_zero_inf_nan_preserve_float32.into();
            self
        }

        #[inline]
        pub fn shader_signed_zero_inf_nan_preserve_float64(
            mut self,
            shader_signed_zero_inf_nan_preserve_float64: bool,
        ) -> Self {
            self.shader_signed_zero_inf_nan_preserve_float64 =
                shader_signed_zero_inf_nan_preserve_float64.into();
            self
        }

        #[inline]
        pub fn shader_denorm_preserve_float16(
            mut self,
            shader_denorm_preserve_float16: bool,
        ) -> Self {
            self.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
            self
        }

        #[inline]
        pub fn shader_denorm_preserve_float32(
            mut self,
            shader_denorm_preserve_float32: bool,
        ) -> Self {
            self.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
            self
        }

        #[inline]
        pub fn shader_denorm_preserve_float64(
            mut self,
            shader_denorm_preserve_float64: bool,
        ) -> Self {
            self.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
            self
        }

        #[inline]
        pub fn shader_denorm_flush_to_zero_float16(
            mut self,
            shader_denorm_flush_to_zero_float16: bool,
        ) -> Self {
            self.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
            self
        }

        #[inline]
        pub fn shader_denorm_flush_to_zero_float32(
            mut self,
            shader_denorm_flush_to_zero_float32: bool,
        ) -> Self {
            self.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
            self
        }

        #[inline]
        pub fn shader_denorm_flush_to_zero_float64(
            mut self,
            shader_denorm_flush_to_zero_float64: bool,
        ) -> Self {
            self.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rte_float16(
            mut self,
            shader_rounding_mode_rte_float16: bool,
        ) -> Self {
            self.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rte_float32(
            mut self,
            shader_rounding_mode_rte_float32: bool,
        ) -> Self {
            self.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rte_float64(
            mut self,
            shader_rounding_mode_rte_float64: bool,
        ) -> Self {
            self.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rtz_float16(
            mut self,
            shader_rounding_mode_rtz_float16: bool,
        ) -> Self {
            self.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rtz_float32(
            mut self,
            shader_rounding_mode_rtz_float32: bool,
        ) -> Self {
            self.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rtz_float64(
            mut self,
            shader_rounding_mode_rtz_float64: bool,
        ) -> Self {
            self.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceHostQueryResetFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub host_query_reset: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceHostQueryResetFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceHostQueryResetFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("host_query_reset", &self.host_query_reset)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceHostQueryResetFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceHostQueryResetFeatures<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceHostQueryResetFeatures<'_> {}

    impl Default for PhysicalDeviceHostQueryResetFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                host_query_reset: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceHostQueryResetFeatures<'a> {
        #[inline]
        pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
            self.host_query_reset = host_query_reset.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceDescriptorIndexingFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub shader_input_attachment_array_dynamic_indexing: Bool32,
        pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
        pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
        pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
        pub shader_sampled_image_array_non_uniform_indexing: Bool32,
        pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
        pub shader_storage_image_array_non_uniform_indexing: Bool32,
        pub shader_input_attachment_array_non_uniform_indexing: Bool32,
        pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
        pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
        pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
        pub descriptor_binding_sampled_image_update_after_bind: Bool32,
        pub descriptor_binding_storage_image_update_after_bind: Bool32,
        pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
        pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
        pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
        pub descriptor_binding_update_unused_while_pending: Bool32,
        pub descriptor_binding_partially_bound: Bool32,
        pub descriptor_binding_variable_descriptor_count: Bool32,
        pub runtime_descriptor_array: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceDescriptorIndexingFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceDescriptorIndexingFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "shader_input_attachment_array_dynamic_indexing",
                    &self.shader_input_attachment_array_dynamic_indexing,
                )
                .field(
                    "shader_uniform_texel_buffer_array_dynamic_indexing",
                    &self.shader_uniform_texel_buffer_array_dynamic_indexing,
                )
                .field(
                    "shader_storage_texel_buffer_array_dynamic_indexing",
                    &self.shader_storage_texel_buffer_array_dynamic_indexing,
                )
                .field(
                    "shader_uniform_buffer_array_non_uniform_indexing",
                    &self.shader_uniform_buffer_array_non_uniform_indexing,
                )
                .field(
                    "shader_sampled_image_array_non_uniform_indexing",
                    &self.shader_sampled_image_array_non_uniform_indexing,
                )
                .field(
                    "shader_storage_buffer_array_non_uniform_indexing",
                    &self.shader_storage_buffer_array_non_uniform_indexing,
                )
                .field(
                    "shader_storage_image_array_non_uniform_indexing",
                    &self.shader_storage_image_array_non_uniform_indexing,
                )
                .field(
                    "shader_input_attachment_array_non_uniform_indexing",
                    &self.shader_input_attachment_array_non_uniform_indexing,
                )
                .field(
                    "shader_uniform_texel_buffer_array_non_uniform_indexing",
                    &self.shader_uniform_texel_buffer_array_non_uniform_indexing,
                )
                .field(
                    "shader_storage_texel_buffer_array_non_uniform_indexing",
                    &self.shader_storage_texel_buffer_array_non_uniform_indexing,
                )
                .field(
                    "descriptor_binding_uniform_buffer_update_after_bind",
                    &self.descriptor_binding_uniform_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_sampled_image_update_after_bind",
                    &self.descriptor_binding_sampled_image_update_after_bind,
                )
                .field(
                    "descriptor_binding_storage_image_update_after_bind",
                    &self.descriptor_binding_storage_image_update_after_bind,
                )
                .field(
                    "descriptor_binding_storage_buffer_update_after_bind",
                    &self.descriptor_binding_storage_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_uniform_texel_buffer_update_after_bind",
                    &self.descriptor_binding_uniform_texel_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_storage_texel_buffer_update_after_bind",
                    &self.descriptor_binding_storage_texel_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_update_unused_while_pending",
                    &self.descriptor_binding_update_unused_while_pending,
                )
                .field(
                    "descriptor_binding_partially_bound",
                    &self.descriptor_binding_partially_bound,
                )
                .field(
                    "descriptor_binding_variable_descriptor_count",
                    &self.descriptor_binding_variable_descriptor_count,
                )
                .field("runtime_descriptor_array", &self.runtime_descriptor_array)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceDescriptorIndexingFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceDescriptorIndexingFeatures<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceDescriptorIndexingFeatures<'_> {}

    impl Default for PhysicalDeviceDescriptorIndexingFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                shader_input_attachment_array_dynamic_indexing: Default::default(),
                shader_uniform_texel_buffer_array_dynamic_indexing: Default::default(),
                shader_storage_texel_buffer_array_dynamic_indexing: Default::default(),
                shader_uniform_buffer_array_non_uniform_indexing: Default::default(),
                shader_sampled_image_array_non_uniform_indexing: Default::default(),
                shader_storage_buffer_array_non_uniform_indexing: Default::default(),
                shader_storage_image_array_non_uniform_indexing: Default::default(),
                shader_input_attachment_array_non_uniform_indexing: Default::default(),
                shader_uniform_texel_buffer_array_non_uniform_indexing: Default::default(),
                shader_storage_texel_buffer_array_non_uniform_indexing: Default::default(),
                descriptor_binding_uniform_buffer_update_after_bind: Default::default(),
                descriptor_binding_sampled_image_update_after_bind: Default::default(),
                descriptor_binding_storage_image_update_after_bind: Default::default(),
                descriptor_binding_storage_buffer_update_after_bind: Default::default(),
                descriptor_binding_uniform_texel_buffer_update_after_bind: Default::default(),
                descriptor_binding_storage_texel_buffer_update_after_bind: Default::default(),
                descriptor_binding_update_unused_while_pending: Default::default(),
                descriptor_binding_partially_bound: Default::default(),
                descriptor_binding_variable_descriptor_count: Default::default(),
                runtime_descriptor_array: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceDescriptorIndexingFeatures<'a> {
        #[inline]
        pub fn shader_input_attachment_array_dynamic_indexing(
            mut self,
            shader_input_attachment_array_dynamic_indexing: bool,
        ) -> Self {
            self.shader_input_attachment_array_dynamic_indexing =
                shader_input_attachment_array_dynamic_indexing.into();
            self
        }

        #[inline]
        pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
            mut self,
            shader_uniform_texel_buffer_array_dynamic_indexing: bool,
        ) -> Self {
            self.shader_uniform_texel_buffer_array_dynamic_indexing =
                shader_uniform_texel_buffer_array_dynamic_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_texel_buffer_array_dynamic_indexing(
            mut self,
            shader_storage_texel_buffer_array_dynamic_indexing: bool,
        ) -> Self {
            self.shader_storage_texel_buffer_array_dynamic_indexing =
                shader_storage_texel_buffer_array_dynamic_indexing.into();
            self
        }

        #[inline]
        pub fn shader_uniform_buffer_array_non_uniform_indexing(
            mut self,
            shader_uniform_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_uniform_buffer_array_non_uniform_indexing =
                shader_uniform_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_sampled_image_array_non_uniform_indexing(
            mut self,
            shader_sampled_image_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_sampled_image_array_non_uniform_indexing =
                shader_sampled_image_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_buffer_array_non_uniform_indexing(
            mut self,
            shader_storage_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_storage_buffer_array_non_uniform_indexing =
                shader_storage_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_image_array_non_uniform_indexing(
            mut self,
            shader_storage_image_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_storage_image_array_non_uniform_indexing =
                shader_storage_image_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_input_attachment_array_non_uniform_indexing(
            mut self,
            shader_input_attachment_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_input_attachment_array_non_uniform_indexing =
                shader_input_attachment_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
            mut self,
            shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_uniform_texel_buffer_array_non_uniform_indexing =
                shader_uniform_texel_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
            mut self,
            shader_storage_texel_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_storage_texel_buffer_array_non_uniform_indexing =
                shader_storage_texel_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_uniform_buffer_update_after_bind(
            mut self,
            descriptor_binding_uniform_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_uniform_buffer_update_after_bind =
                descriptor_binding_uniform_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_sampled_image_update_after_bind(
            mut self,
            descriptor_binding_sampled_image_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_sampled_image_update_after_bind =
                descriptor_binding_sampled_image_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_storage_image_update_after_bind(
            mut self,
            descriptor_binding_storage_image_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_storage_image_update_after_bind =
                descriptor_binding_storage_image_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_storage_buffer_update_after_bind(
            mut self,
            descriptor_binding_storage_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_storage_buffer_update_after_bind =
                descriptor_binding_storage_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
            mut self,
            descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_uniform_texel_buffer_update_after_bind =
                descriptor_binding_uniform_texel_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
            mut self,
            descriptor_binding_storage_texel_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_storage_texel_buffer_update_after_bind =
                descriptor_binding_storage_texel_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_update_unused_while_pending(
            mut self,
            descriptor_binding_update_unused_while_pending: bool,
        ) -> Self {
            self.descriptor_binding_update_unused_while_pending =
                descriptor_binding_update_unused_while_pending.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_partially_bound(
            mut self,
            descriptor_binding_partially_bound: bool,
        ) -> Self {
            self.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_variable_descriptor_count(
            mut self,
            descriptor_binding_variable_descriptor_count: bool,
        ) -> Self {
            self.descriptor_binding_variable_descriptor_count =
                descriptor_binding_variable_descriptor_count.into();
            self
        }

        #[inline]
        pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
            self.runtime_descriptor_array = runtime_descriptor_array.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceDescriptorIndexingProperties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub max_update_after_bind_descriptors_in_all_pools: u32,
        pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
        pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
        pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
        pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
        pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
        pub robust_buffer_access_update_after_bind: Bool32,
        pub quad_divergent_implicit_lod: Bool32,
        pub max_per_stage_descriptor_update_after_bind_samplers: u32,
        pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
        pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
        pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
        pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
        pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
        pub max_per_stage_update_after_bind_resources: u32,
        pub max_descriptor_set_update_after_bind_samplers: u32,
        pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
        pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
        pub max_descriptor_set_update_after_bind_storage_buffers: u32,
        pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
        pub max_descriptor_set_update_after_bind_sampled_images: u32,
        pub max_descriptor_set_update_after_bind_storage_images: u32,
        pub max_descriptor_set_update_after_bind_input_attachments: u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceDescriptorIndexingProperties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceDescriptorIndexingProperties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "max_update_after_bind_descriptors_in_all_pools",
                    &self.max_update_after_bind_descriptors_in_all_pools,
                )
                .field(
                    "shader_uniform_buffer_array_non_uniform_indexing_native",
                    &self.shader_uniform_buffer_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_sampled_image_array_non_uniform_indexing_native",
                    &self.shader_sampled_image_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_storage_buffer_array_non_uniform_indexing_native",
                    &self.shader_storage_buffer_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_storage_image_array_non_uniform_indexing_native",
                    &self.shader_storage_image_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_input_attachment_array_non_uniform_indexing_native",
                    &self.shader_input_attachment_array_non_uniform_indexing_native,
                )
                .field(
                    "robust_buffer_access_update_after_bind",
                    &self.robust_buffer_access_update_after_bind,
                )
                .field(
                    "quad_divergent_implicit_lod",
                    &self.quad_divergent_implicit_lod,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_samplers",
                    &self.max_per_stage_descriptor_update_after_bind_samplers,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_uniform_buffers",
                    &self.max_per_stage_descriptor_update_after_bind_uniform_buffers,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_storage_buffers",
                    &self.max_per_stage_descriptor_update_after_bind_storage_buffers,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_sampled_images",
                    &self.max_per_stage_descriptor_update_after_bind_sampled_images,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_storage_images",
                    &self.max_per_stage_descriptor_update_after_bind_storage_images,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_input_attachments",
                    &self.max_per_stage_descriptor_update_after_bind_input_attachments,
                )
                .field(
                    "max_per_stage_update_after_bind_resources",
                    &self.max_per_stage_update_after_bind_resources,
                )
                .field(
                    "max_descriptor_set_update_after_bind_samplers",
                    &self.max_descriptor_set_update_after_bind_samplers,
                )
                .field(
                    "max_descriptor_set_update_after_bind_uniform_buffers",
                    &self.max_descriptor_set_update_after_bind_uniform_buffers,
                )
                .field(
                    "max_descriptor_set_update_after_bind_uniform_buffers_dynamic",
                    &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic,
                )
                .field(
                    "max_descriptor_set_update_after_bind_storage_buffers",
                    &self.max_descriptor_set_update_after_bind_storage_buffers,
                )
                .field(
                    "max_descriptor_set_update_after_bind_storage_buffers_dynamic",
                    &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic,
                )
                .field(
                    "max_descriptor_set_update_after_bind_sampled_images",
                    &self.max_descriptor_set_update_after_bind_sampled_images,
                )
                .field(
                    "max_descriptor_set_update_after_bind_storage_images",
                    &self.max_descriptor_set_update_after_bind_storage_images,
                )
                .field(
                    "max_descriptor_set_update_after_bind_input_attachments",
                    &self.max_descriptor_set_update_after_bind_input_attachments,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceDescriptorIndexingProperties<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>>
        for PhysicalDeviceDescriptorIndexingProperties<'_>
    {
    }

    impl Default for PhysicalDeviceDescriptorIndexingProperties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                max_update_after_bind_descriptors_in_all_pools: Default::default(),
                shader_uniform_buffer_array_non_uniform_indexing_native: Default::default(),
                shader_sampled_image_array_non_uniform_indexing_native: Default::default(),
                shader_storage_buffer_array_non_uniform_indexing_native: Default::default(),
                shader_storage_image_array_non_uniform_indexing_native: Default::default(),
                shader_input_attachment_array_non_uniform_indexing_native: Default::default(),
                robust_buffer_access_update_after_bind: Default::default(),
                quad_divergent_implicit_lod: Default::default(),
                max_per_stage_descriptor_update_after_bind_samplers: Default::default(),
                max_per_stage_descriptor_update_after_bind_uniform_buffers: Default::default(),
                max_per_stage_descriptor_update_after_bind_storage_buffers: Default::default(),
                max_per_stage_descriptor_update_after_bind_sampled_images: Default::default(),
                max_per_stage_descriptor_update_after_bind_storage_images: Default::default(),
                max_per_stage_descriptor_update_after_bind_input_attachments: Default::default(),
                max_per_stage_update_after_bind_resources: Default::default(),
                max_descriptor_set_update_after_bind_samplers: Default::default(),
                max_descriptor_set_update_after_bind_uniform_buffers: Default::default(),
                max_descriptor_set_update_after_bind_uniform_buffers_dynamic: Default::default(),
                max_descriptor_set_update_after_bind_storage_buffers: Default::default(),
                max_descriptor_set_update_after_bind_storage_buffers_dynamic: Default::default(),
                max_descriptor_set_update_after_bind_sampled_images: Default::default(),
                max_descriptor_set_update_after_bind_storage_images: Default::default(),
                max_descriptor_set_update_after_bind_input_attachments: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceDescriptorIndexingProperties<'a> {
        #[inline]
        pub fn max_update_after_bind_descriptors_in_all_pools(
            mut self,
            max_update_after_bind_descriptors_in_all_pools: u32,
        ) -> Self {
            self.max_update_after_bind_descriptors_in_all_pools =
                max_update_after_bind_descriptors_in_all_pools;
            self
        }

        #[inline]
        pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
            mut self,
            shader_uniform_buffer_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_uniform_buffer_array_non_uniform_indexing_native =
                shader_uniform_buffer_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_sampled_image_array_non_uniform_indexing_native(
            mut self,
            shader_sampled_image_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_sampled_image_array_non_uniform_indexing_native =
                shader_sampled_image_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_storage_buffer_array_non_uniform_indexing_native(
            mut self,
            shader_storage_buffer_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_storage_buffer_array_non_uniform_indexing_native =
                shader_storage_buffer_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_storage_image_array_non_uniform_indexing_native(
            mut self,
            shader_storage_image_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_storage_image_array_non_uniform_indexing_native =
                shader_storage_image_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_input_attachment_array_non_uniform_indexing_native(
            mut self,
            shader_input_attachment_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_input_attachment_array_non_uniform_indexing_native =
                shader_input_attachment_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn robust_buffer_access_update_after_bind(
            mut self,
            robust_buffer_access_update_after_bind: bool,
        ) -> Self {
            self.robust_buffer_access_update_after_bind =
                robust_buffer_access_update_after_bind.into();
            self
        }

        #[inline]
        pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
            self.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_samplers(
            mut self,
            max_per_stage_descriptor_update_after_bind_samplers: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_samplers =
                max_per_stage_descriptor_update_after_bind_samplers;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
            mut self,
            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_uniform_buffers =
                max_per_stage_descriptor_update_after_bind_uniform_buffers;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
            mut self,
            max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_storage_buffers =
                max_per_stage_descriptor_update_after_bind_storage_buffers;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
            mut self,
            max_per_stage_descriptor_update_after_bind_sampled_images: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_sampled_images =
                max_per_stage_descriptor_update_after_bind_sampled_images;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_storage_images(
            mut self,
            max_per_stage_descriptor_update_after_bind_storage_images: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_storage_images =
                max_per_stage_descriptor_update_after_bind_storage_images;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
            mut self,
            max_per_stage_descriptor_update_after_bind_input_attachments: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_input_attachments =
                max_per_stage_descriptor_update_after_bind_input_attachments;
            self
        }

        #[inline]
        pub fn max_per_stage_update_after_bind_resources(
            mut self,
            max_per_stage_update_after_bind_resources: u32,
        ) -> Self {
            self.max_per_stage_update_after_bind_resources =
                max_per_stage_update_after_bind_resources;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_samplers(
            mut self,
            max_descriptor_set_update_after_bind_samplers: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_samplers =
                max_descriptor_set_update_after_bind_samplers;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_uniform_buffers(
            mut self,
            max_descriptor_set_update_after_bind_uniform_buffers: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_uniform_buffers =
                max_descriptor_set_update_after_bind_uniform_buffers;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
            mut self,
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
                max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_storage_buffers(
            mut self,
            max_descriptor_set_update_after_bind_storage_buffers: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_storage_buffers =
                max_descriptor_set_update_after_bind_storage_buffers;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
            mut self,
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_storage_buffers_dynamic =
                max_descriptor_set_update_after_bind_storage_buffers_dynamic;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_sampled_images(
            mut self,
            max_descriptor_set_update_after_bind_sampled_images: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_sampled_images =
                max_descriptor_set_update_after_bind_sampled_images;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_storage_images(
            mut self,
            max_descriptor_set_update_after_bind_storage_images: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_storage_images =
                max_descriptor_set_update_after_bind_storage_images;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_input_attachments(
            mut self,
            max_descriptor_set_update_after_bind_input_attachments: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_input_attachments =
                max_descriptor_set_update_after_bind_input_attachments;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct DescriptorSetLayoutBindingFlagsCreateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub binding_count: u32,
        pub p_binding_flags: *const DescriptorBindingFlags,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for DescriptorSetLayoutBindingFlagsCreateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("DescriptorSetLayoutBindingFlagsCreateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("binding_count", &self.binding_count)
                .field("p_binding_flags", &self.p_binding_flags)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for DescriptorSetLayoutBindingFlagsCreateInfo<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
    }

    unsafe impl Extends<DescriptorSetLayoutCreateInfo<'_>>
        for DescriptorSetLayoutBindingFlagsCreateInfo<'_>
    {
    }

    impl Default for DescriptorSetLayoutBindingFlagsCreateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                binding_count: Default::default(),
                p_binding_flags: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> DescriptorSetLayoutBindingFlagsCreateInfo<'a> {
        #[inline]
        pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self {
            self.binding_count = binding_flags.len().try_into().unwrap();
            self.p_binding_flags = binding_flags.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct DescriptorSetVariableDescriptorCountAllocateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub descriptor_set_count: u32,
        pub p_descriptor_counts: *const u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for DescriptorSetVariableDescriptorCountAllocateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("DescriptorSetVariableDescriptorCountAllocateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("descriptor_set_count", &self.descriptor_set_count)
                .field("p_descriptor_counts", &self.p_descriptor_counts)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for DescriptorSetVariableDescriptorCountAllocateInfo<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
    }

    unsafe impl Extends<DescriptorSetAllocateInfo<'_>>
        for DescriptorSetVariableDescriptorCountAllocateInfo<'_>
    {
    }

    impl Default for DescriptorSetVariableDescriptorCountAllocateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                descriptor_set_count: Default::default(),
                p_descriptor_counts: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> DescriptorSetVariableDescriptorCountAllocateInfo<'a> {
        #[inline]
        pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self {
            self.descriptor_set_count = descriptor_counts.len().try_into().unwrap();
            self.p_descriptor_counts = descriptor_counts.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct DescriptorSetVariableDescriptorCountLayoutSupport<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub max_variable_descriptor_count: u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for DescriptorSetVariableDescriptorCountLayoutSupport<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("DescriptorSetVariableDescriptorCountLayoutSupport")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "max_variable_descriptor_count",
                    &self.max_variable_descriptor_count,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for DescriptorSetVariableDescriptorCountLayoutSupport<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
    }

    unsafe impl Extends<DescriptorSetLayoutSupport<'_>>
        for DescriptorSetVariableDescriptorCountLayoutSupport<'_>
    {
    }

    impl Default for DescriptorSetVariableDescriptorCountLayoutSupport<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                max_variable_descriptor_count: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> DescriptorSetVariableDescriptorCountLayoutSupport<'a> {
        #[inline]
        pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self {
            self.max_variable_descriptor_count = max_variable_descriptor_count;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescription2.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct AttachmentDescription2<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub flags: AttachmentDescriptionFlags,
        pub format: Format,
        pub samples: SampleCountFlagBits,
        pub load_op: AttachmentLoadOp,
        pub store_op: AttachmentStoreOp,
        pub stencil_load_op: AttachmentLoadOp,
        pub stencil_store_op: AttachmentStoreOp,
        pub initial_layout: ImageLayout,
        pub final_layout: ImageLayout,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for AttachmentDescription2<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("AttachmentDescription2")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("flags", &self.flags)
                .field("format", &self.format)
                .field("samples", &self.samples)
                .field("load_op", &self.load_op)
                .field("store_op", &self.store_op)
                .field("stencil_load_op", &self.stencil_load_op)
                .field("stencil_store_op", &self.stencil_store_op)
                .field("initial_layout", &self.initial_layout)
                .field("final_layout", &self.final_layout)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for AttachmentDescription2<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_2;
    }

    impl Default for AttachmentDescription2<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                flags: Default::default(),
                format: Default::default(),
                samples: Default::default(),
                load_op: Default::default(),
                store_op: Default::default(),
                stencil_load_op: Default::default(),
                stencil_store_op: Default::default(),
                initial_layout: Default::default(),
                final_layout: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> AttachmentDescription2<'a> {
        #[inline]
        pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn format(mut self, format: Format) -> Self {
            self.format = format;
            self
        }

        #[inline]
        pub fn samples(mut self, samples: SampleCountFlagBits) -> Self {
            self.samples = samples;
            self
        }

        #[inline]
        pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
            self.load_op = load_op;
            self
        }

        #[inline]
        pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
            self.store_op = store_op;
            self
        }

        #[inline]
        pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
            self.stencil_load_op = stencil_load_op;
            self
        }

        #[inline]
        pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
            self.stencil_store_op = stencil_store_op;
            self
        }

        #[inline]
        pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
            self.initial_layout = initial_layout;
            self
        }

        #[inline]
        pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
            self.final_layout = final_layout;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReference2.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct AttachmentReference2<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub attachment: u32,
        pub layout: ImageLayout,
        pub aspect_mask: ImageAspectFlags,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for AttachmentReference2<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("AttachmentReference2")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("attachment", &self.attachment)
                .field("layout", &self.layout)
                .field("aspect_mask", &self.aspect_mask)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for AttachmentReference2<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_2;
    }

    impl Default for AttachmentReference2<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                attachment: Default::default(),
                layout: Default::default(),
                aspect_mask: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> AttachmentReference2<'a> {
        #[inline]
        pub fn attachment(mut self, attachment: u32) -> Self {
            self.attachment = attachment;
            self
        }

        #[inline]
        pub fn layout(mut self, layout: ImageLayout) -> Self {
            self.layout = layout;
            self
        }

        #[inline]
        pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
            self.aspect_mask = aspect_mask;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescription2.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SubpassDescription2<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub flags: SubpassDescriptionFlags,
        pub pipeline_bind_point: PipelineBindPoint,
        pub view_mask: u32,
        pub input_attachment_count: u32,
        pub p_input_attachments: *const AttachmentReference2<'a>,
        pub color_attachment_count: u32,
        pub p_color_attachments: *const AttachmentReference2<'a>,
        pub p_resolve_attachments: *const AttachmentReference2<'a>,
        pub p_depth_stencil_attachment: *const AttachmentReference2<'a>,
        pub preserve_attachment_count: u32,
        pub p_preserve_attachments: *const u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SubpassDescription2<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SubpassDescription2")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("flags", &self.flags)
                .field("pipeline_bind_point", &self.pipeline_bind_point)
                .field("view_mask", &self.view_mask)
                .field("input_attachment_count", &self.input_attachment_count)
                .field("p_input_attachments", &self.p_input_attachments)
                .field("color_attachment_count", &self.color_attachment_count)
                .field("p_color_attachments", &self.p_color_attachments)
                .field("p_resolve_attachments", &self.p_resolve_attachments)
                .field(
                    "p_depth_stencil_attachment",
                    &self.p_depth_stencil_attachment,
                )
                .field("preserve_attachment_count", &self.preserve_attachment_count)
                .field("p_preserve_attachments", &self.p_preserve_attachments)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SubpassDescription2<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_2;
    }

    impl Default for SubpassDescription2<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                flags: Default::default(),
                pipeline_bind_point: Default::default(),
                view_mask: Default::default(),
                input_attachment_count: Default::default(),
                p_input_attachments: ptr::null(),
                color_attachment_count: Default::default(),
                p_color_attachments: ptr::null(),
                p_resolve_attachments: ptr::null(),
                p_depth_stencil_attachment: ptr::null(),
                preserve_attachment_count: Default::default(),
                p_preserve_attachments: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SubpassDescription2<'a> {
        #[inline]
        pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
            self.pipeline_bind_point = pipeline_bind_point;
            self
        }

        #[inline]
        pub fn view_mask(mut self, view_mask: u32) -> Self {
            self.view_mask = view_mask;
            self
        }

        #[inline]
        pub fn input_attachments(
            mut self,
            input_attachments: &'a [AttachmentReference2<'_>],
        ) -> Self {
            self.input_attachment_count = input_attachments.len().try_into().unwrap();
            self.p_input_attachments = input_attachments.as_ptr() as _;
            self
        }

        #[inline]
        pub fn color_attachments(
            mut self,
            color_attachments: &'a [AttachmentReference2<'_>],
            resolve_attachments: Option<&'a [AttachmentReference2<'_>]>,
        ) -> Self {
            self.color_attachment_count = color_attachments.len().try_into().unwrap();
            if let Some(s) = &resolve_attachments {
                assert_eq!(s.len(), self.color_attachment_count as usize);
            }
            self.p_color_attachments = color_attachments.as_ptr() as _;
            self.p_resolve_attachments =
                resolve_attachments.map_or(ptr::null(), |s| s.as_ptr() as _);
            self
        }

        #[inline]
        pub fn depth_stencil_attachment(
            mut self,
            depth_stencil_attachment: &'a AttachmentReference2<'a>,
        ) -> Self {
            self.p_depth_stencil_attachment = depth_stencil_attachment;
            self
        }

        #[inline]
        pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
            self.preserve_attachment_count = preserve_attachments.len().try_into().unwrap();
            self.p_preserve_attachments = preserve_attachments.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDependency2.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SubpassDependency2<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub src_subpass: u32,
        pub dst_subpass: u32,
        pub src_stage_mask: PipelineStageFlags,
        pub dst_stage_mask: PipelineStageFlags,
        pub src_access_mask: AccessFlags,
        pub dst_access_mask: AccessFlags,
        pub dependency_flags: DependencyFlags,
        pub view_offset: i32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SubpassDependency2<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SubpassDependency2")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("src_subpass", &self.src_subpass)
                .field("dst_subpass", &self.dst_subpass)
                .field("src_stage_mask", &self.src_stage_mask)
                .field("dst_stage_mask", &self.dst_stage_mask)
                .field("src_access_mask", &self.src_access_mask)
                .field("dst_access_mask", &self.dst_access_mask)
                .field("dependency_flags", &self.dependency_flags)
                .field("view_offset", &self.view_offset)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SubpassDependency2<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DEPENDENCY_2;
    }

    impl Default for SubpassDependency2<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                src_subpass: Default::default(),
                dst_subpass: Default::default(),
                src_stage_mask: Default::default(),
                dst_stage_mask: Default::default(),
                src_access_mask: Default::default(),
                dst_access_mask: Default::default(),
                dependency_flags: Default::default(),
                view_offset: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SubpassDependency2<'a> {
        #[inline]
        pub fn src_subpass(mut self, src_subpass: u32) -> Self {
            self.src_subpass = src_subpass;
            self
        }

        #[inline]
        pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
            self.dst_subpass = dst_subpass;
            self
        }

        #[inline]
        pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
            self.src_stage_mask = src_stage_mask;
            self
        }

        #[inline]
        pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
            self.dst_stage_mask = dst_stage_mask;
            self
        }

        #[inline]
        pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
            self.src_access_mask = src_access_mask;
            self
        }

        #[inline]
        pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
            self.dst_access_mask = dst_access_mask;
            self
        }

        #[inline]
        pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
            self.dependency_flags = dependency_flags;
            self
        }

        #[inline]
        pub fn view_offset(mut self, view_offset: i32) -> Self {
            self.view_offset = view_offset;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateInfo2.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct RenderPassCreateInfo2<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub flags: RenderPassCreateFlags,
        pub attachment_count: u32,
        pub p_attachments: *const AttachmentDescription2<'a>,
        pub subpass_count: u32,
        pub p_subpasses: *const SubpassDescription2<'a>,
        pub dependency_count: u32,
        pub p_dependencies: *const SubpassDependency2<'a>,
        pub correlated_view_mask_count: u32,
        pub p_correlated_view_masks: *const u32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for RenderPassCreateInfo2<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("RenderPassCreateInfo2")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("flags", &self.flags)
                .field("attachment_count", &self.attachment_count)
                .field("p_attachments", &self.p_attachments)
                .field("subpass_count", &self.subpass_count)
                .field("p_subpasses", &self.p_subpasses)
                .field("dependency_count", &self.dependency_count)
                .field("p_dependencies", &self.p_dependencies)
                .field(
                    "correlated_view_mask_count",
                    &self.correlated_view_mask_count,
                )
                .field("p_correlated_view_masks", &self.p_correlated_view_masks)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for RenderPassCreateInfo2<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO_2;
    }

    impl Default for RenderPassCreateInfo2<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                flags: Default::default(),
                attachment_count: Default::default(),
                p_attachments: ptr::null(),
                subpass_count: Default::default(),
                p_subpasses: ptr::null(),
                dependency_count: Default::default(),
                p_dependencies: ptr::null(),
                correlated_view_mask_count: Default::default(),
                p_correlated_view_masks: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> RenderPassCreateInfo2<'a> {
        #[inline]
        pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn attachments(mut self, attachments: &'a [AttachmentDescription2<'_>]) -> Self {
            self.attachment_count = attachments.len().try_into().unwrap();
            self.p_attachments = attachments.as_ptr() as _;
            self
        }

        #[inline]
        pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2<'_>]) -> Self {
            self.subpass_count = subpasses.len().try_into().unwrap();
            self.p_subpasses = subpasses.as_ptr() as _;
            self
        }

        #[inline]
        pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2<'_>]) -> Self {
            self.dependency_count = dependencies.len().try_into().unwrap();
            self.p_dependencies = dependencies.as_ptr() as _;
            self
        }

        #[inline]
        pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self {
            self.correlated_view_mask_count = correlated_view_masks.len().try_into().unwrap();
            self.p_correlated_view_masks = correlated_view_masks.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassBeginInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SubpassBeginInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub contents: SubpassContents,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SubpassBeginInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SubpassBeginInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("contents", &self.contents)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SubpassBeginInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_BEGIN_INFO;
    }

    impl Default for SubpassBeginInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                contents: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SubpassBeginInfo<'a> {
        #[inline]
        pub fn contents(mut self, contents: SubpassContents) -> Self {
            self.contents = contents;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassEndInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SubpassEndInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SubpassEndInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SubpassEndInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SubpassEndInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_END_INFO;
    }

    impl Default for SubpassEndInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SubpassEndInfo<'a> {}

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceTimelineSemaphoreFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub timeline_semaphore: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceTimelineSemaphoreFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceTimelineSemaphoreFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("timeline_semaphore", &self.timeline_semaphore)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceTimelineSemaphoreFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceTimelineSemaphoreFeatures<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceTimelineSemaphoreFeatures<'_> {}

    impl Default for PhysicalDeviceTimelineSemaphoreFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                timeline_semaphore: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceTimelineSemaphoreFeatures<'a> {
        #[inline]
        pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
            self.timeline_semaphore = timeline_semaphore.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceTimelineSemaphoreProperties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub max_timeline_semaphore_value_difference: u64,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceTimelineSemaphoreProperties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceTimelineSemaphoreProperties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "max_timeline_semaphore_value_difference",
                    &self.max_timeline_semaphore_value_difference,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceTimelineSemaphoreProperties<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>>
        for PhysicalDeviceTimelineSemaphoreProperties<'_>
    {
    }

    impl Default for PhysicalDeviceTimelineSemaphoreProperties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                max_timeline_semaphore_value_difference: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceTimelineSemaphoreProperties<'a> {
        #[inline]
        pub fn max_timeline_semaphore_value_difference(
            mut self,
            max_timeline_semaphore_value_difference: u64,
        ) -> Self {
            self.max_timeline_semaphore_value_difference = max_timeline_semaphore_value_difference;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreTypeCreateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SemaphoreTypeCreateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub semaphore_type: SemaphoreType,
        pub initial_value: u64,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SemaphoreTypeCreateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SemaphoreTypeCreateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("semaphore_type", &self.semaphore_type)
                .field("initial_value", &self.initial_value)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SemaphoreTypeCreateInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_TYPE_CREATE_INFO;
    }

    unsafe impl Extends<SemaphoreCreateInfo<'_>> for SemaphoreTypeCreateInfo<'_> {}
    unsafe impl Extends<PhysicalDeviceExternalSemaphoreInfo<'_>> for SemaphoreTypeCreateInfo<'_> {}

    impl Default for SemaphoreTypeCreateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                semaphore_type: Default::default(),
                initial_value: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SemaphoreTypeCreateInfo<'a> {
        #[inline]
        pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self {
            self.semaphore_type = semaphore_type;
            self
        }

        #[inline]
        pub fn initial_value(mut self, initial_value: u64) -> Self {
            self.initial_value = initial_value;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkTimelineSemaphoreSubmitInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct TimelineSemaphoreSubmitInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub wait_semaphore_value_count: u32,
        pub p_wait_semaphore_values: *const u64,
        pub signal_semaphore_value_count: u32,
        pub p_signal_semaphore_values: *const u64,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for TimelineSemaphoreSubmitInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("TimelineSemaphoreSubmitInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "wait_semaphore_value_count",
                    &self.wait_semaphore_value_count,
                )
                .field("p_wait_semaphore_values", &self.p_wait_semaphore_values)
                .field(
                    "signal_semaphore_value_count",
                    &self.signal_semaphore_value_count,
                )
                .field("p_signal_semaphore_values", &self.p_signal_semaphore_values)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for TimelineSemaphoreSubmitInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO;
    }

    unsafe impl Extends<SubmitInfo<'_>> for TimelineSemaphoreSubmitInfo<'_> {}
    unsafe impl Extends<BindSparseInfo<'_>> for TimelineSemaphoreSubmitInfo<'_> {}

    impl Default for TimelineSemaphoreSubmitInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                wait_semaphore_value_count: Default::default(),
                p_wait_semaphore_values: ptr::null(),
                signal_semaphore_value_count: Default::default(),
                p_signal_semaphore_values: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> TimelineSemaphoreSubmitInfo<'a> {
        #[inline]
        pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
            self.wait_semaphore_value_count = wait_semaphore_values.len().try_into().unwrap();
            self.p_wait_semaphore_values = wait_semaphore_values.as_ptr() as _;
            self
        }

        #[inline]
        pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
            self.signal_semaphore_value_count = signal_semaphore_values.len().try_into().unwrap();
            self.p_signal_semaphore_values = signal_semaphore_values.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SemaphoreWaitInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub flags: SemaphoreWaitFlags,
        pub semaphore_count: u32,
        pub p_semaphores: *const Semaphore,
        pub p_values: *const u64,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SemaphoreWaitInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SemaphoreWaitInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("flags", &self.flags)
                .field("semaphore_count", &self.semaphore_count)
                .field("p_semaphores", &self.p_semaphores)
                .field("p_values", &self.p_values)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SemaphoreWaitInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_WAIT_INFO;
    }

    impl Default for SemaphoreWaitInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                flags: Default::default(),
                semaphore_count: Default::default(),
                p_semaphores: ptr::null(),
                p_values: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SemaphoreWaitInfo<'a> {
        #[inline]
        pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn semaphores(mut self, semaphores: &'a [Semaphore], values: &'a [u64]) -> Self {
            self.semaphore_count = semaphores.len().try_into().unwrap();
            assert_eq!(values.len(), self.semaphore_count as usize);
            self.p_semaphores = semaphores.as_ptr() as _;
            self.p_values = values.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreSignalInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SemaphoreSignalInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub semaphore: Semaphore,
        pub value: u64,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SemaphoreSignalInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SemaphoreSignalInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("semaphore", &self.semaphore)
                .field("value", &self.value)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SemaphoreSignalInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SIGNAL_INFO;
    }

    impl Default for SemaphoreSignalInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                semaphore: Default::default(),
                value: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SemaphoreSignalInfo<'a> {
        #[inline]
        pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
            self.semaphore = semaphore;
            self
        }

        #[inline]
        pub fn value(mut self, value: u64) -> Self {
            self.value = value;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice8BitStorageFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDevice8BitStorageFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub storage_buffer8_bit_access: Bool32,
        pub uniform_and_storage_buffer8_bit_access: Bool32,
        pub storage_push_constant8: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDevice8BitStorageFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDevice8BitStorageFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "storage_buffer8_bit_access",
                    &self.storage_buffer8_bit_access,
                )
                .field(
                    "uniform_and_storage_buffer8_bit_access",
                    &self.uniform_and_storage_buffer8_bit_access,
                )
                .field("storage_push_constant8", &self.storage_push_constant8)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDevice8BitStorageFeatures<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDevice8BitStorageFeatures<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDevice8BitStorageFeatures<'_> {}

    impl Default for PhysicalDevice8BitStorageFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                storage_buffer8_bit_access: Default::default(),
                uniform_and_storage_buffer8_bit_access: Default::default(),
                storage_push_constant8: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDevice8BitStorageFeatures<'a> {
        #[inline]
        pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
            self.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
            self
        }

        #[inline]
        pub fn uniform_and_storage_buffer8_bit_access(
            mut self,
            uniform_and_storage_buffer8_bit_access: bool,
        ) -> Self {
            self.uniform_and_storage_buffer8_bit_access =
                uniform_and_storage_buffer8_bit_access.into();
            self
        }

        #[inline]
        pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
            self.storage_push_constant8 = storage_push_constant8.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceVulkanMemoryModelFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub vulkan_memory_model: Bool32,
        pub vulkan_memory_model_device_scope: Bool32,
        pub vulkan_memory_model_availability_visibility_chains: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceVulkanMemoryModelFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceVulkanMemoryModelFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("vulkan_memory_model", &self.vulkan_memory_model)
                .field(
                    "vulkan_memory_model_device_scope",
                    &self.vulkan_memory_model_device_scope,
                )
                .field(
                    "vulkan_memory_model_availability_visibility_chains",
                    &self.vulkan_memory_model_availability_visibility_chains,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceVulkanMemoryModelFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceVulkanMemoryModelFeatures<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceVulkanMemoryModelFeatures<'_> {}

    impl Default for PhysicalDeviceVulkanMemoryModelFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                vulkan_memory_model: Default::default(),
                vulkan_memory_model_device_scope: Default::default(),
                vulkan_memory_model_availability_visibility_chains: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceVulkanMemoryModelFeatures<'a> {
        #[inline]
        pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
            self.vulkan_memory_model = vulkan_memory_model.into();
            self
        }

        #[inline]
        pub fn vulkan_memory_model_device_scope(
            mut self,
            vulkan_memory_model_device_scope: bool,
        ) -> Self {
            self.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
            self
        }

        #[inline]
        pub fn vulkan_memory_model_availability_visibility_chains(
            mut self,
            vulkan_memory_model_availability_visibility_chains: bool,
        ) -> Self {
            self.vulkan_memory_model_availability_visibility_chains =
                vulkan_memory_model_availability_visibility_chains.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceShaderAtomicInt64Features<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub shader_buffer_int64_atomics: Bool32,
        pub shader_shared_int64_atomics: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceShaderAtomicInt64Features<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceShaderAtomicInt64Features")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "shader_buffer_int64_atomics",
                    &self.shader_buffer_int64_atomics,
                )
                .field(
                    "shader_shared_int64_atomics",
                    &self.shader_shared_int64_atomics,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderAtomicInt64Features<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceShaderAtomicInt64Features<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceShaderAtomicInt64Features<'_> {}

    impl Default for PhysicalDeviceShaderAtomicInt64Features<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                shader_buffer_int64_atomics: Default::default(),
                shader_shared_int64_atomics: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceShaderAtomicInt64Features<'a> {
        #[inline]
        pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
            self.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
            self
        }

        #[inline]
        pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
            self.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceDepthStencilResolveProperties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub supported_depth_resolve_modes: ResolveModeFlags,
        pub supported_stencil_resolve_modes: ResolveModeFlags,
        pub independent_resolve_none: Bool32,
        pub independent_resolve: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceDepthStencilResolveProperties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceDepthStencilResolveProperties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "supported_depth_resolve_modes",
                    &self.supported_depth_resolve_modes,
                )
                .field(
                    "supported_stencil_resolve_modes",
                    &self.supported_stencil_resolve_modes,
                )
                .field("independent_resolve_none", &self.independent_resolve_none)
                .field("independent_resolve", &self.independent_resolve)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceDepthStencilResolveProperties<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>>
        for PhysicalDeviceDepthStencilResolveProperties<'_>
    {
    }

    impl Default for PhysicalDeviceDepthStencilResolveProperties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                supported_depth_resolve_modes: Default::default(),
                supported_stencil_resolve_modes: Default::default(),
                independent_resolve_none: Default::default(),
                independent_resolve: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceDepthStencilResolveProperties<'a> {
        #[inline]
        pub fn supported_depth_resolve_modes(
            mut self,
            supported_depth_resolve_modes: ResolveModeFlags,
        ) -> Self {
            self.supported_depth_resolve_modes = supported_depth_resolve_modes;
            self
        }

        #[inline]
        pub fn supported_stencil_resolve_modes(
            mut self,
            supported_stencil_resolve_modes: ResolveModeFlags,
        ) -> Self {
            self.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
            self
        }

        #[inline]
        pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
            self.independent_resolve_none = independent_resolve_none.into();
            self
        }

        #[inline]
        pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
            self.independent_resolve = independent_resolve.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionDepthStencilResolve.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct SubpassDescriptionDepthStencilResolve<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub depth_resolve_mode: ResolveModeFlagBits,
        pub stencil_resolve_mode: ResolveModeFlagBits,
        pub p_depth_stencil_resolve_attachment: *const AttachmentReference2<'a>,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for SubpassDescriptionDepthStencilResolve<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("SubpassDescriptionDepthStencilResolve")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("depth_resolve_mode", &self.depth_resolve_mode)
                .field("stencil_resolve_mode", &self.stencil_resolve_mode)
                .field(
                    "p_depth_stencil_resolve_attachment",
                    &self.p_depth_stencil_resolve_attachment,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for SubpassDescriptionDepthStencilResolve<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
    }

    unsafe impl Extends<SubpassDescription2<'_>> for SubpassDescriptionDepthStencilResolve<'_> {}

    impl Default for SubpassDescriptionDepthStencilResolve<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                depth_resolve_mode: Default::default(),
                stencil_resolve_mode: Default::default(),
                p_depth_stencil_resolve_attachment: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> SubpassDescriptionDepthStencilResolve<'a> {
        #[inline]
        pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlagBits) -> Self {
            self.depth_resolve_mode = depth_resolve_mode;
            self
        }

        #[inline]
        pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlagBits) -> Self {
            self.stencil_resolve_mode = stencil_resolve_mode;
            self
        }

        #[inline]
        pub fn depth_stencil_resolve_attachment(
            mut self,
            depth_stencil_resolve_attachment: &'a AttachmentReference2<'a>,
        ) -> Self {
            self.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageStencilUsageCreateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct ImageStencilUsageCreateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub stencil_usage: ImageUsageFlags,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for ImageStencilUsageCreateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("ImageStencilUsageCreateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("stencil_usage", &self.stencil_usage)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for ImageStencilUsageCreateInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO;
    }

    unsafe impl Extends<ImageCreateInfo<'_>> for ImageStencilUsageCreateInfo<'_> {}
    unsafe impl Extends<PhysicalDeviceImageFormatInfo2<'_>> for ImageStencilUsageCreateInfo<'_> {}

    impl Default for ImageStencilUsageCreateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                stencil_usage: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> ImageStencilUsageCreateInfo<'a> {
        #[inline]
        pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self {
            self.stencil_usage = stencil_usage;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceScalarBlockLayoutFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub scalar_block_layout: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceScalarBlockLayoutFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceScalarBlockLayoutFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("scalar_block_layout", &self.scalar_block_layout)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceScalarBlockLayoutFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceScalarBlockLayoutFeatures<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceScalarBlockLayoutFeatures<'_> {}

    impl Default for PhysicalDeviceScalarBlockLayoutFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                scalar_block_layout: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceScalarBlockLayoutFeatures<'a> {
        #[inline]
        pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
            self.scalar_block_layout = scalar_block_layout.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub uniform_buffer_standard_layout: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceUniformBufferStandardLayoutFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "uniform_buffer_standard_layout",
                    &self.uniform_buffer_standard_layout,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>>
        for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_>
    {
    }
    unsafe impl Extends<DeviceCreateInfo<'_>>
        for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_>
    {
    }

    impl Default for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                uniform_buffer_standard_layout: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> {
        #[inline]
        pub fn uniform_buffer_standard_layout(
            mut self,
            uniform_buffer_standard_layout: bool,
        ) -> Self {
            self.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceBufferDeviceAddressFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub buffer_device_address: Bool32,
        pub buffer_device_address_capture_replay: Bool32,
        pub buffer_device_address_multi_device: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceBufferDeviceAddressFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceBufferDeviceAddressFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("buffer_device_address", &self.buffer_device_address)
                .field(
                    "buffer_device_address_capture_replay",
                    &self.buffer_device_address_capture_replay,
                )
                .field(
                    "buffer_device_address_multi_device",
                    &self.buffer_device_address_multi_device,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceBufferDeviceAddressFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceBufferDeviceAddressFeatures<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceBufferDeviceAddressFeatures<'_> {}

    impl Default for PhysicalDeviceBufferDeviceAddressFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                buffer_device_address: Default::default(),
                buffer_device_address_capture_replay: Default::default(),
                buffer_device_address_multi_device: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceBufferDeviceAddressFeatures<'a> {
        #[inline]
        pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
            self.buffer_device_address = buffer_device_address.into();
            self
        }

        #[inline]
        pub fn buffer_device_address_capture_replay(
            mut self,
            buffer_device_address_capture_replay: bool,
        ) -> Self {
            self.buffer_device_address_capture_replay = buffer_device_address_capture_replay.into();
            self
        }

        #[inline]
        pub fn buffer_device_address_multi_device(
            mut self,
            buffer_device_address_multi_device: bool,
        ) -> Self {
            self.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferDeviceAddressInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct BufferDeviceAddressInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub buffer: Buffer,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for BufferDeviceAddressInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("BufferDeviceAddressInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("buffer", &self.buffer)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for BufferDeviceAddressInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_INFO;
    }

    impl Default for BufferDeviceAddressInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                buffer: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> BufferDeviceAddressInfo<'a> {
        #[inline]
        pub fn buffer(mut self, buffer: Buffer) -> Self {
            self.buffer = buffer;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct BufferOpaqueCaptureAddressCreateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub opaque_capture_address: u64,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for BufferOpaqueCaptureAddressCreateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("BufferOpaqueCaptureAddressCreateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("opaque_capture_address", &self.opaque_capture_address)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for BufferOpaqueCaptureAddressCreateInfo<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
    }

    unsafe impl Extends<BufferCreateInfo<'_>> for BufferOpaqueCaptureAddressCreateInfo<'_> {}

    impl Default for BufferOpaqueCaptureAddressCreateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                opaque_capture_address: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> BufferOpaqueCaptureAddressCreateInfo<'a> {
        #[inline]
        pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
            self.opaque_capture_address = opaque_capture_address;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceImagelessFramebufferFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub imageless_framebuffer: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceImagelessFramebufferFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceImagelessFramebufferFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("imageless_framebuffer", &self.imageless_framebuffer)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceImagelessFramebufferFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>>
        for PhysicalDeviceImagelessFramebufferFeatures<'_>
    {
    }
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceImagelessFramebufferFeatures<'_> {}

    impl Default for PhysicalDeviceImagelessFramebufferFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                imageless_framebuffer: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceImagelessFramebufferFeatures<'a> {
        #[inline]
        pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
            self.imageless_framebuffer = imageless_framebuffer.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferAttachmentsCreateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct FramebufferAttachmentsCreateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub attachment_image_info_count: u32,
        pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo<'a>,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for FramebufferAttachmentsCreateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("FramebufferAttachmentsCreateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "attachment_image_info_count",
                    &self.attachment_image_info_count,
                )
                .field("p_attachment_image_infos", &self.p_attachment_image_infos)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for FramebufferAttachmentsCreateInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
    }

    unsafe impl Extends<FramebufferCreateInfo<'_>> for FramebufferAttachmentsCreateInfo<'_> {}

    impl Default for FramebufferAttachmentsCreateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                attachment_image_info_count: Default::default(),
                p_attachment_image_infos: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> FramebufferAttachmentsCreateInfo<'a> {
        #[inline]
        pub fn attachment_image_infos(
            mut self,
            attachment_image_infos: &'a [FramebufferAttachmentImageInfo<'_>],
        ) -> Self {
            self.attachment_image_info_count = attachment_image_infos.len().try_into().unwrap();
            self.p_attachment_image_infos = attachment_image_infos.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferAttachmentImageInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct FramebufferAttachmentImageInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub flags: ImageCreateFlags,
        pub usage: ImageUsageFlags,
        pub width: u32,
        pub height: u32,
        pub layer_count: u32,
        pub view_format_count: u32,
        pub p_view_formats: *const Format,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for FramebufferAttachmentImageInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("FramebufferAttachmentImageInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("flags", &self.flags)
                .field("usage", &self.usage)
                .field("width", &self.width)
                .field("height", &self.height)
                .field("layer_count", &self.layer_count)
                .field("view_format_count", &self.view_format_count)
                .field("p_view_formats", &self.p_view_formats)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for FramebufferAttachmentImageInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
    }

    impl Default for FramebufferAttachmentImageInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                flags: Default::default(),
                usage: Default::default(),
                width: Default::default(),
                height: Default::default(),
                layer_count: Default::default(),
                view_format_count: Default::default(),
                p_view_formats: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> FramebufferAttachmentImageInfo<'a> {
        #[inline]
        pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
            self.usage = usage;
            self
        }

        #[inline]
        pub fn width(mut self, width: u32) -> Self {
            self.width = width;
            self
        }

        #[inline]
        pub fn height(mut self, height: u32) -> Self {
            self.height = height;
            self
        }

        #[inline]
        pub fn layer_count(mut self, layer_count: u32) -> Self {
            self.layer_count = layer_count;
            self
        }

        #[inline]
        pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
            self.view_format_count = view_formats.len().try_into().unwrap();
            self.p_view_formats = view_formats.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassAttachmentBeginInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct RenderPassAttachmentBeginInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub attachment_count: u32,
        pub p_attachments: *const ImageView,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for RenderPassAttachmentBeginInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("RenderPassAttachmentBeginInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("attachment_count", &self.attachment_count)
                .field("p_attachments", &self.p_attachments)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for RenderPassAttachmentBeginInfo<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO;
    }

    unsafe impl Extends<RenderPassBeginInfo<'_>> for RenderPassAttachmentBeginInfo<'_> {}

    impl Default for RenderPassAttachmentBeginInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                attachment_count: Default::default(),
                p_attachments: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> RenderPassAttachmentBeginInfo<'a> {
        #[inline]
        pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
            self.attachment_count = attachments.len().try_into().unwrap();
            self.p_attachments = attachments.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub separate_depth_stencil_layouts: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceSeparateDepthStencilLayoutsFeatures")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "separate_depth_stencil_layouts",
                    &self.separate_depth_stencil_layouts,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>>
        for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_>
    {
    }
    unsafe impl Extends<DeviceCreateInfo<'_>>
        for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_>
    {
    }

    impl Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                separate_depth_stencil_layouts: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> {
        #[inline]
        pub fn separate_depth_stencil_layouts(
            mut self,
            separate_depth_stencil_layouts: bool,
        ) -> Self {
            self.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReferenceStencilLayout.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct AttachmentReferenceStencilLayout<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub stencil_layout: ImageLayout,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for AttachmentReferenceStencilLayout<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("AttachmentReferenceStencilLayout")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("stencil_layout", &self.stencil_layout)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for AttachmentReferenceStencilLayout<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
    }

    unsafe impl Extends<AttachmentReference2<'_>> for AttachmentReferenceStencilLayout<'_> {}

    impl Default for AttachmentReferenceStencilLayout<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                stencil_layout: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> AttachmentReferenceStencilLayout<'a> {
        #[inline]
        pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self {
            self.stencil_layout = stencil_layout;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionStencilLayout.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct AttachmentDescriptionStencilLayout<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub stencil_initial_layout: ImageLayout,
        pub stencil_final_layout: ImageLayout,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for AttachmentDescriptionStencilLayout<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("AttachmentDescriptionStencilLayout")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("stencil_initial_layout", &self.stencil_initial_layout)
                .field("stencil_final_layout", &self.stencil_final_layout)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for AttachmentDescriptionStencilLayout<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
    }

    unsafe impl Extends<AttachmentDescription2<'_>> for AttachmentDescriptionStencilLayout<'_> {}

    impl Default for AttachmentDescriptionStencilLayout<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                stencil_initial_layout: Default::default(),
                stencil_final_layout: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> AttachmentDescriptionStencilLayout<'a> {
        #[inline]
        pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self {
            self.stencil_initial_layout = stencil_initial_layout;
            self
        }

        #[inline]
        pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self {
            self.stencil_final_layout = stencil_final_layout;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct MemoryOpaqueCaptureAddressAllocateInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub opaque_capture_address: u64,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for MemoryOpaqueCaptureAddressAllocateInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("MemoryOpaqueCaptureAddressAllocateInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("opaque_capture_address", &self.opaque_capture_address)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for MemoryOpaqueCaptureAddressAllocateInfo<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
    }

    unsafe impl Extends<MemoryAllocateInfo<'_>> for MemoryOpaqueCaptureAddressAllocateInfo<'_> {}

    impl Default for MemoryOpaqueCaptureAddressAllocateInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                opaque_capture_address: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> MemoryOpaqueCaptureAddressAllocateInfo<'a> {
        #[inline]
        pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
            self.opaque_capture_address = opaque_capture_address;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct DeviceMemoryOpaqueCaptureAddressInfo<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub memory: DeviceMemory,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for DeviceMemoryOpaqueCaptureAddressInfo<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("DeviceMemoryOpaqueCaptureAddressInfo")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("memory", &self.memory)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for DeviceMemoryOpaqueCaptureAddressInfo<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
    }

    impl Default for DeviceMemoryOpaqueCaptureAddressInfo<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                memory: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> DeviceMemoryOpaqueCaptureAddressInfo<'a> {
        #[inline]
        pub fn memory(mut self, memory: DeviceMemory) -> Self {
            self.memory = memory;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Features.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceVulkan11Features<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub storage_buffer16_bit_access: Bool32,
        pub uniform_and_storage_buffer16_bit_access: Bool32,
        pub storage_push_constant16: Bool32,
        pub storage_input_output16: Bool32,
        pub multiview: Bool32,
        pub multiview_geometry_shader: Bool32,
        pub multiview_tessellation_shader: Bool32,
        pub variable_pointers_storage_buffer: Bool32,
        pub variable_pointers: Bool32,
        pub protected_memory: Bool32,
        pub sampler_ycbcr_conversion: Bool32,
        pub shader_draw_parameters: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceVulkan11Features<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceVulkan11Features")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "storage_buffer16_bit_access",
                    &self.storage_buffer16_bit_access,
                )
                .field(
                    "uniform_and_storage_buffer16_bit_access",
                    &self.uniform_and_storage_buffer16_bit_access,
                )
                .field("storage_push_constant16", &self.storage_push_constant16)
                .field("storage_input_output16", &self.storage_input_output16)
                .field("multiview", &self.multiview)
                .field("multiview_geometry_shader", &self.multiview_geometry_shader)
                .field(
                    "multiview_tessellation_shader",
                    &self.multiview_tessellation_shader,
                )
                .field(
                    "variable_pointers_storage_buffer",
                    &self.variable_pointers_storage_buffer,
                )
                .field("variable_pointers", &self.variable_pointers)
                .field("protected_memory", &self.protected_memory)
                .field("sampler_ycbcr_conversion", &self.sampler_ycbcr_conversion)
                .field("shader_draw_parameters", &self.shader_draw_parameters)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceVulkan11Features<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceVulkan11Features<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceVulkan11Features<'_> {}

    impl Default for PhysicalDeviceVulkan11Features<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                storage_buffer16_bit_access: Default::default(),
                uniform_and_storage_buffer16_bit_access: Default::default(),
                storage_push_constant16: Default::default(),
                storage_input_output16: Default::default(),
                multiview: Default::default(),
                multiview_geometry_shader: Default::default(),
                multiview_tessellation_shader: Default::default(),
                variable_pointers_storage_buffer: Default::default(),
                variable_pointers: Default::default(),
                protected_memory: Default::default(),
                sampler_ycbcr_conversion: Default::default(),
                shader_draw_parameters: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceVulkan11Features<'a> {
        #[inline]
        pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
            self.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
            self
        }

        #[inline]
        pub fn uniform_and_storage_buffer16_bit_access(
            mut self,
            uniform_and_storage_buffer16_bit_access: bool,
        ) -> Self {
            self.uniform_and_storage_buffer16_bit_access =
                uniform_and_storage_buffer16_bit_access.into();
            self
        }

        #[inline]
        pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
            self.storage_push_constant16 = storage_push_constant16.into();
            self
        }

        #[inline]
        pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
            self.storage_input_output16 = storage_input_output16.into();
            self
        }

        #[inline]
        pub fn multiview(mut self, multiview: bool) -> Self {
            self.multiview = multiview.into();
            self
        }

        #[inline]
        pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
            self.multiview_geometry_shader = multiview_geometry_shader.into();
            self
        }

        #[inline]
        pub fn multiview_tessellation_shader(
            mut self,
            multiview_tessellation_shader: bool,
        ) -> Self {
            self.multiview_tessellation_shader = multiview_tessellation_shader.into();
            self
        }

        #[inline]
        pub fn variable_pointers_storage_buffer(
            mut self,
            variable_pointers_storage_buffer: bool,
        ) -> Self {
            self.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
            self
        }

        #[inline]
        pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
            self.variable_pointers = variable_pointers.into();
            self
        }

        #[inline]
        pub fn protected_memory(mut self, protected_memory: bool) -> Self {
            self.protected_memory = protected_memory.into();
            self
        }

        #[inline]
        pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
            self.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
            self
        }

        #[inline]
        pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
            self.shader_draw_parameters = shader_draw_parameters.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Properties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceVulkan11Properties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub device_uuid: [u8; UUID_SIZE as usize],
        pub driver_uuid: [u8; UUID_SIZE as usize],
        pub device_luid: [u8; LUID_SIZE as usize],
        pub device_node_mask: u32,
        pub device_luid_valid: Bool32,
        pub subgroup_size: u32,
        pub subgroup_supported_stages: ShaderStageFlags,
        pub subgroup_supported_operations: SubgroupFeatureFlags,
        pub subgroup_quad_operations_in_all_stages: Bool32,
        pub point_clipping_behavior: PointClippingBehavior,
        pub max_multiview_view_count: u32,
        pub max_multiview_instance_index: u32,
        pub protected_no_fault: Bool32,
        pub max_per_set_descriptors: u32,
        pub max_memory_allocation_size: DeviceSize,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceVulkan11Properties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceVulkan11Properties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("device_uuid", &self.device_uuid)
                .field("driver_uuid", &self.driver_uuid)
                .field("device_luid", &self.device_luid)
                .field("device_node_mask", &self.device_node_mask)
                .field("device_luid_valid", &self.device_luid_valid)
                .field("subgroup_size", &self.subgroup_size)
                .field("subgroup_supported_stages", &self.subgroup_supported_stages)
                .field(
                    "subgroup_supported_operations",
                    &self.subgroup_supported_operations,
                )
                .field(
                    "subgroup_quad_operations_in_all_stages",
                    &self.subgroup_quad_operations_in_all_stages,
                )
                .field("point_clipping_behavior", &self.point_clipping_behavior)
                .field("max_multiview_view_count", &self.max_multiview_view_count)
                .field(
                    "max_multiview_instance_index",
                    &self.max_multiview_instance_index,
                )
                .field("protected_no_fault", &self.protected_no_fault)
                .field("max_per_set_descriptors", &self.max_per_set_descriptors)
                .field(
                    "max_memory_allocation_size",
                    &self.max_memory_allocation_size,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceVulkan11Properties<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>> for PhysicalDeviceVulkan11Properties<'_> {}

    impl Default for PhysicalDeviceVulkan11Properties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                device_uuid: [Default::default(); _],
                driver_uuid: [Default::default(); _],
                device_luid: [Default::default(); _],
                device_node_mask: Default::default(),
                device_luid_valid: Default::default(),
                subgroup_size: Default::default(),
                subgroup_supported_stages: Default::default(),
                subgroup_supported_operations: Default::default(),
                subgroup_quad_operations_in_all_stages: Default::default(),
                point_clipping_behavior: Default::default(),
                max_multiview_view_count: Default::default(),
                max_multiview_instance_index: Default::default(),
                protected_no_fault: Default::default(),
                max_per_set_descriptors: Default::default(),
                max_memory_allocation_size: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceVulkan11Properties<'a> {
        #[inline]
        pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE as usize]) -> Self {
            self.device_uuid = device_uuid;
            self
        }

        #[inline]
        pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE as usize]) -> Self {
            self.driver_uuid = driver_uuid;
            self
        }

        #[inline]
        pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE as usize]) -> Self {
            self.device_luid = device_luid;
            self
        }

        #[inline]
        pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
            self.device_node_mask = device_node_mask;
            self
        }

        #[inline]
        pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
            self.device_luid_valid = device_luid_valid.into();
            self
        }

        #[inline]
        pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
            self.subgroup_size = subgroup_size;
            self
        }

        #[inline]
        pub fn subgroup_supported_stages(
            mut self,
            subgroup_supported_stages: ShaderStageFlags,
        ) -> Self {
            self.subgroup_supported_stages = subgroup_supported_stages;
            self
        }

        #[inline]
        pub fn subgroup_supported_operations(
            mut self,
            subgroup_supported_operations: SubgroupFeatureFlags,
        ) -> Self {
            self.subgroup_supported_operations = subgroup_supported_operations;
            self
        }

        #[inline]
        pub fn subgroup_quad_operations_in_all_stages(
            mut self,
            subgroup_quad_operations_in_all_stages: bool,
        ) -> Self {
            self.subgroup_quad_operations_in_all_stages =
                subgroup_quad_operations_in_all_stages.into();
            self
        }

        #[inline]
        pub fn point_clipping_behavior(
            mut self,
            point_clipping_behavior: PointClippingBehavior,
        ) -> Self {
            self.point_clipping_behavior = point_clipping_behavior;
            self
        }

        #[inline]
        pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
            self.max_multiview_view_count = max_multiview_view_count;
            self
        }

        #[inline]
        pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
            self.max_multiview_instance_index = max_multiview_instance_index;
            self
        }

        #[inline]
        pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
            self.protected_no_fault = protected_no_fault.into();
            self
        }

        #[inline]
        pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
            self.max_per_set_descriptors = max_per_set_descriptors;
            self
        }

        #[inline]
        pub fn max_memory_allocation_size(
            mut self,
            max_memory_allocation_size: DeviceSize,
        ) -> Self {
            self.max_memory_allocation_size = max_memory_allocation_size;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Features.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceVulkan12Features<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub sampler_mirror_clamp_to_edge: Bool32,
        pub draw_indirect_count: Bool32,
        pub storage_buffer8_bit_access: Bool32,
        pub uniform_and_storage_buffer8_bit_access: Bool32,
        pub storage_push_constant8: Bool32,
        pub shader_buffer_int64_atomics: Bool32,
        pub shader_shared_int64_atomics: Bool32,
        pub shader_float16: Bool32,
        pub shader_int8: Bool32,
        pub descriptor_indexing: Bool32,
        pub shader_input_attachment_array_dynamic_indexing: Bool32,
        pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
        pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
        pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
        pub shader_sampled_image_array_non_uniform_indexing: Bool32,
        pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
        pub shader_storage_image_array_non_uniform_indexing: Bool32,
        pub shader_input_attachment_array_non_uniform_indexing: Bool32,
        pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
        pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
        pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
        pub descriptor_binding_sampled_image_update_after_bind: Bool32,
        pub descriptor_binding_storage_image_update_after_bind: Bool32,
        pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
        pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
        pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
        pub descriptor_binding_update_unused_while_pending: Bool32,
        pub descriptor_binding_partially_bound: Bool32,
        pub descriptor_binding_variable_descriptor_count: Bool32,
        pub runtime_descriptor_array: Bool32,
        pub sampler_filter_minmax: Bool32,
        pub scalar_block_layout: Bool32,
        pub imageless_framebuffer: Bool32,
        pub uniform_buffer_standard_layout: Bool32,
        pub shader_subgroup_extended_types: Bool32,
        pub separate_depth_stencil_layouts: Bool32,
        pub host_query_reset: Bool32,
        pub timeline_semaphore: Bool32,
        pub buffer_device_address: Bool32,
        pub buffer_device_address_capture_replay: Bool32,
        pub buffer_device_address_multi_device: Bool32,
        pub vulkan_memory_model: Bool32,
        pub vulkan_memory_model_device_scope: Bool32,
        pub vulkan_memory_model_availability_visibility_chains: Bool32,
        pub shader_output_viewport_index: Bool32,
        pub shader_output_layer: Bool32,
        pub subgroup_broadcast_dynamic_id: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceVulkan12Features<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceVulkan12Features")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "sampler_mirror_clamp_to_edge",
                    &self.sampler_mirror_clamp_to_edge,
                )
                .field("draw_indirect_count", &self.draw_indirect_count)
                .field(
                    "storage_buffer8_bit_access",
                    &self.storage_buffer8_bit_access,
                )
                .field(
                    "uniform_and_storage_buffer8_bit_access",
                    &self.uniform_and_storage_buffer8_bit_access,
                )
                .field("storage_push_constant8", &self.storage_push_constant8)
                .field(
                    "shader_buffer_int64_atomics",
                    &self.shader_buffer_int64_atomics,
                )
                .field(
                    "shader_shared_int64_atomics",
                    &self.shader_shared_int64_atomics,
                )
                .field("shader_float16", &self.shader_float16)
                .field("shader_int8", &self.shader_int8)
                .field("descriptor_indexing", &self.descriptor_indexing)
                .field(
                    "shader_input_attachment_array_dynamic_indexing",
                    &self.shader_input_attachment_array_dynamic_indexing,
                )
                .field(
                    "shader_uniform_texel_buffer_array_dynamic_indexing",
                    &self.shader_uniform_texel_buffer_array_dynamic_indexing,
                )
                .field(
                    "shader_storage_texel_buffer_array_dynamic_indexing",
                    &self.shader_storage_texel_buffer_array_dynamic_indexing,
                )
                .field(
                    "shader_uniform_buffer_array_non_uniform_indexing",
                    &self.shader_uniform_buffer_array_non_uniform_indexing,
                )
                .field(
                    "shader_sampled_image_array_non_uniform_indexing",
                    &self.shader_sampled_image_array_non_uniform_indexing,
                )
                .field(
                    "shader_storage_buffer_array_non_uniform_indexing",
                    &self.shader_storage_buffer_array_non_uniform_indexing,
                )
                .field(
                    "shader_storage_image_array_non_uniform_indexing",
                    &self.shader_storage_image_array_non_uniform_indexing,
                )
                .field(
                    "shader_input_attachment_array_non_uniform_indexing",
                    &self.shader_input_attachment_array_non_uniform_indexing,
                )
                .field(
                    "shader_uniform_texel_buffer_array_non_uniform_indexing",
                    &self.shader_uniform_texel_buffer_array_non_uniform_indexing,
                )
                .field(
                    "shader_storage_texel_buffer_array_non_uniform_indexing",
                    &self.shader_storage_texel_buffer_array_non_uniform_indexing,
                )
                .field(
                    "descriptor_binding_uniform_buffer_update_after_bind",
                    &self.descriptor_binding_uniform_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_sampled_image_update_after_bind",
                    &self.descriptor_binding_sampled_image_update_after_bind,
                )
                .field(
                    "descriptor_binding_storage_image_update_after_bind",
                    &self.descriptor_binding_storage_image_update_after_bind,
                )
                .field(
                    "descriptor_binding_storage_buffer_update_after_bind",
                    &self.descriptor_binding_storage_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_uniform_texel_buffer_update_after_bind",
                    &self.descriptor_binding_uniform_texel_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_storage_texel_buffer_update_after_bind",
                    &self.descriptor_binding_storage_texel_buffer_update_after_bind,
                )
                .field(
                    "descriptor_binding_update_unused_while_pending",
                    &self.descriptor_binding_update_unused_while_pending,
                )
                .field(
                    "descriptor_binding_partially_bound",
                    &self.descriptor_binding_partially_bound,
                )
                .field(
                    "descriptor_binding_variable_descriptor_count",
                    &self.descriptor_binding_variable_descriptor_count,
                )
                .field("runtime_descriptor_array", &self.runtime_descriptor_array)
                .field("sampler_filter_minmax", &self.sampler_filter_minmax)
                .field("scalar_block_layout", &self.scalar_block_layout)
                .field("imageless_framebuffer", &self.imageless_framebuffer)
                .field(
                    "uniform_buffer_standard_layout",
                    &self.uniform_buffer_standard_layout,
                )
                .field(
                    "shader_subgroup_extended_types",
                    &self.shader_subgroup_extended_types,
                )
                .field(
                    "separate_depth_stencil_layouts",
                    &self.separate_depth_stencil_layouts,
                )
                .field("host_query_reset", &self.host_query_reset)
                .field("timeline_semaphore", &self.timeline_semaphore)
                .field("buffer_device_address", &self.buffer_device_address)
                .field(
                    "buffer_device_address_capture_replay",
                    &self.buffer_device_address_capture_replay,
                )
                .field(
                    "buffer_device_address_multi_device",
                    &self.buffer_device_address_multi_device,
                )
                .field("vulkan_memory_model", &self.vulkan_memory_model)
                .field(
                    "vulkan_memory_model_device_scope",
                    &self.vulkan_memory_model_device_scope,
                )
                .field(
                    "vulkan_memory_model_availability_visibility_chains",
                    &self.vulkan_memory_model_availability_visibility_chains,
                )
                .field(
                    "shader_output_viewport_index",
                    &self.shader_output_viewport_index,
                )
                .field("shader_output_layer", &self.shader_output_layer)
                .field(
                    "subgroup_broadcast_dynamic_id",
                    &self.subgroup_broadcast_dynamic_id,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceVulkan12Features<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceVulkan12Features<'_> {}
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceVulkan12Features<'_> {}

    impl Default for PhysicalDeviceVulkan12Features<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                sampler_mirror_clamp_to_edge: Default::default(),
                draw_indirect_count: Default::default(),
                storage_buffer8_bit_access: Default::default(),
                uniform_and_storage_buffer8_bit_access: Default::default(),
                storage_push_constant8: Default::default(),
                shader_buffer_int64_atomics: Default::default(),
                shader_shared_int64_atomics: Default::default(),
                shader_float16: Default::default(),
                shader_int8: Default::default(),
                descriptor_indexing: Default::default(),
                shader_input_attachment_array_dynamic_indexing: Default::default(),
                shader_uniform_texel_buffer_array_dynamic_indexing: Default::default(),
                shader_storage_texel_buffer_array_dynamic_indexing: Default::default(),
                shader_uniform_buffer_array_non_uniform_indexing: Default::default(),
                shader_sampled_image_array_non_uniform_indexing: Default::default(),
                shader_storage_buffer_array_non_uniform_indexing: Default::default(),
                shader_storage_image_array_non_uniform_indexing: Default::default(),
                shader_input_attachment_array_non_uniform_indexing: Default::default(),
                shader_uniform_texel_buffer_array_non_uniform_indexing: Default::default(),
                shader_storage_texel_buffer_array_non_uniform_indexing: Default::default(),
                descriptor_binding_uniform_buffer_update_after_bind: Default::default(),
                descriptor_binding_sampled_image_update_after_bind: Default::default(),
                descriptor_binding_storage_image_update_after_bind: Default::default(),
                descriptor_binding_storage_buffer_update_after_bind: Default::default(),
                descriptor_binding_uniform_texel_buffer_update_after_bind: Default::default(),
                descriptor_binding_storage_texel_buffer_update_after_bind: Default::default(),
                descriptor_binding_update_unused_while_pending: Default::default(),
                descriptor_binding_partially_bound: Default::default(),
                descriptor_binding_variable_descriptor_count: Default::default(),
                runtime_descriptor_array: Default::default(),
                sampler_filter_minmax: Default::default(),
                scalar_block_layout: Default::default(),
                imageless_framebuffer: Default::default(),
                uniform_buffer_standard_layout: Default::default(),
                shader_subgroup_extended_types: Default::default(),
                separate_depth_stencil_layouts: Default::default(),
                host_query_reset: Default::default(),
                timeline_semaphore: Default::default(),
                buffer_device_address: Default::default(),
                buffer_device_address_capture_replay: Default::default(),
                buffer_device_address_multi_device: Default::default(),
                vulkan_memory_model: Default::default(),
                vulkan_memory_model_device_scope: Default::default(),
                vulkan_memory_model_availability_visibility_chains: Default::default(),
                shader_output_viewport_index: Default::default(),
                shader_output_layer: Default::default(),
                subgroup_broadcast_dynamic_id: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceVulkan12Features<'a> {
        #[inline]
        pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self {
            self.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into();
            self
        }

        #[inline]
        pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self {
            self.draw_indirect_count = draw_indirect_count.into();
            self
        }

        #[inline]
        pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
            self.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
            self
        }

        #[inline]
        pub fn uniform_and_storage_buffer8_bit_access(
            mut self,
            uniform_and_storage_buffer8_bit_access: bool,
        ) -> Self {
            self.uniform_and_storage_buffer8_bit_access =
                uniform_and_storage_buffer8_bit_access.into();
            self
        }

        #[inline]
        pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
            self.storage_push_constant8 = storage_push_constant8.into();
            self
        }

        #[inline]
        pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
            self.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
            self
        }

        #[inline]
        pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
            self.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
            self
        }

        #[inline]
        pub fn shader_float16(mut self, shader_float16: bool) -> Self {
            self.shader_float16 = shader_float16.into();
            self
        }

        #[inline]
        pub fn shader_int8(mut self, shader_int8: bool) -> Self {
            self.shader_int8 = shader_int8.into();
            self
        }

        #[inline]
        pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self {
            self.descriptor_indexing = descriptor_indexing.into();
            self
        }

        #[inline]
        pub fn shader_input_attachment_array_dynamic_indexing(
            mut self,
            shader_input_attachment_array_dynamic_indexing: bool,
        ) -> Self {
            self.shader_input_attachment_array_dynamic_indexing =
                shader_input_attachment_array_dynamic_indexing.into();
            self
        }

        #[inline]
        pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
            mut self,
            shader_uniform_texel_buffer_array_dynamic_indexing: bool,
        ) -> Self {
            self.shader_uniform_texel_buffer_array_dynamic_indexing =
                shader_uniform_texel_buffer_array_dynamic_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_texel_buffer_array_dynamic_indexing(
            mut self,
            shader_storage_texel_buffer_array_dynamic_indexing: bool,
        ) -> Self {
            self.shader_storage_texel_buffer_array_dynamic_indexing =
                shader_storage_texel_buffer_array_dynamic_indexing.into();
            self
        }

        #[inline]
        pub fn shader_uniform_buffer_array_non_uniform_indexing(
            mut self,
            shader_uniform_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_uniform_buffer_array_non_uniform_indexing =
                shader_uniform_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_sampled_image_array_non_uniform_indexing(
            mut self,
            shader_sampled_image_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_sampled_image_array_non_uniform_indexing =
                shader_sampled_image_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_buffer_array_non_uniform_indexing(
            mut self,
            shader_storage_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_storage_buffer_array_non_uniform_indexing =
                shader_storage_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_image_array_non_uniform_indexing(
            mut self,
            shader_storage_image_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_storage_image_array_non_uniform_indexing =
                shader_storage_image_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_input_attachment_array_non_uniform_indexing(
            mut self,
            shader_input_attachment_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_input_attachment_array_non_uniform_indexing =
                shader_input_attachment_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
            mut self,
            shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_uniform_texel_buffer_array_non_uniform_indexing =
                shader_uniform_texel_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
            mut self,
            shader_storage_texel_buffer_array_non_uniform_indexing: bool,
        ) -> Self {
            self.shader_storage_texel_buffer_array_non_uniform_indexing =
                shader_storage_texel_buffer_array_non_uniform_indexing.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_uniform_buffer_update_after_bind(
            mut self,
            descriptor_binding_uniform_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_uniform_buffer_update_after_bind =
                descriptor_binding_uniform_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_sampled_image_update_after_bind(
            mut self,
            descriptor_binding_sampled_image_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_sampled_image_update_after_bind =
                descriptor_binding_sampled_image_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_storage_image_update_after_bind(
            mut self,
            descriptor_binding_storage_image_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_storage_image_update_after_bind =
                descriptor_binding_storage_image_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_storage_buffer_update_after_bind(
            mut self,
            descriptor_binding_storage_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_storage_buffer_update_after_bind =
                descriptor_binding_storage_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
            mut self,
            descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_uniform_texel_buffer_update_after_bind =
                descriptor_binding_uniform_texel_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
            mut self,
            descriptor_binding_storage_texel_buffer_update_after_bind: bool,
        ) -> Self {
            self.descriptor_binding_storage_texel_buffer_update_after_bind =
                descriptor_binding_storage_texel_buffer_update_after_bind.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_update_unused_while_pending(
            mut self,
            descriptor_binding_update_unused_while_pending: bool,
        ) -> Self {
            self.descriptor_binding_update_unused_while_pending =
                descriptor_binding_update_unused_while_pending.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_partially_bound(
            mut self,
            descriptor_binding_partially_bound: bool,
        ) -> Self {
            self.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
            self
        }

        #[inline]
        pub fn descriptor_binding_variable_descriptor_count(
            mut self,
            descriptor_binding_variable_descriptor_count: bool,
        ) -> Self {
            self.descriptor_binding_variable_descriptor_count =
                descriptor_binding_variable_descriptor_count.into();
            self
        }

        #[inline]
        pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
            self.runtime_descriptor_array = runtime_descriptor_array.into();
            self
        }

        #[inline]
        pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self {
            self.sampler_filter_minmax = sampler_filter_minmax.into();
            self
        }

        #[inline]
        pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
            self.scalar_block_layout = scalar_block_layout.into();
            self
        }

        #[inline]
        pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
            self.imageless_framebuffer = imageless_framebuffer.into();
            self
        }

        #[inline]
        pub fn uniform_buffer_standard_layout(
            mut self,
            uniform_buffer_standard_layout: bool,
        ) -> Self {
            self.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
            self
        }

        #[inline]
        pub fn shader_subgroup_extended_types(
            mut self,
            shader_subgroup_extended_types: bool,
        ) -> Self {
            self.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
            self
        }

        #[inline]
        pub fn separate_depth_stencil_layouts(
            mut self,
            separate_depth_stencil_layouts: bool,
        ) -> Self {
            self.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
            self
        }

        #[inline]
        pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
            self.host_query_reset = host_query_reset.into();
            self
        }

        #[inline]
        pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
            self.timeline_semaphore = timeline_semaphore.into();
            self
        }

        #[inline]
        pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
            self.buffer_device_address = buffer_device_address.into();
            self
        }

        #[inline]
        pub fn buffer_device_address_capture_replay(
            mut self,
            buffer_device_address_capture_replay: bool,
        ) -> Self {
            self.buffer_device_address_capture_replay = buffer_device_address_capture_replay.into();
            self
        }

        #[inline]
        pub fn buffer_device_address_multi_device(
            mut self,
            buffer_device_address_multi_device: bool,
        ) -> Self {
            self.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
            self
        }

        #[inline]
        pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
            self.vulkan_memory_model = vulkan_memory_model.into();
            self
        }

        #[inline]
        pub fn vulkan_memory_model_device_scope(
            mut self,
            vulkan_memory_model_device_scope: bool,
        ) -> Self {
            self.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
            self
        }

        #[inline]
        pub fn vulkan_memory_model_availability_visibility_chains(
            mut self,
            vulkan_memory_model_availability_visibility_chains: bool,
        ) -> Self {
            self.vulkan_memory_model_availability_visibility_chains =
                vulkan_memory_model_availability_visibility_chains.into();
            self
        }

        #[inline]
        pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self {
            self.shader_output_viewport_index = shader_output_viewport_index.into();
            self
        }

        #[inline]
        pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self {
            self.shader_output_layer = shader_output_layer.into();
            self
        }

        #[inline]
        pub fn subgroup_broadcast_dynamic_id(
            mut self,
            subgroup_broadcast_dynamic_id: bool,
        ) -> Self {
            self.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Properties.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceVulkan12Properties<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub driver_id: DriverId,
        pub driver_name: ArrayCStr<{ MAX_DRIVER_NAME_SIZE as usize }>,
        pub driver_info: ArrayCStr<{ MAX_DRIVER_INFO_SIZE as usize }>,
        pub conformance_version: ConformanceVersion,
        pub denorm_behavior_independence: ShaderFloatControlsIndependence,
        pub rounding_mode_independence: ShaderFloatControlsIndependence,
        pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
        pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
        pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
        pub shader_denorm_preserve_float16: Bool32,
        pub shader_denorm_preserve_float32: Bool32,
        pub shader_denorm_preserve_float64: Bool32,
        pub shader_denorm_flush_to_zero_float16: Bool32,
        pub shader_denorm_flush_to_zero_float32: Bool32,
        pub shader_denorm_flush_to_zero_float64: Bool32,
        pub shader_rounding_mode_rte_float16: Bool32,
        pub shader_rounding_mode_rte_float32: Bool32,
        pub shader_rounding_mode_rte_float64: Bool32,
        pub shader_rounding_mode_rtz_float16: Bool32,
        pub shader_rounding_mode_rtz_float32: Bool32,
        pub shader_rounding_mode_rtz_float64: Bool32,
        pub max_update_after_bind_descriptors_in_all_pools: u32,
        pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
        pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
        pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
        pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
        pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
        pub robust_buffer_access_update_after_bind: Bool32,
        pub quad_divergent_implicit_lod: Bool32,
        pub max_per_stage_descriptor_update_after_bind_samplers: u32,
        pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
        pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
        pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
        pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
        pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
        pub max_per_stage_update_after_bind_resources: u32,
        pub max_descriptor_set_update_after_bind_samplers: u32,
        pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
        pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
        pub max_descriptor_set_update_after_bind_storage_buffers: u32,
        pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
        pub max_descriptor_set_update_after_bind_sampled_images: u32,
        pub max_descriptor_set_update_after_bind_storage_images: u32,
        pub max_descriptor_set_update_after_bind_input_attachments: u32,
        pub supported_depth_resolve_modes: ResolveModeFlags,
        pub supported_stencil_resolve_modes: ResolveModeFlags,
        pub independent_resolve_none: Bool32,
        pub independent_resolve: Bool32,
        pub filter_minmax_single_component_formats: Bool32,
        pub filter_minmax_image_component_mapping: Bool32,
        pub max_timeline_semaphore_value_difference: u64,
        pub framebuffer_integer_color_sample_counts: SampleCountFlags,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceVulkan12Properties<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceVulkan12Properties")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("driver_id", &self.driver_id)
                .field("driver_name", &self.driver_name)
                .field("driver_info", &self.driver_info)
                .field("conformance_version", &self.conformance_version)
                .field(
                    "denorm_behavior_independence",
                    &self.denorm_behavior_independence,
                )
                .field(
                    "rounding_mode_independence",
                    &self.rounding_mode_independence,
                )
                .field(
                    "shader_signed_zero_inf_nan_preserve_float16",
                    &self.shader_signed_zero_inf_nan_preserve_float16,
                )
                .field(
                    "shader_signed_zero_inf_nan_preserve_float32",
                    &self.shader_signed_zero_inf_nan_preserve_float32,
                )
                .field(
                    "shader_signed_zero_inf_nan_preserve_float64",
                    &self.shader_signed_zero_inf_nan_preserve_float64,
                )
                .field(
                    "shader_denorm_preserve_float16",
                    &self.shader_denorm_preserve_float16,
                )
                .field(
                    "shader_denorm_preserve_float32",
                    &self.shader_denorm_preserve_float32,
                )
                .field(
                    "shader_denorm_preserve_float64",
                    &self.shader_denorm_preserve_float64,
                )
                .field(
                    "shader_denorm_flush_to_zero_float16",
                    &self.shader_denorm_flush_to_zero_float16,
                )
                .field(
                    "shader_denorm_flush_to_zero_float32",
                    &self.shader_denorm_flush_to_zero_float32,
                )
                .field(
                    "shader_denorm_flush_to_zero_float64",
                    &self.shader_denorm_flush_to_zero_float64,
                )
                .field(
                    "shader_rounding_mode_rte_float16",
                    &self.shader_rounding_mode_rte_float16,
                )
                .field(
                    "shader_rounding_mode_rte_float32",
                    &self.shader_rounding_mode_rte_float32,
                )
                .field(
                    "shader_rounding_mode_rte_float64",
                    &self.shader_rounding_mode_rte_float64,
                )
                .field(
                    "shader_rounding_mode_rtz_float16",
                    &self.shader_rounding_mode_rtz_float16,
                )
                .field(
                    "shader_rounding_mode_rtz_float32",
                    &self.shader_rounding_mode_rtz_float32,
                )
                .field(
                    "shader_rounding_mode_rtz_float64",
                    &self.shader_rounding_mode_rtz_float64,
                )
                .field(
                    "max_update_after_bind_descriptors_in_all_pools",
                    &self.max_update_after_bind_descriptors_in_all_pools,
                )
                .field(
                    "shader_uniform_buffer_array_non_uniform_indexing_native",
                    &self.shader_uniform_buffer_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_sampled_image_array_non_uniform_indexing_native",
                    &self.shader_sampled_image_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_storage_buffer_array_non_uniform_indexing_native",
                    &self.shader_storage_buffer_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_storage_image_array_non_uniform_indexing_native",
                    &self.shader_storage_image_array_non_uniform_indexing_native,
                )
                .field(
                    "shader_input_attachment_array_non_uniform_indexing_native",
                    &self.shader_input_attachment_array_non_uniform_indexing_native,
                )
                .field(
                    "robust_buffer_access_update_after_bind",
                    &self.robust_buffer_access_update_after_bind,
                )
                .field(
                    "quad_divergent_implicit_lod",
                    &self.quad_divergent_implicit_lod,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_samplers",
                    &self.max_per_stage_descriptor_update_after_bind_samplers,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_uniform_buffers",
                    &self.max_per_stage_descriptor_update_after_bind_uniform_buffers,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_storage_buffers",
                    &self.max_per_stage_descriptor_update_after_bind_storage_buffers,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_sampled_images",
                    &self.max_per_stage_descriptor_update_after_bind_sampled_images,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_storage_images",
                    &self.max_per_stage_descriptor_update_after_bind_storage_images,
                )
                .field(
                    "max_per_stage_descriptor_update_after_bind_input_attachments",
                    &self.max_per_stage_descriptor_update_after_bind_input_attachments,
                )
                .field(
                    "max_per_stage_update_after_bind_resources",
                    &self.max_per_stage_update_after_bind_resources,
                )
                .field(
                    "max_descriptor_set_update_after_bind_samplers",
                    &self.max_descriptor_set_update_after_bind_samplers,
                )
                .field(
                    "max_descriptor_set_update_after_bind_uniform_buffers",
                    &self.max_descriptor_set_update_after_bind_uniform_buffers,
                )
                .field(
                    "max_descriptor_set_update_after_bind_uniform_buffers_dynamic",
                    &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic,
                )
                .field(
                    "max_descriptor_set_update_after_bind_storage_buffers",
                    &self.max_descriptor_set_update_after_bind_storage_buffers,
                )
                .field(
                    "max_descriptor_set_update_after_bind_storage_buffers_dynamic",
                    &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic,
                )
                .field(
                    "max_descriptor_set_update_after_bind_sampled_images",
                    &self.max_descriptor_set_update_after_bind_sampled_images,
                )
                .field(
                    "max_descriptor_set_update_after_bind_storage_images",
                    &self.max_descriptor_set_update_after_bind_storage_images,
                )
                .field(
                    "max_descriptor_set_update_after_bind_input_attachments",
                    &self.max_descriptor_set_update_after_bind_input_attachments,
                )
                .field(
                    "supported_depth_resolve_modes",
                    &self.supported_depth_resolve_modes,
                )
                .field(
                    "supported_stencil_resolve_modes",
                    &self.supported_stencil_resolve_modes,
                )
                .field("independent_resolve_none", &self.independent_resolve_none)
                .field("independent_resolve", &self.independent_resolve)
                .field(
                    "filter_minmax_single_component_formats",
                    &self.filter_minmax_single_component_formats,
                )
                .field(
                    "filter_minmax_image_component_mapping",
                    &self.filter_minmax_image_component_mapping,
                )
                .field(
                    "max_timeline_semaphore_value_difference",
                    &self.max_timeline_semaphore_value_difference,
                )
                .field(
                    "framebuffer_integer_color_sample_counts",
                    &self.framebuffer_integer_color_sample_counts,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceVulkan12Properties<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>> for PhysicalDeviceVulkan12Properties<'_> {}

    impl Default for PhysicalDeviceVulkan12Properties<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                driver_id: Default::default(),
                driver_name: Default::default(),
                driver_info: Default::default(),
                conformance_version: Default::default(),
                denorm_behavior_independence: Default::default(),
                rounding_mode_independence: Default::default(),
                shader_signed_zero_inf_nan_preserve_float16: Default::default(),
                shader_signed_zero_inf_nan_preserve_float32: Default::default(),
                shader_signed_zero_inf_nan_preserve_float64: Default::default(),
                shader_denorm_preserve_float16: Default::default(),
                shader_denorm_preserve_float32: Default::default(),
                shader_denorm_preserve_float64: Default::default(),
                shader_denorm_flush_to_zero_float16: Default::default(),
                shader_denorm_flush_to_zero_float32: Default::default(),
                shader_denorm_flush_to_zero_float64: Default::default(),
                shader_rounding_mode_rte_float16: Default::default(),
                shader_rounding_mode_rte_float32: Default::default(),
                shader_rounding_mode_rte_float64: Default::default(),
                shader_rounding_mode_rtz_float16: Default::default(),
                shader_rounding_mode_rtz_float32: Default::default(),
                shader_rounding_mode_rtz_float64: Default::default(),
                max_update_after_bind_descriptors_in_all_pools: Default::default(),
                shader_uniform_buffer_array_non_uniform_indexing_native: Default::default(),
                shader_sampled_image_array_non_uniform_indexing_native: Default::default(),
                shader_storage_buffer_array_non_uniform_indexing_native: Default::default(),
                shader_storage_image_array_non_uniform_indexing_native: Default::default(),
                shader_input_attachment_array_non_uniform_indexing_native: Default::default(),
                robust_buffer_access_update_after_bind: Default::default(),
                quad_divergent_implicit_lod: Default::default(),
                max_per_stage_descriptor_update_after_bind_samplers: Default::default(),
                max_per_stage_descriptor_update_after_bind_uniform_buffers: Default::default(),
                max_per_stage_descriptor_update_after_bind_storage_buffers: Default::default(),
                max_per_stage_descriptor_update_after_bind_sampled_images: Default::default(),
                max_per_stage_descriptor_update_after_bind_storage_images: Default::default(),
                max_per_stage_descriptor_update_after_bind_input_attachments: Default::default(),
                max_per_stage_update_after_bind_resources: Default::default(),
                max_descriptor_set_update_after_bind_samplers: Default::default(),
                max_descriptor_set_update_after_bind_uniform_buffers: Default::default(),
                max_descriptor_set_update_after_bind_uniform_buffers_dynamic: Default::default(),
                max_descriptor_set_update_after_bind_storage_buffers: Default::default(),
                max_descriptor_set_update_after_bind_storage_buffers_dynamic: Default::default(),
                max_descriptor_set_update_after_bind_sampled_images: Default::default(),
                max_descriptor_set_update_after_bind_storage_images: Default::default(),
                max_descriptor_set_update_after_bind_input_attachments: Default::default(),
                supported_depth_resolve_modes: Default::default(),
                supported_stencil_resolve_modes: Default::default(),
                independent_resolve_none: Default::default(),
                independent_resolve: Default::default(),
                filter_minmax_single_component_formats: Default::default(),
                filter_minmax_image_component_mapping: Default::default(),
                max_timeline_semaphore_value_difference: Default::default(),
                framebuffer_integer_color_sample_counts: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceVulkan12Properties<'a> {
        #[inline]
        pub fn driver_id(mut self, driver_id: DriverId) -> Self {
            self.driver_id = driver_id;
            self
        }

        #[inline]
        pub fn driver_name(
            mut self,
            driver_name: &CStr,
        ) -> core::result::Result<Self, CStrTooLargeForStaticArray> {
            self.driver_name.write_c_str(driver_name)?;
            Ok(self)
        }

        #[inline]
        pub fn driver_info(
            mut self,
            driver_info: &CStr,
        ) -> core::result::Result<Self, CStrTooLargeForStaticArray> {
            self.driver_info.write_c_str(driver_info)?;
            Ok(self)
        }

        #[inline]
        pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
            self.conformance_version = conformance_version;
            self
        }

        #[inline]
        pub fn denorm_behavior_independence(
            mut self,
            denorm_behavior_independence: ShaderFloatControlsIndependence,
        ) -> Self {
            self.denorm_behavior_independence = denorm_behavior_independence;
            self
        }

        #[inline]
        pub fn rounding_mode_independence(
            mut self,
            rounding_mode_independence: ShaderFloatControlsIndependence,
        ) -> Self {
            self.rounding_mode_independence = rounding_mode_independence;
            self
        }

        #[inline]
        pub fn shader_signed_zero_inf_nan_preserve_float16(
            mut self,
            shader_signed_zero_inf_nan_preserve_float16: bool,
        ) -> Self {
            self.shader_signed_zero_inf_nan_preserve_float16 =
                shader_signed_zero_inf_nan_preserve_float16.into();
            self
        }

        #[inline]
        pub fn shader_signed_zero_inf_nan_preserve_float32(
            mut self,
            shader_signed_zero_inf_nan_preserve_float32: bool,
        ) -> Self {
            self.shader_signed_zero_inf_nan_preserve_float32 =
                shader_signed_zero_inf_nan_preserve_float32.into();
            self
        }

        #[inline]
        pub fn shader_signed_zero_inf_nan_preserve_float64(
            mut self,
            shader_signed_zero_inf_nan_preserve_float64: bool,
        ) -> Self {
            self.shader_signed_zero_inf_nan_preserve_float64 =
                shader_signed_zero_inf_nan_preserve_float64.into();
            self
        }

        #[inline]
        pub fn shader_denorm_preserve_float16(
            mut self,
            shader_denorm_preserve_float16: bool,
        ) -> Self {
            self.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
            self
        }

        #[inline]
        pub fn shader_denorm_preserve_float32(
            mut self,
            shader_denorm_preserve_float32: bool,
        ) -> Self {
            self.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
            self
        }

        #[inline]
        pub fn shader_denorm_preserve_float64(
            mut self,
            shader_denorm_preserve_float64: bool,
        ) -> Self {
            self.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
            self
        }

        #[inline]
        pub fn shader_denorm_flush_to_zero_float16(
            mut self,
            shader_denorm_flush_to_zero_float16: bool,
        ) -> Self {
            self.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
            self
        }

        #[inline]
        pub fn shader_denorm_flush_to_zero_float32(
            mut self,
            shader_denorm_flush_to_zero_float32: bool,
        ) -> Self {
            self.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
            self
        }

        #[inline]
        pub fn shader_denorm_flush_to_zero_float64(
            mut self,
            shader_denorm_flush_to_zero_float64: bool,
        ) -> Self {
            self.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rte_float16(
            mut self,
            shader_rounding_mode_rte_float16: bool,
        ) -> Self {
            self.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rte_float32(
            mut self,
            shader_rounding_mode_rte_float32: bool,
        ) -> Self {
            self.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rte_float64(
            mut self,
            shader_rounding_mode_rte_float64: bool,
        ) -> Self {
            self.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rtz_float16(
            mut self,
            shader_rounding_mode_rtz_float16: bool,
        ) -> Self {
            self.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rtz_float32(
            mut self,
            shader_rounding_mode_rtz_float32: bool,
        ) -> Self {
            self.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
            self
        }

        #[inline]
        pub fn shader_rounding_mode_rtz_float64(
            mut self,
            shader_rounding_mode_rtz_float64: bool,
        ) -> Self {
            self.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
            self
        }

        #[inline]
        pub fn max_update_after_bind_descriptors_in_all_pools(
            mut self,
            max_update_after_bind_descriptors_in_all_pools: u32,
        ) -> Self {
            self.max_update_after_bind_descriptors_in_all_pools =
                max_update_after_bind_descriptors_in_all_pools;
            self
        }

        #[inline]
        pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
            mut self,
            shader_uniform_buffer_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_uniform_buffer_array_non_uniform_indexing_native =
                shader_uniform_buffer_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_sampled_image_array_non_uniform_indexing_native(
            mut self,
            shader_sampled_image_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_sampled_image_array_non_uniform_indexing_native =
                shader_sampled_image_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_storage_buffer_array_non_uniform_indexing_native(
            mut self,
            shader_storage_buffer_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_storage_buffer_array_non_uniform_indexing_native =
                shader_storage_buffer_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_storage_image_array_non_uniform_indexing_native(
            mut self,
            shader_storage_image_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_storage_image_array_non_uniform_indexing_native =
                shader_storage_image_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn shader_input_attachment_array_non_uniform_indexing_native(
            mut self,
            shader_input_attachment_array_non_uniform_indexing_native: bool,
        ) -> Self {
            self.shader_input_attachment_array_non_uniform_indexing_native =
                shader_input_attachment_array_non_uniform_indexing_native.into();
            self
        }

        #[inline]
        pub fn robust_buffer_access_update_after_bind(
            mut self,
            robust_buffer_access_update_after_bind: bool,
        ) -> Self {
            self.robust_buffer_access_update_after_bind =
                robust_buffer_access_update_after_bind.into();
            self
        }

        #[inline]
        pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
            self.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_samplers(
            mut self,
            max_per_stage_descriptor_update_after_bind_samplers: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_samplers =
                max_per_stage_descriptor_update_after_bind_samplers;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
            mut self,
            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_uniform_buffers =
                max_per_stage_descriptor_update_after_bind_uniform_buffers;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
            mut self,
            max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_storage_buffers =
                max_per_stage_descriptor_update_after_bind_storage_buffers;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
            mut self,
            max_per_stage_descriptor_update_after_bind_sampled_images: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_sampled_images =
                max_per_stage_descriptor_update_after_bind_sampled_images;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_storage_images(
            mut self,
            max_per_stage_descriptor_update_after_bind_storage_images: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_storage_images =
                max_per_stage_descriptor_update_after_bind_storage_images;
            self
        }

        #[inline]
        pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
            mut self,
            max_per_stage_descriptor_update_after_bind_input_attachments: u32,
        ) -> Self {
            self.max_per_stage_descriptor_update_after_bind_input_attachments =
                max_per_stage_descriptor_update_after_bind_input_attachments;
            self
        }

        #[inline]
        pub fn max_per_stage_update_after_bind_resources(
            mut self,
            max_per_stage_update_after_bind_resources: u32,
        ) -> Self {
            self.max_per_stage_update_after_bind_resources =
                max_per_stage_update_after_bind_resources;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_samplers(
            mut self,
            max_descriptor_set_update_after_bind_samplers: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_samplers =
                max_descriptor_set_update_after_bind_samplers;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_uniform_buffers(
            mut self,
            max_descriptor_set_update_after_bind_uniform_buffers: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_uniform_buffers =
                max_descriptor_set_update_after_bind_uniform_buffers;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
            mut self,
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
                max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_storage_buffers(
            mut self,
            max_descriptor_set_update_after_bind_storage_buffers: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_storage_buffers =
                max_descriptor_set_update_after_bind_storage_buffers;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
            mut self,
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_storage_buffers_dynamic =
                max_descriptor_set_update_after_bind_storage_buffers_dynamic;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_sampled_images(
            mut self,
            max_descriptor_set_update_after_bind_sampled_images: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_sampled_images =
                max_descriptor_set_update_after_bind_sampled_images;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_storage_images(
            mut self,
            max_descriptor_set_update_after_bind_storage_images: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_storage_images =
                max_descriptor_set_update_after_bind_storage_images;
            self
        }

        #[inline]
        pub fn max_descriptor_set_update_after_bind_input_attachments(
            mut self,
            max_descriptor_set_update_after_bind_input_attachments: u32,
        ) -> Self {
            self.max_descriptor_set_update_after_bind_input_attachments =
                max_descriptor_set_update_after_bind_input_attachments;
            self
        }

        #[inline]
        pub fn supported_depth_resolve_modes(
            mut self,
            supported_depth_resolve_modes: ResolveModeFlags,
        ) -> Self {
            self.supported_depth_resolve_modes = supported_depth_resolve_modes;
            self
        }

        #[inline]
        pub fn supported_stencil_resolve_modes(
            mut self,
            supported_stencil_resolve_modes: ResolveModeFlags,
        ) -> Self {
            self.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
            self
        }

        #[inline]
        pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
            self.independent_resolve_none = independent_resolve_none.into();
            self
        }

        #[inline]
        pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
            self.independent_resolve = independent_resolve.into();
            self
        }

        #[inline]
        pub fn filter_minmax_single_component_formats(
            mut self,
            filter_minmax_single_component_formats: bool,
        ) -> Self {
            self.filter_minmax_single_component_formats =
                filter_minmax_single_component_formats.into();
            self
        }

        #[inline]
        pub fn filter_minmax_image_component_mapping(
            mut self,
            filter_minmax_image_component_mapping: bool,
        ) -> Self {
            self.filter_minmax_image_component_mapping =
                filter_minmax_image_component_mapping.into();
            self
        }

        #[inline]
        pub fn max_timeline_semaphore_value_difference(
            mut self,
            max_timeline_semaphore_value_difference: u64,
        ) -> Self {
            self.max_timeline_semaphore_value_difference = max_timeline_semaphore_value_difference;
            self
        }

        #[inline]
        pub fn framebuffer_integer_color_sample_counts(
            mut self,
            framebuffer_integer_color_sample_counts: SampleCountFlags,
        ) -> Self {
            self.framebuffer_integer_color_sample_counts = framebuffer_integer_color_sample_counts;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreType.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SemaphoreType(i32);

    impl SemaphoreType {
        #[inline]
        pub const fn from_raw(x: i32) -> Self {
            Self(x)
        }
        #[inline]
        pub const fn as_raw(self) -> i32 {
            self.0
        }

        pub const BINARY: Self = Self(0);
        pub const TIMELINE: Self = Self(1);

        // VK_KHR_timeline_semaphore
        pub const BINARY_KHR: Self = Self::BINARY;
        pub const TIMELINE_KHR: Self = Self::TIMELINE;
    }

    impl fmt::Debug for SemaphoreType {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::BINARY => Some("BINARY"),
                Self::TIMELINE => Some("TIMELINE"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerReductionMode.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SamplerReductionMode(i32);

    impl SamplerReductionMode {
        #[inline]
        pub const fn from_raw(x: i32) -> Self {
            Self(x)
        }
        #[inline]
        pub const fn as_raw(self) -> i32 {
            self.0
        }

        pub const WEIGHTED_AVERAGE: Self = Self(0);
        pub const MIN: Self = Self(1);
        pub const MAX: Self = Self(2);

        // VK_EXT_sampler_filter_minmax
        pub const WEIGHTED_AVERAGE_EXT: Self = Self::WEIGHTED_AVERAGE;
        pub const MIN_EXT: Self = Self::MIN;
        pub const MAX_EXT: Self = Self::MAX;

        // VK_QCOM_filter_cubic_clamp
        pub const WEIGHTED_AVERAGE_RANGECLAMP_QCOM: Self = Self(1000521000);
    }

    impl fmt::Debug for SamplerReductionMode {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"),
                Self::MIN => Some("MIN"),
                Self::MAX => Some("MAX"),
                Self::WEIGHTED_AVERAGE_RANGECLAMP_QCOM => Some("WEIGHTED_AVERAGE_RANGECLAMP_QCOM"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDriverId.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct DriverId(i32);

    impl DriverId {
        #[inline]
        pub const fn from_raw(x: i32) -> Self {
            Self(x)
        }
        #[inline]
        pub const fn as_raw(self) -> i32 {
            self.0
        }

        /// Advanced Micro Devices, Inc.
        pub const AMD_PROPRIETARY: Self = Self(1);
        /// Advanced Micro Devices, Inc.
        pub const AMD_OPEN_SOURCE: Self = Self(2);
        /// Mesa open source project
        pub const MESA_RADV: Self = Self(3);
        /// NVIDIA Corporation
        pub const NVIDIA_PROPRIETARY: Self = Self(4);
        /// Intel Corporation
        pub const INTEL_PROPRIETARY_WINDOWS: Self = Self(5);
        /// Intel Corporation
        pub const INTEL_OPEN_SOURCE_MESA: Self = Self(6);
        /// Imagination Technologies
        pub const IMAGINATION_PROPRIETARY: Self = Self(7);
        /// Qualcomm Technologies, Inc.
        pub const QUALCOMM_PROPRIETARY: Self = Self(8);
        /// Arm Limited
        pub const ARM_PROPRIETARY: Self = Self(9);
        /// Google LLC
        pub const GOOGLE_SWIFTSHADER: Self = Self(10);
        /// Google LLC
        pub const GGP_PROPRIETARY: Self = Self(11);
        /// Broadcom Inc.
        pub const BROADCOM_PROPRIETARY: Self = Self(12);
        /// Mesa
        pub const MESA_LLVMPIPE: Self = Self(13);
        /// MoltenVK
        pub const MOLTENVK: Self = Self(14);
        /// Core Avionics & Industrial Inc.
        pub const COREAVI_PROPRIETARY: Self = Self(15);
        /// Juice Technologies, Inc.
        pub const JUICE_PROPRIETARY: Self = Self(16);
        /// Verisilicon, Inc.
        pub const VERISILICON_PROPRIETARY: Self = Self(17);
        /// Mesa open source project
        pub const MESA_TURNIP: Self = Self(18);
        /// Mesa open source project
        pub const MESA_V3DV: Self = Self(19);
        /// Mesa open source project
        pub const MESA_PANVK: Self = Self(20);
        /// Samsung Electronics Co., Ltd.
        pub const SAMSUNG_PROPRIETARY: Self = Self(21);
        /// Mesa open source project
        pub const MESA_VENUS: Self = Self(22);
        /// Mesa open source project
        pub const MESA_DOZEN: Self = Self(23);
        /// Mesa open source project
        pub const MESA_NVK: Self = Self(24);
        /// Imagination Technologies
        pub const IMAGINATION_OPEN_SOURCE_MESA: Self = Self(25);
        /// Mesa open source project
        pub const MESA_HONEYKRISP: Self = Self(26);
        /// Vulkan SC Emulation on Vulkan
        pub const VULKAN_SC_EMULATION_ON_VULKAN: Self = Self(27);
        /// Mesa open source project
        pub const MESA_KOSMICKRISP: Self = Self(28);
        /// Mesa open source project
        pub const MESA_GFXSTREAM: Self = Self(29);
        /// Ape open source project
        pub const APE_SOFT: Self = Self(30);
        /// Reserved for undisclosed driver project
        pub const RESERVED_31: Self = Self(31);

        // VK_KHR_driver_properties
        pub const AMD_PROPRIETARY_KHR: Self = Self::AMD_PROPRIETARY;
        pub const AMD_OPEN_SOURCE_KHR: Self = Self::AMD_OPEN_SOURCE;
        pub const MESA_RADV_KHR: Self = Self::MESA_RADV;
        pub const NVIDIA_PROPRIETARY_KHR: Self = Self::NVIDIA_PROPRIETARY;
        pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = Self::INTEL_PROPRIETARY_WINDOWS;
        pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = Self::INTEL_OPEN_SOURCE_MESA;
        pub const IMAGINATION_PROPRIETARY_KHR: Self = Self::IMAGINATION_PROPRIETARY;
        pub const QUALCOMM_PROPRIETARY_KHR: Self = Self::QUALCOMM_PROPRIETARY;
        pub const ARM_PROPRIETARY_KHR: Self = Self::ARM_PROPRIETARY;
        pub const GOOGLE_SWIFTSHADER_KHR: Self = Self::GOOGLE_SWIFTSHADER;
        pub const GGP_PROPRIETARY_KHR: Self = Self::GGP_PROPRIETARY;
        pub const BROADCOM_PROPRIETARY_KHR: Self = Self::BROADCOM_PROPRIETARY;
    }

    impl fmt::Debug for DriverId {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"),
                Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"),
                Self::MESA_RADV => Some("MESA_RADV"),
                Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"),
                Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"),
                Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"),
                Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"),
                Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"),
                Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"),
                Self::GOOGLE_SWIFTSHADER => Some("GOOGLE_SWIFTSHADER"),
                Self::GGP_PROPRIETARY => Some("GGP_PROPRIETARY"),
                Self::BROADCOM_PROPRIETARY => Some("BROADCOM_PROPRIETARY"),
                Self::MESA_LLVMPIPE => Some("MESA_LLVMPIPE"),
                Self::MOLTENVK => Some("MOLTENVK"),
                Self::COREAVI_PROPRIETARY => Some("COREAVI_PROPRIETARY"),
                Self::JUICE_PROPRIETARY => Some("JUICE_PROPRIETARY"),
                Self::VERISILICON_PROPRIETARY => Some("VERISILICON_PROPRIETARY"),
                Self::MESA_TURNIP => Some("MESA_TURNIP"),
                Self::MESA_V3DV => Some("MESA_V3DV"),
                Self::MESA_PANVK => Some("MESA_PANVK"),
                Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"),
                Self::MESA_VENUS => Some("MESA_VENUS"),
                Self::MESA_DOZEN => Some("MESA_DOZEN"),
                Self::MESA_NVK => Some("MESA_NVK"),
                Self::IMAGINATION_OPEN_SOURCE_MESA => Some("IMAGINATION_OPEN_SOURCE_MESA"),
                Self::MESA_HONEYKRISP => Some("MESA_HONEYKRISP"),
                Self::VULKAN_SC_EMULATION_ON_VULKAN => Some("VULKAN_SC_EMULATION_ON_VULKAN"),
                Self::MESA_KOSMICKRISP => Some("MESA_KOSMICKRISP"),
                Self::MESA_GFXSTREAM => Some("MESA_GFXSTREAM"),
                Self::APE_SOFT => Some("APE_SOFT"),
                Self::RESERVED_31 => Some("RESERVED_31"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderFloatControlsIndependence.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ShaderFloatControlsIndependence(i32);

    impl ShaderFloatControlsIndependence {
        #[inline]
        pub const fn from_raw(x: i32) -> Self {
            Self(x)
        }
        #[inline]
        pub const fn as_raw(self) -> i32 {
            self.0
        }

        pub const _32_BIT_ONLY: Self = Self(0);
        pub const ALL: Self = Self(1);
        pub const NONE: Self = Self(2);

        // VK_KHR_shader_float_controls
        pub const _32_BIT_ONLY_KHR: Self = Self::_32_BIT_ONLY;
        pub const ALL_KHR: Self = Self::ALL;
        pub const NONE_KHR: Self = Self::NONE;
    }

    impl fmt::Debug for ShaderFloatControlsIndependence {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::_32_BIT_ONLY => Some("_32_BIT_ONLY"),
                Self::ALL => Some("ALL"),
                Self::NONE => Some("NONE"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlags.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct SemaphoreWaitFlags(Flags);
    vk_bitflags_wrapped!(SemaphoreWaitFlags, Flags, SemaphoreWaitFlagBits);

    impl fmt::Debug for SemaphoreWaitFlags {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[(SemaphoreWaitFlagBits::ANY.0, "ANY")];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlagBits.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct SemaphoreWaitFlagBits(u32);

    impl SemaphoreWaitFlagBits {
        pub const ANY: Self = Self(1 << 0);
        // VK_KHR_timeline_semaphore
        pub const ANY_KHR: Self = Self::ANY;
    }

    impl fmt::Debug for SemaphoreWaitFlagBits {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::ANY => Some("ANY"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlags.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct DescriptorBindingFlags(Flags);
    vk_bitflags_wrapped!(DescriptorBindingFlags, Flags, DescriptorBindingFlagBits);

    impl fmt::Debug for DescriptorBindingFlags {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[
                (
                    DescriptorBindingFlagBits::UPDATE_AFTER_BIND.0,
                    "UPDATE_AFTER_BIND",
                ),
                (
                    DescriptorBindingFlagBits::UPDATE_UNUSED_WHILE_PENDING.0,
                    "UPDATE_UNUSED_WHILE_PENDING",
                ),
                (
                    DescriptorBindingFlagBits::PARTIALLY_BOUND.0,
                    "PARTIALLY_BOUND",
                ),
                (
                    DescriptorBindingFlagBits::VARIABLE_DESCRIPTOR_COUNT.0,
                    "VARIABLE_DESCRIPTOR_COUNT",
                ),
            ];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlagBits.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct DescriptorBindingFlagBits(u32);

    impl DescriptorBindingFlagBits {
        pub const UPDATE_AFTER_BIND: Self = Self(1 << 0);
        pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(1 << 1);
        pub const PARTIALLY_BOUND: Self = Self(1 << 2);
        pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(1 << 3);
        // VK_EXT_descriptor_indexing
        pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND;
        pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = Self::UPDATE_UNUSED_WHILE_PENDING;
        pub const PARTIALLY_BOUND_EXT: Self = Self::PARTIALLY_BOUND;
        pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = Self::VARIABLE_DESCRIPTOR_COUNT;
    }

    impl fmt::Debug for DescriptorBindingFlagBits {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::UPDATE_AFTER_BIND => Some("UPDATE_AFTER_BIND"),
                Self::UPDATE_UNUSED_WHILE_PENDING => Some("UPDATE_UNUSED_WHILE_PENDING"),
                Self::PARTIALLY_BOUND => Some("PARTIALLY_BOUND"),
                Self::VARIABLE_DESCRIPTOR_COUNT => Some("VARIABLE_DESCRIPTOR_COUNT"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlags.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct ResolveModeFlags(Flags);
    vk_bitflags_wrapped!(ResolveModeFlags, Flags, ResolveModeFlagBits);

    impl ResolveModeFlags {
        pub const NONE: Self = Self(0);
    }

    impl fmt::Debug for ResolveModeFlags {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            const KNOWN: &[(Flags, &str)] = &[
                (ResolveModeFlagBits::SAMPLE_ZERO.0, "SAMPLE_ZERO"),
                (ResolveModeFlagBits::AVERAGE.0, "AVERAGE"),
                (ResolveModeFlagBits::MIN.0, "MIN"),
                (ResolveModeFlagBits::MAX.0, "MAX"),
                (
                    ResolveModeFlagBits::EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID.0,
                    "EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID",
                ),
                (ResolveModeFlagBits::CUSTOM_EXT.0, "CUSTOM_EXT"),
            ];
            debug_flags(f, KNOWN, self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlagBits.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
    pub struct ResolveModeFlagBits(u32);

    impl ResolveModeFlagBits {
        pub const SAMPLE_ZERO: Self = Self(1 << 0);
        pub const AVERAGE: Self = Self(1 << 1);
        pub const MIN: Self = Self(1 << 2);
        pub const MAX: Self = Self(1 << 3);
        // VK_ANDROID_external_format_resolve
        pub const EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID: Self = Self(1 << 4);

        // VK_EXT_custom_resolve
        pub const CUSTOM_EXT: Self = Self(1 << 5);

        // VK_KHR_depth_stencil_resolve
        pub const SAMPLE_ZERO_KHR: Self = Self::SAMPLE_ZERO;
        pub const AVERAGE_KHR: Self = Self::AVERAGE;
        pub const MIN_KHR: Self = Self::MIN;
        pub const MAX_KHR: Self = Self::MAX;
    }

    impl fmt::Debug for ResolveModeFlagBits {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::SAMPLE_ZERO => Some("SAMPLE_ZERO"),
                Self::AVERAGE => Some("AVERAGE"),
                Self::MIN => Some("MIN"),
                Self::MAX => Some("MAX"),
                Self::EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID => {
                    Some("EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID")
                }
                Self::CUSTOM_EXT => Some("CUSTOM_EXT"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html>
    pub type PFN_vkResetQueryPool = unsafe extern "system" fn(
        device: Device,
        query_pool: QueryPool,
        first_query: u32,
        query_count: u32,
    );
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html>
    pub type PFN_vkCreateRenderPass2 = unsafe extern "system" fn(
        device: Device,
        p_create_info: *const RenderPassCreateInfo2<'_>,
        p_allocator: *const AllocationCallbacks<'_>,
        p_render_pass: *mut RenderPass,
    ) -> vk::Result;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html>
    pub type PFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn(
        command_buffer: CommandBuffer,
        p_render_pass_begin: *const RenderPassBeginInfo<'_>,
        p_subpass_begin_info: *const SubpassBeginInfo<'_>,
    );
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html>
    pub type PFN_vkCmdNextSubpass2 = unsafe extern "system" fn(
        command_buffer: CommandBuffer,
        p_subpass_begin_info: *const SubpassBeginInfo<'_>,
        p_subpass_end_info: *const SubpassEndInfo<'_>,
    );
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html>
    pub type PFN_vkCmdEndRenderPass2 = unsafe extern "system" fn(
        command_buffer: CommandBuffer,
        p_subpass_end_info: *const SubpassEndInfo<'_>,
    );
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html>
    pub type PFN_vkGetSemaphoreCounterValue = unsafe extern "system" fn(
        device: Device,
        semaphore: Semaphore,
        p_value: *mut u64,
    ) -> vk::Result;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html>
    pub type PFN_vkWaitSemaphores = unsafe extern "system" fn(
        device: Device,
        p_wait_info: *const SemaphoreWaitInfo<'_>,
        timeout: u64,
    ) -> vk::Result;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html>
    pub type PFN_vkSignalSemaphore = unsafe extern "system" fn(
        device: Device,
        p_signal_info: *const SemaphoreSignalInfo<'_>,
    ) -> vk::Result;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html>
    pub type PFN_vkCmdDrawIndirectCount = unsafe extern "system" fn(
        command_buffer: CommandBuffer,
        buffer: Buffer,
        offset: DeviceSize,
        count_buffer: Buffer,
        count_buffer_offset: DeviceSize,
        max_draw_count: u32,
        stride: u32,
    );
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html>
    pub type PFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn(
        command_buffer: CommandBuffer,
        buffer: Buffer,
        offset: DeviceSize,
        count_buffer: Buffer,
        count_buffer_offset: DeviceSize,
        max_draw_count: u32,
        stride: u32,
    );
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html>
    pub type PFN_vkGetBufferOpaqueCaptureAddress = unsafe extern "system" fn(
        device: Device,
        p_info: *const BufferDeviceAddressInfo<'_>,
    ) -> u64;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html>
    pub type PFN_vkGetBufferDeviceAddress = unsafe extern "system" fn(
        device: Device,
        p_info: *const BufferDeviceAddressInfo<'_>,
    ) -> DeviceAddress;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html>
    pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn(
        device: Device,
        p_info: *const DeviceMemoryOpaqueCaptureAddressInfo<'_>,
    ) -> u64;
}

#[cfg(feature = "ffi")]
pub(super) mod ffi {
    #![allow(non_camel_case_types)]
    use super::defs::*;

    pub type VkConformanceVersion = ConformanceVersion;
    pub type VkPhysicalDeviceDriverProperties = PhysicalDeviceDriverProperties<'static>;
    pub type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures =
        PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'static>;
    pub type VkPhysicalDeviceSamplerFilterMinmaxProperties =
        PhysicalDeviceSamplerFilterMinmaxProperties<'static>;
    pub type VkSamplerReductionModeCreateInfo = SamplerReductionModeCreateInfo<'static>;
    pub type VkImageFormatListCreateInfo = ImageFormatListCreateInfo<'static>;
    pub type VkPhysicalDeviceShaderFloat16Int8Features =
        PhysicalDeviceShaderFloat16Int8Features<'static>;
    pub type VkPhysicalDeviceFloatControlsProperties =
        PhysicalDeviceFloatControlsProperties<'static>;
    pub type VkPhysicalDeviceHostQueryResetFeatures = PhysicalDeviceHostQueryResetFeatures<'static>;
    pub type VkPhysicalDeviceDescriptorIndexingFeatures =
        PhysicalDeviceDescriptorIndexingFeatures<'static>;
    pub type VkPhysicalDeviceDescriptorIndexingProperties =
        PhysicalDeviceDescriptorIndexingProperties<'static>;
    pub type VkDescriptorSetLayoutBindingFlagsCreateInfo =
        DescriptorSetLayoutBindingFlagsCreateInfo<'static>;
    pub type VkDescriptorSetVariableDescriptorCountAllocateInfo =
        DescriptorSetVariableDescriptorCountAllocateInfo<'static>;
    pub type VkDescriptorSetVariableDescriptorCountLayoutSupport =
        DescriptorSetVariableDescriptorCountLayoutSupport<'static>;
    pub type VkAttachmentDescription2 = AttachmentDescription2<'static>;
    pub type VkAttachmentReference2 = AttachmentReference2<'static>;
    pub type VkSubpassDescription2 = SubpassDescription2<'static>;
    pub type VkSubpassDependency2 = SubpassDependency2<'static>;
    pub type VkRenderPassCreateInfo2 = RenderPassCreateInfo2<'static>;
    pub type VkSubpassBeginInfo = SubpassBeginInfo<'static>;
    pub type VkSubpassEndInfo = SubpassEndInfo<'static>;
    pub type VkPhysicalDeviceTimelineSemaphoreFeatures =
        PhysicalDeviceTimelineSemaphoreFeatures<'static>;
    pub type VkPhysicalDeviceTimelineSemaphoreProperties =
        PhysicalDeviceTimelineSemaphoreProperties<'static>;
    pub type VkSemaphoreTypeCreateInfo = SemaphoreTypeCreateInfo<'static>;
    pub type VkTimelineSemaphoreSubmitInfo = TimelineSemaphoreSubmitInfo<'static>;
    pub type VkSemaphoreWaitInfo = SemaphoreWaitInfo<'static>;
    pub type VkSemaphoreSignalInfo = SemaphoreSignalInfo<'static>;
    pub type VkPhysicalDevice8BitStorageFeatures = PhysicalDevice8BitStorageFeatures<'static>;
    pub type VkPhysicalDeviceVulkanMemoryModelFeatures =
        PhysicalDeviceVulkanMemoryModelFeatures<'static>;
    pub type VkPhysicalDeviceShaderAtomicInt64Features =
        PhysicalDeviceShaderAtomicInt64Features<'static>;
    pub type VkPhysicalDeviceDepthStencilResolveProperties =
        PhysicalDeviceDepthStencilResolveProperties<'static>;
    pub type VkSubpassDescriptionDepthStencilResolve =
        SubpassDescriptionDepthStencilResolve<'static>;
    pub type VkImageStencilUsageCreateInfo = ImageStencilUsageCreateInfo<'static>;
    pub type VkPhysicalDeviceScalarBlockLayoutFeatures =
        PhysicalDeviceScalarBlockLayoutFeatures<'static>;
    pub type VkPhysicalDeviceUniformBufferStandardLayoutFeatures =
        PhysicalDeviceUniformBufferStandardLayoutFeatures<'static>;
    pub type VkPhysicalDeviceBufferDeviceAddressFeatures =
        PhysicalDeviceBufferDeviceAddressFeatures<'static>;
    pub type VkBufferDeviceAddressInfo = BufferDeviceAddressInfo<'static>;
    pub type VkBufferOpaqueCaptureAddressCreateInfo = BufferOpaqueCaptureAddressCreateInfo<'static>;
    pub type VkPhysicalDeviceImagelessFramebufferFeatures =
        PhysicalDeviceImagelessFramebufferFeatures<'static>;
    pub type VkFramebufferAttachmentsCreateInfo = FramebufferAttachmentsCreateInfo<'static>;
    pub type VkFramebufferAttachmentImageInfo = FramebufferAttachmentImageInfo<'static>;
    pub type VkRenderPassAttachmentBeginInfo = RenderPassAttachmentBeginInfo<'static>;
    pub type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures =
        PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'static>;
    pub type VkAttachmentReferenceStencilLayout = AttachmentReferenceStencilLayout<'static>;
    pub type VkAttachmentDescriptionStencilLayout = AttachmentDescriptionStencilLayout<'static>;
    pub type VkMemoryOpaqueCaptureAddressAllocateInfo =
        MemoryOpaqueCaptureAddressAllocateInfo<'static>;
    pub type VkDeviceMemoryOpaqueCaptureAddressInfo = DeviceMemoryOpaqueCaptureAddressInfo<'static>;
    pub type VkPhysicalDeviceVulkan11Features = PhysicalDeviceVulkan11Features<'static>;
    pub type VkPhysicalDeviceVulkan11Properties = PhysicalDeviceVulkan11Properties<'static>;
    pub type VkPhysicalDeviceVulkan12Features = PhysicalDeviceVulkan12Features<'static>;
    pub type VkPhysicalDeviceVulkan12Properties = PhysicalDeviceVulkan12Properties<'static>;
    pub type VkSemaphoreType = SemaphoreType;
    pub type VkSamplerReductionMode = SamplerReductionMode;
    pub type VkDriverId = DriverId;
    pub type VkShaderFloatControlsIndependence = ShaderFloatControlsIndependence;
    pub type VkSemaphoreWaitFlags = SemaphoreWaitFlags;
    pub type VkSemaphoreWaitFlagBits = SemaphoreWaitFlagBits;
    pub type VkDescriptorBindingFlags = DescriptorBindingFlags;
    pub type VkDescriptorBindingFlagBits = DescriptorBindingFlagBits;
    pub type VkResolveModeFlags = ResolveModeFlags;
    pub type VkResolveModeFlagBits = ResolveModeFlagBits;
    impl PhysicalDeviceDriverProperties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceDriverProperties {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceSamplerFilterMinmaxProperties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceSamplerFilterMinmaxProperties {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SamplerReductionModeCreateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSamplerReductionModeCreateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl ImageFormatListCreateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkImageFormatListCreateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceShaderFloat16Int8Features<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceShaderFloat16Int8Features {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceFloatControlsProperties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceFloatControlsProperties {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceHostQueryResetFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceHostQueryResetFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceDescriptorIndexingFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceDescriptorIndexingFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceDescriptorIndexingProperties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceDescriptorIndexingProperties {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl DescriptorSetLayoutBindingFlagsCreateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDescriptorSetLayoutBindingFlagsCreateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl DescriptorSetVariableDescriptorCountAllocateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkDescriptorSetVariableDescriptorCountAllocateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl DescriptorSetVariableDescriptorCountLayoutSupport<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkDescriptorSetVariableDescriptorCountLayoutSupport {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl AttachmentDescription2<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkAttachmentDescription2 {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl AttachmentReference2<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkAttachmentReference2 {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SubpassDescription2<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSubpassDescription2 {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SubpassDependency2<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSubpassDependency2 {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl RenderPassCreateInfo2<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkRenderPassCreateInfo2 {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SubpassBeginInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSubpassBeginInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SubpassEndInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSubpassEndInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceTimelineSemaphoreFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceTimelineSemaphoreFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceTimelineSemaphoreProperties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceTimelineSemaphoreProperties {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SemaphoreTypeCreateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSemaphoreTypeCreateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl TimelineSemaphoreSubmitInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkTimelineSemaphoreSubmitInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SemaphoreWaitInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSemaphoreWaitInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SemaphoreSignalInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSemaphoreSignalInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDevice8BitStorageFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDevice8BitStorageFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceVulkanMemoryModelFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceVulkanMemoryModelFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceShaderAtomicInt64Features<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceShaderAtomicInt64Features {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceDepthStencilResolveProperties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceDepthStencilResolveProperties {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl SubpassDescriptionDepthStencilResolve<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSubpassDescriptionDepthStencilResolve {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl ImageStencilUsageCreateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkImageStencilUsageCreateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceScalarBlockLayoutFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceScalarBlockLayoutFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceBufferDeviceAddressFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceBufferDeviceAddressFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl BufferDeviceAddressInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkBufferDeviceAddressInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl BufferOpaqueCaptureAddressCreateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkBufferOpaqueCaptureAddressCreateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceImagelessFramebufferFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceImagelessFramebufferFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl FramebufferAttachmentsCreateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkFramebufferAttachmentsCreateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl FramebufferAttachmentImageInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkFramebufferAttachmentImageInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl RenderPassAttachmentBeginInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkRenderPassAttachmentBeginInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl AttachmentReferenceStencilLayout<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkAttachmentReferenceStencilLayout {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl AttachmentDescriptionStencilLayout<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkAttachmentDescriptionStencilLayout {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl MemoryOpaqueCaptureAddressAllocateInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkMemoryOpaqueCaptureAddressAllocateInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl DeviceMemoryOpaqueCaptureAddressInfo<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDeviceMemoryOpaqueCaptureAddressInfo {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceVulkan11Features<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceVulkan11Features {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceVulkan11Properties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceVulkan11Properties {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceVulkan12Features<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceVulkan12Features {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceVulkan12Properties<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceVulkan12Properties {
            unsafe { core::mem::transmute(self) }
        }
    }
}

pub struct DeviceFn {
    reset_query_pool: PFN_vkResetQueryPool,
    get_semaphore_counter_value: PFN_vkGetSemaphoreCounterValue,
    wait_semaphores: PFN_vkWaitSemaphores,
    signal_semaphore: PFN_vkSignalSemaphore,
    get_buffer_device_address: PFN_vkGetBufferDeviceAddress,
    get_buffer_opaque_capture_address: PFN_vkGetBufferOpaqueCaptureAddress,
    get_device_memory_opaque_capture_address: PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
    cmd_draw_indirect_count: PFN_vkCmdDrawIndirectCount,
    cmd_draw_indexed_indirect_count: PFN_vkCmdDrawIndexedIndirectCount,
    create_render_pass2: PFN_vkCreateRenderPass2,
    cmd_begin_render_pass2: PFN_vkCmdBeginRenderPass2,
    cmd_next_subpass2: PFN_vkCmdNextSubpass2,
    cmd_end_render_pass2: PFN_vkCmdEndRenderPass2,
}

impl LoadDeviceFn for DeviceFn {
    unsafe fn load_with(
        load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
    ) -> core::result::Result<Self, MissingEntryPointError> {
        unsafe {
            Ok(Self {
                reset_query_pool: transmute(
                    load(c"vkResetQueryPool").ok_or(MissingEntryPointError)?,
                ),
                get_semaphore_counter_value: transmute(
                    load(c"vkGetSemaphoreCounterValue").ok_or(MissingEntryPointError)?,
                ),
                wait_semaphores: transmute(
                    load(c"vkWaitSemaphores").ok_or(MissingEntryPointError)?,
                ),
                signal_semaphore: transmute(
                    load(c"vkSignalSemaphore").ok_or(MissingEntryPointError)?,
                ),
                get_buffer_device_address: transmute(
                    load(c"vkGetBufferDeviceAddress").ok_or(MissingEntryPointError)?,
                ),
                get_buffer_opaque_capture_address: transmute(
                    load(c"vkGetBufferOpaqueCaptureAddress").ok_or(MissingEntryPointError)?,
                ),
                get_device_memory_opaque_capture_address: transmute(
                    load(c"vkGetDeviceMemoryOpaqueCaptureAddress").ok_or(MissingEntryPointError)?,
                ),
                cmd_draw_indirect_count: transmute(
                    load(c"vkCmdDrawIndirectCount").ok_or(MissingEntryPointError)?,
                ),
                cmd_draw_indexed_indirect_count: transmute(
                    load(c"vkCmdDrawIndexedIndirectCount").ok_or(MissingEntryPointError)?,
                ),
                create_render_pass2: transmute(
                    load(c"vkCreateRenderPass2").ok_or(MissingEntryPointError)?,
                ),
                cmd_begin_render_pass2: transmute(
                    load(c"vkCmdBeginRenderPass2").ok_or(MissingEntryPointError)?,
                ),
                cmd_next_subpass2: transmute(
                    load(c"vkCmdNextSubpass2").ok_or(MissingEntryPointError)?,
                ),
                cmd_end_render_pass2: transmute(
                    load(c"vkCmdEndRenderPass2").ok_or(MissingEntryPointError)?,
                ),
            })
        }
    }
}

impl DeviceFn {
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html>
    #[inline]
    pub unsafe fn reset_query_pool(
        &self,
        device: Device,
        query_pool: QueryPool,
        first_query: u32,
        query_count: u32,
    ) {
        unsafe { (self.reset_query_pool)(device, query_pool, first_query, query_count) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html>
    #[inline]
    pub unsafe fn get_semaphore_counter_value(
        &self,
        device: Device,
        semaphore: Semaphore,
    ) -> crate::Result<u64> {
        unsafe {
            let mut value = core::mem::MaybeUninit::uninit();
            let result = (self.get_semaphore_counter_value)(device, semaphore, value.as_mut_ptr());

            match result {
                VkResult::SUCCESS => Ok(value.assume_init()),
                err => Err(err),
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html>
    #[inline]
    pub unsafe fn wait_semaphores(
        &self,
        device: Device,
        wait_info: &SemaphoreWaitInfo<'_>,
        timeout: u64,
    ) -> crate::Result<()> {
        unsafe {
            let result = (self.wait_semaphores)(device, wait_info, timeout);

            match result {
                VkResult::SUCCESS => Ok(()),
                err => Err(err),
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html>
    #[inline]
    pub unsafe fn signal_semaphore(
        &self,
        device: Device,
        signal_info: &SemaphoreSignalInfo<'_>,
    ) -> crate::Result<()> {
        unsafe {
            let result = (self.signal_semaphore)(device, signal_info);

            match result {
                VkResult::SUCCESS => Ok(()),
                err => Err(err),
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html>
    #[inline]
    pub unsafe fn get_buffer_device_address(
        &self,
        device: Device,
        info: &BufferDeviceAddressInfo<'_>,
    ) -> DeviceAddress {
        unsafe { (self.get_buffer_device_address)(device, info) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html>
    #[inline]
    pub unsafe fn get_buffer_opaque_capture_address(
        &self,
        device: Device,
        info: &BufferDeviceAddressInfo<'_>,
    ) -> u64 {
        unsafe { (self.get_buffer_opaque_capture_address)(device, info) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html>
    #[inline]
    pub unsafe fn get_device_memory_opaque_capture_address(
        &self,
        device: Device,
        info: &DeviceMemoryOpaqueCaptureAddressInfo<'_>,
    ) -> u64 {
        unsafe { (self.get_device_memory_opaque_capture_address)(device, info) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html>
    #[inline]
    pub unsafe fn cmd_draw_indirect_count(
        &self,
        command_buffer: CommandBuffer,
        buffer: Buffer,
        offset: DeviceSize,
        count_buffer: Buffer,
        count_buffer_offset: DeviceSize,
        max_draw_count: u32,
        stride: u32,
    ) {
        unsafe {
            (self.cmd_draw_indirect_count)(
                command_buffer,
                buffer,
                offset,
                count_buffer,
                count_buffer_offset,
                max_draw_count,
                stride,
            )
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html>
    #[inline]
    pub unsafe fn cmd_draw_indexed_indirect_count(
        &self,
        command_buffer: CommandBuffer,
        buffer: Buffer,
        offset: DeviceSize,
        count_buffer: Buffer,
        count_buffer_offset: DeviceSize,
        max_draw_count: u32,
        stride: u32,
    ) {
        unsafe {
            (self.cmd_draw_indexed_indirect_count)(
                command_buffer,
                buffer,
                offset,
                count_buffer,
                count_buffer_offset,
                max_draw_count,
                stride,
            )
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html>
    #[inline]
    pub unsafe fn create_render_pass2(
        &self,
        device: Device,
        create_info: &RenderPassCreateInfo2<'_>,
        allocator: Option<&AllocationCallbacks<'_>>,
    ) -> crate::Result<RenderPass> {
        unsafe {
            let mut render_pass = core::mem::MaybeUninit::uninit();
            let result = (self.create_render_pass2)(
                device,
                create_info,
                allocator.to_raw_ptr(),
                render_pass.as_mut_ptr(),
            );

            match result {
                VkResult::SUCCESS => Ok(render_pass.assume_init()),
                err => Err(err),
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html>
    #[inline]
    pub unsafe fn cmd_begin_render_pass2(
        &self,
        command_buffer: CommandBuffer,
        render_pass_begin: &RenderPassBeginInfo<'_>,
        subpass_begin_info: &SubpassBeginInfo<'_>,
    ) {
        unsafe {
            (self.cmd_begin_render_pass2)(command_buffer, render_pass_begin, subpass_begin_info)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html>
    #[inline]
    pub unsafe fn cmd_next_subpass2(
        &self,
        command_buffer: CommandBuffer,
        subpass_begin_info: &SubpassBeginInfo<'_>,
        subpass_end_info: &SubpassEndInfo<'_>,
    ) {
        unsafe { (self.cmd_next_subpass2)(command_buffer, subpass_begin_info, subpass_end_info) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html>
    #[inline]
    pub unsafe fn cmd_end_render_pass2(
        &self,
        command_buffer: CommandBuffer,
        subpass_end_info: &SubpassEndInfo<'_>,
    ) {
        unsafe { (self.cmd_end_render_pass2)(command_buffer, subpass_end_info) }
    }
}