Update Vulkan-Headers to 1.2.166 (#355)

* Update Vulkan-Headers to 1.2.165

* Update Vulkan-Headers to 1.2.166

* generator: Update itertools to 0.10

ash/src/vk/const_debugs.rs

@@ -906,6 +906,10 @@ impl fmt::Debug for DescriptorPoolCreateFlags {
                 DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0,
                 "FREE_DESCRIPTOR_SET",
             ),
+            (
+                DescriptorPoolCreateFlags::HOST_ONLY_VALVE.0,
+                "HOST_ONLY_VALVE",
+            ),
             (
                 DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0,
                 "UPDATE_AFTER_BIND",
@@ -927,6 +931,10 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags {
                 DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0,
                 "PUSH_DESCRIPTOR_KHR",
             ),
+            (
+                DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_VALVE.0,
+                "HOST_ONLY_POOL_VALVE",
+            ),
             (
                 DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL.0,
                 "UPDATE_AFTER_BIND_POOL",
@@ -952,6 +960,7 @@ impl fmt::Debug for DescriptorType {
             Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"),
             Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
             Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
+            Self::MUTABLE_VALVE => Some("MUTABLE_VALVE"),
             _ => None,
         };
         if let Some(x) = name {
@@ -4284,6 +4293,12 @@ impl fmt::Debug for StructureType {
                 Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT")
             }
             Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"),
+            Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE => {
+                Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE")
+            }
+            Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE => {
+                Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE")
+            }
             Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => {
                 Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES")
             }
@@ -4778,6 +4793,7 @@ impl fmt::Debug for VendorId {
             Self::KAZAN => Some("KAZAN"),
             Self::CODEPLAY => Some("CODEPLAY"),
             Self::MESA => Some("MESA"),
+            Self::POCL => Some("POCL"),
             _ => None,
         };
         if let Some(x) = name {

ash/src/vk/definitions.rs

@@ -9,7 +9,7 @@ use std::os::raw::*;
 pub const API_VERSION_1_0: u32 = crate::vk::make_version(1, 0, 0);
 pub const API_VERSION_1_1: u32 = crate::vk::make_version(1, 1, 0);
 pub const API_VERSION_1_2: u32 = crate::vk::make_version(1, 2, 0);
-pub const HEADER_VERSION: u32 = 162u32;
+pub const HEADER_VERSION: u32 = 166u32;
 pub const HEADER_VERSION_COMPLETE: u32 = crate::vk::make_version(1, 2, HEADER_VERSION);
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleMask.html>"]
 pub type SampleMask = u32;
@@ -48782,3 +48782,185 @@ impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
         self.inner
     }
 }
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html>"]
+pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub mutable_descriptor_type: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+    fn default() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+        PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+            s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
+            p_next: ::std::ptr::null_mut(),
+            mutable_descriptor_type: Bool32::default(),
+        }
+    }
+}
+impl PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+    pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+        PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder {
+            inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+    inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+    type Target = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+    pub fn mutable_descriptor_type(
+        mut self,
+        mutable_descriptor_type: bool,
+    ) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+        self.inner.mutable_descriptor_type = mutable_descriptor_type.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMutableDescriptorTypeListVALVE.html>"]
+pub struct MutableDescriptorTypeListVALVE {
+    pub descriptor_type_count: u32,
+    pub p_descriptor_types: *const DescriptorType,
+}
+impl ::std::default::Default for MutableDescriptorTypeListVALVE {
+    fn default() -> MutableDescriptorTypeListVALVE {
+        MutableDescriptorTypeListVALVE {
+            descriptor_type_count: u32::default(),
+            p_descriptor_types: ::std::ptr::null(),
+        }
+    }
+}
+impl MutableDescriptorTypeListVALVE {
+    pub fn builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a> {
+        MutableDescriptorTypeListVALVEBuilder {
+            inner: MutableDescriptorTypeListVALVE::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MutableDescriptorTypeListVALVEBuilder<'a> {
+    inner: MutableDescriptorTypeListVALVE,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MutableDescriptorTypeListVALVEBuilder<'a> {
+    type Target = MutableDescriptorTypeListVALVE;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListVALVEBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> {
+    pub fn descriptor_types(
+        mut self,
+        descriptor_types: &'a [DescriptorType],
+    ) -> MutableDescriptorTypeListVALVEBuilder<'a> {
+        self.inner.descriptor_type_count = descriptor_types.len() as _;
+        self.inner.p_descriptor_types = descriptor_types.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MutableDescriptorTypeListVALVE {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMutableDescriptorTypeCreateInfoVALVE.html>"]
+pub struct MutableDescriptorTypeCreateInfoVALVE {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub mutable_descriptor_type_list_count: u32,
+    pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE,
+}
+impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE {
+    fn default() -> MutableDescriptorTypeCreateInfoVALVE {
+        MutableDescriptorTypeCreateInfoVALVE {
+            s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
+            p_next: ::std::ptr::null(),
+            mutable_descriptor_type_list_count: u32::default(),
+            p_mutable_descriptor_type_lists: ::std::ptr::null(),
+        }
+    }
+}
+impl MutableDescriptorTypeCreateInfoVALVE {
+    pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+        MutableDescriptorTypeCreateInfoVALVEBuilder {
+            inner: MutableDescriptorTypeCreateInfoVALVE::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+    inner: MutableDescriptorTypeCreateInfoVALVE,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsDescriptorSetLayoutCreateInfo
+    for MutableDescriptorTypeCreateInfoVALVEBuilder<'_>
+{
+}
+unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
+unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> {}
+unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
+impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+    type Target = MutableDescriptorTypeCreateInfoVALVE;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+    pub fn mutable_descriptor_type_lists(
+        mut self,
+        mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE],
+    ) -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+        self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _;
+        self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MutableDescriptorTypeCreateInfoVALVE {
+        self.inner
+    }
+}

ash/src/vk/enums.rs

@@ -1054,55 +1054,30 @@ impl ObjectType {
 }
 impl ObjectType {
     pub const UNKNOWN: Self = Self(0);
-    #[doc = "VkInstance"]
     pub const INSTANCE: Self = Self(1);
-    #[doc = "VkPhysicalDevice"]
     pub const PHYSICAL_DEVICE: Self = Self(2);
-    #[doc = "VkDevice"]
     pub const DEVICE: Self = Self(3);
-    #[doc = "VkQueue"]
     pub const QUEUE: Self = Self(4);
-    #[doc = "VkSemaphore"]
     pub const SEMAPHORE: Self = Self(5);
-    #[doc = "VkCommandBuffer"]
     pub const COMMAND_BUFFER: Self = Self(6);
-    #[doc = "VkFence"]
     pub const FENCE: Self = Self(7);
-    #[doc = "VkDeviceMemory"]
     pub const DEVICE_MEMORY: Self = Self(8);
-    #[doc = "VkBuffer"]
     pub const BUFFER: Self = Self(9);
-    #[doc = "VkImage"]
     pub const IMAGE: Self = Self(10);
-    #[doc = "VkEvent"]
     pub const EVENT: Self = Self(11);
-    #[doc = "VkQueryPool"]
     pub const QUERY_POOL: Self = Self(12);
-    #[doc = "VkBufferView"]
     pub const BUFFER_VIEW: Self = Self(13);
-    #[doc = "VkImageView"]
     pub const IMAGE_VIEW: Self = Self(14);
-    #[doc = "VkShaderModule"]
     pub const SHADER_MODULE: Self = Self(15);
-    #[doc = "VkPipelineCache"]
     pub const PIPELINE_CACHE: Self = Self(16);
-    #[doc = "VkPipelineLayout"]
     pub const PIPELINE_LAYOUT: Self = Self(17);
-    #[doc = "VkRenderPass"]
     pub const RENDER_PASS: Self = Self(18);
-    #[doc = "VkPipeline"]
     pub const PIPELINE: Self = Self(19);
-    #[doc = "VkDescriptorSetLayout"]
     pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20);
-    #[doc = "VkSampler"]
     pub const SAMPLER: Self = Self(21);
-    #[doc = "VkDescriptorPool"]
     pub const DESCRIPTOR_POOL: Self = Self(22);
-    #[doc = "VkDescriptorSet"]
     pub const DESCRIPTOR_SET: Self = Self(23);
-    #[doc = "VkFramebuffer"]
     pub const FRAMEBUFFER: Self = Self(24);
-    #[doc = "VkCommandPool"]
     pub const COMMAND_POOL: Self = Self(25);
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
@@ -1663,6 +1638,8 @@ impl VendorId {
     pub const CODEPLAY: Self = Self(0x1_0004);
     #[doc = "Mesa vendor ID"]
     pub const MESA: Self = Self(0x1_0005);
+    #[doc = "PoCL vendor ID"]
+    pub const POCL: Self = Self(0x1_0006);
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]

ash/src/vk/extensions.rs

@@ -24251,27 +24251,101 @@ impl ArmExtension345Fn {
         ArmExtension345Fn {}
     }
 }
-impl NvExtension346Fn {
+impl NvAcquireWinrtDisplayFn {
     pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_346\0")
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_acquire_winrt_display\0")
             .expect("Wrong extension string")
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
-pub struct NvExtension346Fn {}
+#[allow(non_camel_case_types)]
-unsafe impl Send for NvExtension346Fn {}
+pub type PFN_vkAcquireWinrtDisplayNV =
-unsafe impl Sync for NvExtension346Fn {}
+    extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result;
-impl ::std::clone::Clone for NvExtension346Fn {
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetWinrtDisplayNV = extern "system" fn(
+    physical_device: PhysicalDevice,
+    device_relative_id: u32,
+    p_display: *mut DisplayKHR,
+) -> Result;
+pub struct NvAcquireWinrtDisplayFn {
+    pub acquire_winrt_display_nv:
+        extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result,
+    pub get_winrt_display_nv: extern "system" fn(
+        physical_device: PhysicalDevice,
+        device_relative_id: u32,
+        p_display: *mut DisplayKHR,
+    ) -> Result,
+}
+unsafe impl Send for NvAcquireWinrtDisplayFn {}
+unsafe impl Sync for NvAcquireWinrtDisplayFn {}
+impl ::std::clone::Clone for NvAcquireWinrtDisplayFn {
     fn clone(&self) -> Self {
-        NvExtension346Fn {}
+        NvAcquireWinrtDisplayFn {
+            acquire_winrt_display_nv: self.acquire_winrt_display_nv,
+            get_winrt_display_nv: self.get_winrt_display_nv,
         }
     }
-impl NvExtension346Fn {
+}
+impl NvAcquireWinrtDisplayFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension346Fn {}
+        NvAcquireWinrtDisplayFn {
+            acquire_winrt_display_nv: unsafe {
+                extern "system" fn acquire_winrt_display_nv(
+                    _physical_device: PhysicalDevice,
+                    _display: DisplayKHR,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(acquire_winrt_display_nv)
+                    ))
+                }
+                let raw_name = stringify!(vkAcquireWinrtDisplayNV);
+                let cname = ::std::ffi::CString::new(raw_name).unwrap();
+                let val = _f(&cname);
+                if val.is_null() {
+                    acquire_winrt_display_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_winrt_display_nv: unsafe {
+                extern "system" fn get_winrt_display_nv(
+                    _physical_device: PhysicalDevice,
+                    _device_relative_id: u32,
+                    _p_display: *mut DisplayKHR,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(get_winrt_display_nv)))
+                }
+                let raw_name = stringify!(vkGetWinrtDisplayNV);
+                let cname = ::std::ffi::CString::new(raw_name).unwrap();
+                let val = _f(&cname);
+                if val.is_null() {
+                    get_winrt_display_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireWinrtDisplayNV.html>"]
+    pub unsafe fn acquire_winrt_display_nv(
+        &self,
+        physical_device: PhysicalDevice,
+        display: DisplayKHR,
+    ) -> Result {
+        (self.acquire_winrt_display_nv)(physical_device, display)
+    }
+    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetWinrtDisplayNV.html>"]
+    pub unsafe fn get_winrt_display_nv(
+        &self,
+        physical_device: PhysicalDevice,
+        device_relative_id: u32,
+        p_display: *mut DisplayKHR,
+    ) -> Result {
+        (self.get_winrt_display_nv)(physical_device, device_relative_id, p_display)
     }
 }
 impl ExtDirectfbSurfaceFn {
@@ -24445,29 +24519,49 @@ impl NvExtension351Fn {
         NvExtension351Fn {}
     }
 }
-impl ExtExtension352Fn {
+impl ValveMutableDescriptorTypeFn {
     pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_352\0")
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_VALVE_mutable_descriptor_type\0")
             .expect("Wrong extension string")
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
-pub struct ExtExtension352Fn {}
+pub struct ValveMutableDescriptorTypeFn {}
-unsafe impl Send for ExtExtension352Fn {}
+unsafe impl Send for ValveMutableDescriptorTypeFn {}
-unsafe impl Sync for ExtExtension352Fn {}
+unsafe impl Sync for ValveMutableDescriptorTypeFn {}
-impl ::std::clone::Clone for ExtExtension352Fn {
+impl ::std::clone::Clone for ValveMutableDescriptorTypeFn {
     fn clone(&self) -> Self {
-        ExtExtension352Fn {}
+        ValveMutableDescriptorTypeFn {}
     }
 }
-impl ExtExtension352Fn {
+impl ValveMutableDescriptorTypeFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension352Fn {}
+        ValveMutableDescriptorTypeFn {}
     }
 }
+#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self = Self(1_000_351_000);
+}
+#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
+impl StructureType {
+    pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self = Self(1_000_351_002);
+}
+#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
+impl DescriptorType {
+    pub const MUTABLE_VALVE: Self = Self(1_000_351_000);
+}
+#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
+impl DescriptorPoolCreateFlags {
+    pub const HOST_ONLY_VALVE: Self = Self(0b100);
+}
+#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
+impl DescriptorSetLayoutCreateFlags {
+    pub const HOST_ONLY_POOL_VALVE: Self = Self(0b100);
+}
 impl ExtExtension353Fn {
     pub fn name() -> &'static ::std::ffi::CStr {
         ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_353\0")
@@ -24936,3 +25030,141 @@ impl BufferCreateFlags {
 impl ImageCreateFlags {
     pub const RESERVED_15_NV: Self = Self(0b1000_0000_0000_0000);
 }
+impl NvExtension373Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_373\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+pub struct NvExtension373Fn {}
+unsafe impl Send for NvExtension373Fn {}
+unsafe impl Sync for NvExtension373Fn {}
+impl ::std::clone::Clone for NvExtension373Fn {
+    fn clone(&self) -> Self {
+        NvExtension373Fn {}
+    }
+}
+impl NvExtension373Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        NvExtension373Fn {}
+    }
+}
+impl NvExtension374Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_374\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+pub struct NvExtension374Fn {}
+unsafe impl Send for NvExtension374Fn {}
+unsafe impl Sync for NvExtension374Fn {}
+impl ::std::clone::Clone for NvExtension374Fn {
+    fn clone(&self) -> Self {
+        NvExtension374Fn {}
+    }
+}
+impl NvExtension374Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        NvExtension374Fn {}
+    }
+}
+impl NvExtension375Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_375\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+pub struct NvExtension375Fn {}
+unsafe impl Send for NvExtension375Fn {}
+unsafe impl Sync for NvExtension375Fn {}
+impl ::std::clone::Clone for NvExtension375Fn {
+    fn clone(&self) -> Self {
+        NvExtension375Fn {}
+    }
+}
+impl NvExtension375Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        NvExtension375Fn {}
+    }
+}
+impl ExtExtension376Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_376\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+pub struct ExtExtension376Fn {}
+unsafe impl Send for ExtExtension376Fn {}
+unsafe impl Sync for ExtExtension376Fn {}
+impl ::std::clone::Clone for ExtExtension376Fn {
+    fn clone(&self) -> Self {
+        ExtExtension376Fn {}
+    }
+}
+impl ExtExtension376Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        ExtExtension376Fn {}
+    }
+}
+impl ExtExtension377Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_377\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+pub struct ExtExtension377Fn {}
+unsafe impl Send for ExtExtension377Fn {}
+unsafe impl Sync for ExtExtension377Fn {}
+impl ::std::clone::Clone for ExtExtension377Fn {
+    fn clone(&self) -> Self {
+        ExtExtension377Fn {}
+    }
+}
+impl ExtExtension377Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        ExtExtension377Fn {}
+    }
+}
+impl NvExtension378Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_378\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+pub struct NvExtension378Fn {}
+unsafe impl Send for NvExtension378Fn {}
+unsafe impl Sync for NvExtension378Fn {}
+impl ::std::clone::Clone for NvExtension378Fn {
+    fn clone(&self) -> Self {
+        NvExtension378Fn {}
+    }
+}
+impl NvExtension378Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        NvExtension378Fn {}
+    }
+}

generator/Cargo.toml

@@ -10,7 +10,7 @@ vkxml = "0.3"
 nom = "6.0"
 heck = "0.3"
 proc-macro2 = "1.0"
-itertools = "0.9"
+itertools = "0.10"
 quote = "1.0"
 
 [dependencies.syn]

generator/Vulkan-Headers

@@ -1 +1 @@
-Subproject commit d2308183f2846a1453ce7ae8c77ea7b5a7424ad2
+Subproject commit 9efc4a631161eeea11082bbd16d605cca0b7a01e