Update Vulkan-Headers to 1.3.264

Changelog.md

@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added `Handle::is_null()` to allow checking if a handle is a `NULL` value (#694)
 - Allow building `Entry`/`Instance`/`Device` from handle+fns (see their `from_parts_1_x()` associated functions) (#748)
-- Update Vulkan-Headers to 1.3.263 (#760, #763, #783)
+- Update Vulkan-Headers to 1.3.264 (#760, #763, #783)
 - Added `VK_NV_memory_decompression` device extension (#761)
 - Added `VK_GOOGLE_display_timing` device extension (#765)
 - Added `VK_ANDROID_external_memory_android_hardware_buffer` device extension (#769)

ash/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ash"
-version = "0.37.0+1.3.263"
+version = "0.37.0+1.3.264"
 authors = [
     "Maik Klein <[email protected]>",
     "Benjamin Saunders <[email protected]>",

ash/src/vk/bitflags.rs

@@ -1169,6 +1169,14 @@ impl DeviceAddressBindingFlagsEXT {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFrameBoundaryFlagBitsEXT.html>"]
+pub struct FrameBoundaryFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(FrameBoundaryFlagsEXT, Flags);
+impl FrameBoundaryFlagsEXT {
+    pub const FRAME_END: Self = Self(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentScalingFlagBitsEXT.html>"]
 pub struct PresentScalingFlagsEXT(pub(crate) Flags);
 vk_bitflags_wrapped!(PresentScalingFlagsEXT, Flags);

ash/src/vk/const_debugs.rs

@@ -2355,6 +2355,12 @@ impl fmt::Debug for FragmentShadingRateTypeNV {
         }
     }
 }
+impl fmt::Debug for FrameBoundaryFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[(FrameBoundaryFlagsEXT::FRAME_END.0, "FRAME_END")];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for FramebufferCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[(FramebufferCreateFlags::IMAGELESS.0, "IMAGELESS")];
@@ -2959,6 +2965,20 @@ impl fmt::Debug for InternalAllocationType {
         }
     }
 }
+impl fmt::Debug for LayeredDriverUnderlyingApiMSFT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::NONE => Some("NONE"),
+            Self::D3D12 => Some("D3D12"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for LineRasterizationModeEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -6036,6 +6056,10 @@ impl fmt::Debug for StructureType {
             Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT")
             }
+            Self::PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT")
+            }
+            Self::FRAME_BOUNDARY_EXT => Some("FRAME_BOUNDARY_EXT"),
             Self::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT")
             }
@@ -6355,6 +6379,9 @@ impl fmt::Debug for StructureType {
             Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX => {
                 Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX")
             }
+            Self::PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT => {
+                Some("PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT")
+            }
             Self::PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV")
             }

ash/src/vk/definitions.rs

@@ -58,7 +58,7 @@ pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0);
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_3.html>"]
 pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0);
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION.html>"]
-pub const HEADER_VERSION: u32 = 263;
+pub const HEADER_VERSION: u32 = 264;
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
 pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION);
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleMask.html>"]
@@ -48675,6 +48675,123 @@ impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> {
 #[repr(C)]
 #[cfg_attr(feature = "debug", derive(Debug))]
 #[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFrameBoundaryEXT.html>"]
+pub struct FrameBoundaryEXT<'a> {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub flags: FrameBoundaryFlagsEXT,
+    pub frame_id: u64,
+    pub image_count: u32,
+    pub p_images: *const Image,
+    pub buffer_count: u32,
+    pub p_buffers: *const Buffer,
+    pub tag_name: u64,
+    pub tag_size: usize,
+    pub p_tag: *const c_void,
+    pub _marker: PhantomData<&'a ()>,
+}
+impl ::std::default::Default for FrameBoundaryEXT<'_> {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            flags: FrameBoundaryFlagsEXT::default(),
+            frame_id: u64::default(),
+            image_count: u32::default(),
+            p_images: ::std::ptr::null(),
+            buffer_count: u32::default(),
+            p_buffers: ::std::ptr::null(),
+            tag_name: u64::default(),
+            tag_size: usize::default(),
+            p_tag: ::std::ptr::null(),
+            _marker: PhantomData,
+        }
+    }
+}
+unsafe impl<'a> TaggedStructure for FrameBoundaryEXT<'a> {
+    const STRUCTURE_TYPE: StructureType = StructureType::FRAME_BOUNDARY_EXT;
+}
+unsafe impl ExtendsSubmitInfo for FrameBoundaryEXT<'_> {}
+unsafe impl ExtendsSubmitInfo2 for FrameBoundaryEXT<'_> {}
+unsafe impl ExtendsPresentInfoKHR for FrameBoundaryEXT<'_> {}
+unsafe impl ExtendsBindSparseInfo for FrameBoundaryEXT<'_> {}
+impl<'a> FrameBoundaryEXT<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: FrameBoundaryFlagsEXT) -> Self {
+        self.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn frame_id(mut self, frame_id: u64) -> Self {
+        self.frame_id = frame_id;
+        self
+    }
+    #[inline]
+    pub fn images(mut self, images: &'a [Image]) -> Self {
+        self.image_count = images.len() as _;
+        self.p_images = images.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn buffers(mut self, buffers: &'a [Buffer]) -> Self {
+        self.buffer_count = buffers.len() as _;
+        self.p_buffers = buffers.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn tag_name(mut self, tag_name: u64) -> Self {
+        self.tag_name = tag_name;
+        self
+    }
+    #[inline]
+    pub fn tag_size(mut self, tag_size: usize) -> Self {
+        self.tag_size = tag_size;
+        self
+    }
+    #[inline]
+    pub fn tag(mut self, tag: *const c_void) -> Self {
+        self.p_tag = tag;
+        self
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFrameBoundaryFeaturesEXT.html>"]
+pub struct PhysicalDeviceFrameBoundaryFeaturesEXT<'a> {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub frame_boundary: Bool32,
+    pub _marker: PhantomData<&'a ()>,
+}
+impl ::std::default::Default for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            frame_boundary: Bool32::default(),
+            _marker: PhantomData,
+        }
+    }
+}
+unsafe impl<'a> TaggedStructure for PhysicalDeviceFrameBoundaryFeaturesEXT<'a> {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {}
+impl<'a> PhysicalDeviceFrameBoundaryFeaturesEXT<'a> {
+    #[inline]
+    pub fn frame_boundary(mut self, frame_boundary: bool) -> Self {
+        self.frame_boundary = frame_boundary.into();
+        self
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.html>"]
 pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> {
     pub s_type: StructureType,
@@ -51082,3 +51199,36 @@ impl<'a> PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> {
         self
     }
 }
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLayeredDriverPropertiesMSFT.html>"]
+pub struct PhysicalDeviceLayeredDriverPropertiesMSFT<'a> {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub underlying_api: LayeredDriverUnderlyingApiMSFT,
+    pub _marker: PhantomData<&'a ()>,
+}
+impl ::std::default::Default for PhysicalDeviceLayeredDriverPropertiesMSFT<'_> {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            underlying_api: LayeredDriverUnderlyingApiMSFT::default(),
+            _marker: PhantomData,
+        }
+    }
+}
+unsafe impl<'a> TaggedStructure for PhysicalDeviceLayeredDriverPropertiesMSFT<'a> {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT;
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLayeredDriverPropertiesMSFT<'_> {}
+impl<'a> PhysicalDeviceLayeredDriverPropertiesMSFT<'a> {
+    #[inline]
+    pub fn underlying_api(mut self, underlying_api: LayeredDriverUnderlyingApiMSFT) -> Self {
+        self.underlying_api = underlying_api;
+        self
+    }
+}

ash/src/vk/enums.rs

@@ -2840,6 +2840,24 @@ impl BlockMatchWindowCompareModeQCOM {
     pub const MIN: Self = Self(0);
     pub const MAX: Self = Self(1);
 }
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLayeredDriverUnderlyingApiMSFT.html>"]
+pub struct LayeredDriverUnderlyingApiMSFT(pub(crate) i32);
+impl LayeredDriverUnderlyingApiMSFT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl LayeredDriverUnderlyingApiMSFT {
+    pub const NONE: Self = Self(0);
+    pub const D3D12: Self = Self(1);
+}
 impl fmt::Debug for ObjectType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {

ash/src/vk/extensions.rs

@@ -16700,6 +16700,18 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1_000_372_001);
     pub const PIPELINE_INFO_EXT: Self = Self::PIPELINE_INFO_KHR;
 }
+impl ExtFrameBoundaryFn {
+    pub const NAME: &'static ::std::ffi::CStr =
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_frame_boundary\0") };
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtFrameBoundaryFn;
+#[doc = "Generated from 'VK_EXT_frame_boundary'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: Self = Self(1_000_375_000);
+    pub const FRAME_BOUNDARY_EXT: Self = Self(1_000_375_001);
+}
 impl ExtMultisampledRenderToSingleSampledFn {
     pub const NAME: &'static ::std::ffi::CStr = unsafe {
         ::std::ffi::CStr::from_bytes_with_nul_unchecked(
@@ -21641,6 +21653,17 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: Self =
         Self(1_000_529_004);
 }
+impl MsftLayeredDriverFn {
+    pub const NAME: &'static ::std::ffi::CStr =
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MSFT_layered_driver\0") };
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct MsftLayeredDriverFn;
+#[doc = "Generated from 'VK_MSFT_layered_driver'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: Self = Self(1_000_530_000);
+}
 impl NvDescriptorPoolOverallocationFn {
     pub const NAME: &'static ::std::ffi::CStr = unsafe {
         ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_descriptor_pool_overallocation\0")