Update Vulkan-Headers to 1.2.185 (#456)

* Update Vulkan-Headers to 1.2.185

* Update Vulkan-Headers to 1.2.186

ash/src/vk/const_debugs.rs

@@ -321,7 +321,10 @@ impl fmt::Debug for AccessFlags2KHR {
                 AccessFlags2KHR::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0,
                 "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT",
             ),
-            (AccessFlags2KHR::RESERVED_39_HUAWEI.0, "RESERVED_39_HUAWEI"),
+            (
+                AccessFlags2KHR::INVOCATION_MASK_READ_HUAWEI.0,
+                "INVOCATION_MASK_READ_HUAWEI",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -2251,7 +2254,11 @@ impl fmt::Debug for ImageUsageFlags {
                 ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0,
                 "VIDEO_ENCODE_DPB_KHR",
             ),
-            (ImageUsageFlags::RESERVED_18_HUAWEI.0, "RESERVED_18_HUAWEI"),
+            (ImageUsageFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"),
+            (
+                ImageUsageFlags::INVOCATION_MASK_HUAWEI.0,
+                "INVOCATION_MASK_HUAWEI",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -3134,8 +3141,8 @@ impl fmt::Debug for PipelineStageFlags2KHR {
                 "SUBPASS_SHADING_HUAWEI",
             ),
             (
-                PipelineStageFlags2KHR::RESERVED_40_HUAWEI.0,
+                PipelineStageFlags2KHR::INVOCATION_MASK_HUAWEI.0,
-                "RESERVED_40_HUAWEI",
+                "INVOCATION_MASK_HUAWEI",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
@@ -4573,6 +4580,9 @@ impl fmt::Debug for StructureType {
                 Some("PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT")
             }
             Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"),
+            Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => {
+                Some("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR")
+            }
             Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV")
             }
@@ -4642,6 +4652,9 @@ impl fmt::Debug for StructureType {
             Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => {
                 Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR")
             }
+            Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT")
+            }
             Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT")
             }
@@ -4708,6 +4721,10 @@ impl fmt::Debug for StructureType {
                 Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT")
             }
             Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"),
+            Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"),
+            Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => {
+                Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR")
+            }
             Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT")
             }
@@ -4836,6 +4853,9 @@ impl fmt::Debug for StructureType {
             Self::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI => {
                 Some("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI")
             }
+            Self::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI => {
+                Some("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI")
+            }
             Self::MEMORY_GET_REMOTE_ADDRESS_INFO_NV => Some("MEMORY_GET_REMOTE_ADDRESS_INFO_NV"),
             Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV")

ash/src/vk/definitions.rs

@@ -53,7 +53,7 @@ pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0);
 pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0);
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_1_2.html>"]
 pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0);
-pub const HEADER_VERSION: u32 = 184u32;
+pub const HEADER_VERSION: u32 = 186u32;
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
 pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION);
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleMask.html>"]
@@ -18771,6 +18771,178 @@ impl<'a> XYColorEXTBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>"]
+pub struct PhysicalDevicePresentIdFeaturesKHR {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub present_id: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR {
+    fn default() -> PhysicalDevicePresentIdFeaturesKHR {
+        PhysicalDevicePresentIdFeaturesKHR {
+            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR,
+            p_next: ::std::ptr::null_mut(),
+            present_id: Bool32::default(),
+        }
+    }
+}
+impl PhysicalDevicePresentIdFeaturesKHR {
+    pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
+        PhysicalDevicePresentIdFeaturesKHRBuilder {
+            inner: PhysicalDevicePresentIdFeaturesKHR::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
+    inner: PhysicalDevicePresentIdFeaturesKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
+    type Target = PhysicalDevicePresentIdFeaturesKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
+    pub fn present_id(mut self, present_id: bool) -> Self {
+        self.inner.present_id = present_id.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) -> PhysicalDevicePresentIdFeaturesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentIdKHR.html>"]
+pub struct PresentIdKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub swapchain_count: u32,
+    pub p_present_ids: *const u64,
+}
+impl ::std::default::Default for PresentIdKHR {
+    fn default() -> PresentIdKHR {
+        PresentIdKHR {
+            s_type: StructureType::PRESENT_ID_KHR,
+            p_next: ::std::ptr::null(),
+            swapchain_count: u32::default(),
+            p_present_ids: ::std::ptr::null(),
+        }
+    }
+}
+impl PresentIdKHR {
+    pub fn builder<'a>() -> PresentIdKHRBuilder<'a> {
+        PresentIdKHRBuilder {
+            inner: PresentIdKHR::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PresentIdKHRBuilder<'a> {
+    inner: PresentIdKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {}
+unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {}
+impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> {
+    type Target = PresentIdKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PresentIdKHRBuilder<'a> {
+    pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self {
+        self.inner.swapchain_count = present_ids.len() as _;
+        self.inner.p_present_ids = present_ids.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) -> PresentIdKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>"]
+pub struct PhysicalDevicePresentWaitFeaturesKHR {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub present_wait: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR {
+    fn default() -> PhysicalDevicePresentWaitFeaturesKHR {
+        PhysicalDevicePresentWaitFeaturesKHR {
+            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR,
+            p_next: ::std::ptr::null_mut(),
+            present_wait: Bool32::default(),
+        }
+    }
+}
+impl PhysicalDevicePresentWaitFeaturesKHR {
+    pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
+        PhysicalDevicePresentWaitFeaturesKHRBuilder {
+            inner: PhysicalDevicePresentWaitFeaturesKHR::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
+    inner: PhysicalDevicePresentWaitFeaturesKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
+    type Target = PhysicalDevicePresentWaitFeaturesKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
+    pub fn present_wait(mut self, present_wait: bool) -> Self {
+        self.inner.present_wait = present_wait.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) -> PhysicalDevicePresentWaitFeaturesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHdrMetadataEXT.html>"]
 pub struct HdrMetadataEXT {
     pub s_type: StructureType,
@@ -28772,6 +28944,168 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>"]
+pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_buffer_float16_atomics: Bool32,
+    pub shader_buffer_float16_atomic_add: Bool32,
+    pub shader_buffer_float16_atomic_min_max: Bool32,
+    pub shader_buffer_float32_atomic_min_max: Bool32,
+    pub shader_buffer_float64_atomic_min_max: Bool32,
+    pub shader_shared_float16_atomics: Bool32,
+    pub shader_shared_float16_atomic_add: Bool32,
+    pub shader_shared_float16_atomic_min_max: Bool32,
+    pub shader_shared_float32_atomic_min_max: Bool32,
+    pub shader_shared_float64_atomic_min_max: Bool32,
+    pub shader_image_float32_atomic_min_max: Bool32,
+    pub sparse_image_float32_atomic_min_max: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+    fn default() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+        PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
+            p_next: ::std::ptr::null_mut(),
+            shader_buffer_float16_atomics: Bool32::default(),
+            shader_buffer_float16_atomic_add: Bool32::default(),
+            shader_buffer_float16_atomic_min_max: Bool32::default(),
+            shader_buffer_float32_atomic_min_max: Bool32::default(),
+            shader_buffer_float64_atomic_min_max: Bool32::default(),
+            shader_shared_float16_atomics: Bool32::default(),
+            shader_shared_float16_atomic_add: Bool32::default(),
+            shader_shared_float16_atomic_min_max: Bool32::default(),
+            shader_shared_float32_atomic_min_max: Bool32::default(),
+            shader_shared_float64_atomic_min_max: Bool32::default(),
+            shader_image_float32_atomic_min_max: Bool32::default(),
+            sparse_image_float32_atomic_min_max: Bool32::default(),
+        }
+    }
+}
+impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
+        PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder {
+            inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
+    pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self {
+        self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into();
+        self
+    }
+    pub fn shader_buffer_float16_atomic_add(
+        mut self,
+        shader_buffer_float16_atomic_add: bool,
+    ) -> Self {
+        self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into();
+        self
+    }
+    pub fn shader_buffer_float16_atomic_min_max(
+        mut self,
+        shader_buffer_float16_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.shader_buffer_float16_atomic_min_max =
+            shader_buffer_float16_atomic_min_max.into();
+        self
+    }
+    pub fn shader_buffer_float32_atomic_min_max(
+        mut self,
+        shader_buffer_float32_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.shader_buffer_float32_atomic_min_max =
+            shader_buffer_float32_atomic_min_max.into();
+        self
+    }
+    pub fn shader_buffer_float64_atomic_min_max(
+        mut self,
+        shader_buffer_float64_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.shader_buffer_float64_atomic_min_max =
+            shader_buffer_float64_atomic_min_max.into();
+        self
+    }
+    pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self {
+        self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into();
+        self
+    }
+    pub fn shader_shared_float16_atomic_add(
+        mut self,
+        shader_shared_float16_atomic_add: bool,
+    ) -> Self {
+        self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into();
+        self
+    }
+    pub fn shader_shared_float16_atomic_min_max(
+        mut self,
+        shader_shared_float16_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.shader_shared_float16_atomic_min_max =
+            shader_shared_float16_atomic_min_max.into();
+        self
+    }
+    pub fn shader_shared_float32_atomic_min_max(
+        mut self,
+        shader_shared_float32_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.shader_shared_float32_atomic_min_max =
+            shader_shared_float32_atomic_min_max.into();
+        self
+    }
+    pub fn shader_shared_float64_atomic_min_max(
+        mut self,
+        shader_shared_float64_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.shader_shared_float64_atomic_min_max =
+            shader_shared_float64_atomic_min_max.into();
+        self
+    }
+    pub fn shader_image_float32_atomic_min_max(
+        mut self,
+        shader_image_float32_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into();
+        self
+    }
+    pub fn sparse_image_float32_atomic_min_max(
+        mut self,
+        sparse_image_float32_atomic_min_max: bool,
+    ) -> Self {
+        self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.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) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
 pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
     pub s_type: StructureType,
@@ -30332,6 +30666,66 @@ impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>"]
+pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub invocation_mask: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+    fn default() -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+        PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+            s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI,
+            p_next: ::std::ptr::null_mut(),
+            invocation_mask: Bool32::default(),
+        }
+    }
+}
+impl PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+    pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
+        PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder {
+            inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
+    inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
+    type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
+    pub fn invocation_mask(mut self, invocation_mask: bool) -> Self {
+        self.inner.invocation_mask = invocation_mask.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) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+        self.inner
+    }
+}
+#[repr(C)]
 #[derive(Copy, Clone, Default, Debug)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleLocationNV.html>"]
 pub struct CoarseSampleLocationNV {

ash/src/vk/extensions.rs

@@ -17996,24 +17996,66 @@ impl ExtValidationFeaturesFn {
 impl StructureType {
     pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000);
 }
-impl KhrExtension249Fn {
+impl KhrPresentWaitFn {
     pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_249\0")
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_wait\0")
             .expect("Wrong extension string")
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkWaitForPresentKHR = unsafe extern "system" fn(
+    device: Device,
+    swapchain: SwapchainKHR,
+    present_id: u64,
+    timeout: u64,
+) -> Result;
 #[derive(Clone)]
-pub struct KhrExtension249Fn {}
+pub struct KhrPresentWaitFn {
-unsafe impl Send for KhrExtension249Fn {}
+    pub wait_for_present_khr: PFN_vkWaitForPresentKHR,
-unsafe impl Sync for KhrExtension249Fn {}
+}
-impl KhrExtension249Fn {
+unsafe impl Send for KhrPresentWaitFn {}
+unsafe impl Sync for KhrPresentWaitFn {}
+impl KhrPresentWaitFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension249Fn {}
+        KhrPresentWaitFn {
+            wait_for_present_khr: unsafe {
+                unsafe extern "system" fn wait_for_present_khr(
+                    _device: Device,
+                    _swapchain: SwapchainKHR,
+                    _present_id: u64,
+                    _timeout: u64,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(wait_for_present_khr)))
                 }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    wait_for_present_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitForPresentKHR.html>"]
+    pub unsafe fn wait_for_present_khr(
+        &self,
+        device: Device,
+        swapchain: SwapchainKHR,
+        present_id: u64,
+        timeout: u64,
+    ) -> Result {
+        (self.wait_for_present_khr)(device, swapchain, present_id, timeout)
+    }
+}
+#[doc = "Generated from 'VK_KHR_present_wait'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000);
 }
 impl NvCooperativeMatrixFn {
     pub fn name() -> &'static ::std::ffi::CStr {
@@ -19929,25 +19971,29 @@ impl IntelExtension273Fn {
         IntelExtension273Fn {}
     }
 }
-impl IntelExtension274Fn {
+impl ExtShaderAtomicFloat2Fn {
     pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_274\0")
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_atomic_float2\0")
             .expect("Wrong extension string")
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct IntelExtension274Fn {}
+pub struct ExtShaderAtomicFloat2Fn {}
-unsafe impl Send for IntelExtension274Fn {}
+unsafe impl Send for ExtShaderAtomicFloat2Fn {}
-unsafe impl Sync for IntelExtension274Fn {}
+unsafe impl Sync for ExtShaderAtomicFloat2Fn {}
-impl IntelExtension274Fn {
+impl ExtShaderAtomicFloat2Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        IntelExtension274Fn {}
+        ExtShaderAtomicFloat2Fn {}
     }
 }
+#[doc = "Generated from 'VK_EXT_shader_atomic_float2'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000);
+}
 impl KhrExtension275Fn {
     pub fn name() -> &'static ::std::ffi::CStr {
         ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_275\0")
@@ -20898,25 +20944,33 @@ impl KhrShaderNonSemanticInfoFn {
         KhrShaderNonSemanticInfoFn {}
     }
 }
-impl KhrExtension295Fn {
+impl KhrPresentIdFn {
     pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_295\0")
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_id\0")
             .expect("Wrong extension string")
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct KhrExtension295Fn {}
+pub struct KhrPresentIdFn {}
-unsafe impl Send for KhrExtension295Fn {}
+unsafe impl Send for KhrPresentIdFn {}
-unsafe impl Sync for KhrExtension295Fn {}
+unsafe impl Sync for KhrPresentIdFn {}
-impl KhrExtension295Fn {
+impl KhrPresentIdFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension295Fn {}
+        KhrPresentIdFn {}
     }
 }
+#[doc = "Generated from 'VK_KHR_present_id'"]
+impl StructureType {
+    pub const PRESENT_ID_KHR: Self = Self(1_000_294_000);
+}
+#[doc = "Generated from 'VK_KHR_present_id'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001);
+}
 impl ExtPrivateDataFn {
     pub fn name() -> &'static ::std::ffi::CStr {
         ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_private_data\0")
@@ -22946,6 +23000,10 @@ impl ExtExtension340Fn {
         ExtExtension340Fn {}
     }
 }
+#[doc = "Generated from 'VK_EXT_extension_340'"]
+impl ImageUsageFlags {
+    pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000);
+}
 impl Ext4444FormatsFn {
     pub fn name() -> &'static ::std::ffi::CStr {
         ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_4444_formats\0")
@@ -24018,36 +24076,80 @@ impl PipelineStageFlags2KHR {
 impl ShaderStageFlags {
     pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000);
 }
-impl HuaweiExtension371Fn {
+impl HuaweiInvocationMaskFn {
     pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_371\0")
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_invocation_mask\0")
             .expect("Wrong extension string")
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    image_view: ImageView,
+    image_layout: ImageLayout,
+);
 #[derive(Clone)]
-pub struct HuaweiExtension371Fn {}
+pub struct HuaweiInvocationMaskFn {
-unsafe impl Send for HuaweiExtension371Fn {}
+    pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI,
-unsafe impl Sync for HuaweiExtension371Fn {}
+}
-impl HuaweiExtension371Fn {
+unsafe impl Send for HuaweiInvocationMaskFn {}
+unsafe impl Sync for HuaweiInvocationMaskFn {}
+impl HuaweiInvocationMaskFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        HuaweiExtension371Fn {}
+        HuaweiInvocationMaskFn {
+            cmd_bind_invocation_mask_huawei: unsafe {
+                unsafe extern "system" fn cmd_bind_invocation_mask_huawei(
+                    _command_buffer: CommandBuffer,
+                    _image_view: ImageView,
+                    _image_layout: ImageLayout,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_invocation_mask_huawei)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdBindInvocationMaskHUAWEI\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_invocation_mask_huawei
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindInvocationMaskHUAWEI.html>"]
+    pub unsafe fn cmd_bind_invocation_mask_huawei(
+        &self,
+        command_buffer: CommandBuffer,
+        image_view: ImageView,
+        image_layout: ImageLayout,
+    ) {
+        (self.cmd_bind_invocation_mask_huawei)(command_buffer, image_view, image_layout)
     }
 }
-#[doc = "Generated from 'VK_HUAWEI_extension_371'"]
+#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000);
+}
+#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
 impl AccessFlags2KHR {
-    pub const RESERVED_39_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const INVOCATION_MASK_READ_HUAWEI: Self =
+        Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
 }
-#[doc = "Generated from 'VK_HUAWEI_extension_371'"]
+#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
 impl ImageUsageFlags {
-    pub const RESERVED_18_HUAWEI: Self = Self(0b100_0000_0000_0000_0000);
+    pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000);
 }
-#[doc = "Generated from 'VK_HUAWEI_extension_371'"]
+#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
 impl PipelineStageFlags2KHR {
-    pub const RESERVED_40_HUAWEI: Self =
+    pub const INVOCATION_MASK_HUAWEI: Self =
         Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
 }
 impl NvExternalMemoryRdmaFn {
@@ -24060,7 +24162,7 @@ impl NvExternalMemoryRdmaFn {
 #[allow(non_camel_case_types)]
 pub type PFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(
     device: Device,
-    get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
+    p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
     p_address: *mut RemoteAddressNV,
 ) -> Result;
 #[derive(Clone)]
@@ -24078,7 +24180,7 @@ impl NvExternalMemoryRdmaFn {
             get_memory_remote_address_nv: unsafe {
                 unsafe extern "system" fn get_memory_remote_address_nv(
                     _device: Device,
-                    _get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
+                    _p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
                     _p_address: *mut RemoteAddressNV,
                 ) -> Result {
                     panic!(concat!(
@@ -24102,10 +24204,10 @@ impl NvExternalMemoryRdmaFn {
     pub unsafe fn get_memory_remote_address_nv(
         &self,
         device: Device,
-        get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
+        p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
         p_address: *mut RemoteAddressNV,
     ) -> Result {
-        (self.get_memory_remote_address_nv)(device, get_memory_remote_address_info, p_address)
+        (self.get_memory_remote_address_nv)(device, p_memory_get_remote_address_info, p_address)
     }
 }
 #[doc = "Generated from 'VK_NV_external_memory_rdma'"]
@@ -25498,3 +25600,22 @@ impl ExtExtension420Fn {
         ExtExtension420Fn {}
     }
 }
+impl KhrExtension421Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_421\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension421Fn {}
+unsafe impl Send for KhrExtension421Fn {}
+unsafe impl Sync for KhrExtension421Fn {}
+impl KhrExtension421Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        KhrExtension421Fn {}
+    }
+}

generator/Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 0193e158bc9f4d17e3c3a61c9311a0439ed5572d
+Subproject commit b8c57b0a09f7324fec5a7c363f5e26ff4d5a3222