Update Vulkan-Headers to 1.3.254 (#760)

* Update Vulkan-Headers to 1.3.252

* Update Vulkan-Headers to 1.3.253

* Update Vulkan-Headers to 1.3.254

* vk/platform_types: Add `_screen_buffer` type for QNX

Changelog.md

@@ -11,6 +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.254 (#760)
 
 ### Changed
 

ash/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ash"
-version = "0.37.0+1.3.251"
+version = "0.37.0+1.3.254"
 authors = [
     "Maik Klein <maikklein@googlemail.com>",
     "Benjamin Saunders <ben.e.saunders@gmail.com>",

ash/src/vk/bitflags.rs

@@ -1286,6 +1286,7 @@ vk_bitflags_wrapped!(VideoEncodeFeedbackFlagsKHR, Flags);
 impl VideoEncodeFeedbackFlagsKHR {
     pub const BITSTREAM_BUFFER_OFFSET: Self = Self(0b1);
     pub const BITSTREAM_BYTES_WRITTEN: Self = Self(0b10);
+    pub const BITSTREAM_HAS_OVERRIDES: Self = Self(0b100);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -1304,32 +1305,52 @@ impl VideoEncodeRateControlModeFlagsKHR {
 pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags);
 impl VideoEncodeH264CapabilityFlagsEXT {
-    pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1);
+    pub const HRD_COMPLIANCE: Self = Self(0b1);
-    pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10);
+    pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(0b10);
-    pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100);
+    pub const ROW_UNALIGNED_SLICE: Self = Self(0b100);
-    pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000);
+    pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000);
-    pub const SCALING_LISTS: Self = Self(0b1_0000);
+    pub const B_FRAME_IN_L0_LIST: Self = Self(0b1_0000);
-    pub const HRD_COMPLIANCE: Self = Self(0b10_0000);
+    pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000);
-    pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000);
+    pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(0b100_0000);
-    pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000);
+    pub const PER_SLICE_CONSTANT_QP: Self = Self(0b1000_0000);
-    pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000);
+    pub const GENERATE_PREFIX_NALU: Self = Self(0b1_0000_0000);
-    pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000);
+}
-    pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000);
+#[repr(transparent)]
-    pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000);
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264StdFlagBitsEXT.html>"]
-    pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000);
+pub struct VideoEncodeH264StdFlagsEXT(pub(crate) Flags);
-    pub const CABAC: Self = Self(0b100_0000_0000_0000);
+vk_bitflags_wrapped!(VideoEncodeH264StdFlagsEXT, Flags);
-    pub const CAVLC: Self = Self(0b1000_0000_0000_0000);
+impl VideoEncodeH264StdFlagsEXT {
-    pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000);
+    pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(0b1);
-    pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000);
+    pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET: Self = Self(0b10);
-    pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000);
+    pub const SCALING_MATRIX_PRESENT_FLAG_SET: Self = Self(0b100);
-    pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const CHROMA_QP_INDEX_OFFSET: Self = Self(0b1000);
-    pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000);
+    pub const SECOND_CHROMA_QP_INDEX_OFFSET: Self = Self(0b1_0000);
-    pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const PIC_INIT_QP_MINUS26: Self = Self(0b10_0000);
-    pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const WEIGHTED_PRED_FLAG_SET: Self = Self(0b100_0000);
-    pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const WEIGHTED_BIPRED_IDC_EXPLICIT: Self = Self(0b1000_0000);
-    pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+    pub const WEIGHTED_BIPRED_IDC_IMPLICIT: Self = Self(0b1_0000_0000);
-    pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+    pub const TRANSFORM_8X8_MODE_FLAG_SET: Self = Self(0b10_0000_0000);
+    pub const DIRECT_SPATIAL_MV_PRED_FLAG_UNSET: Self = Self(0b100_0000_0000);
+    pub const ENTROPY_CODING_MODE_FLAG_UNSET: Self = Self(0b1000_0000_0000);
+    pub const ENTROPY_CODING_MODE_FLAG_SET: Self = Self(0b1_0000_0000_0000);
+    pub const DIRECT_8X8_INFERENCE_FLAG_UNSET: Self = Self(0b10_0000_0000_0000);
+    pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(0b100_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1000_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b1_0000_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b10_0000_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlFlagBitsEXT.html>"]
+pub struct VideoEncodeH264RateControlFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeH264RateControlFlagsEXT, Flags);
+impl VideoEncodeH264RateControlFlagsEXT {
+    pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(0b1);
+    pub const REGULAR_GOP: Self = Self(0b10);
+    pub const REFERENCE_PATTERN_FLAT: Self = Self(0b100);
+    pub const REFERENCE_PATTERN_DYADIC: Self = Self(0b1000);
+    pub const TEMPORAL_LAYER_PATTERN_DYADIC: Self = Self(0b1_0000);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -1439,33 +1460,54 @@ impl RenderingFlags {
 pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags);
 impl VideoEncodeH265CapabilityFlagsEXT {
-    pub const SEPARATE_COLOUR_PLANE: Self = Self(0b1);
+    pub const HRD_COMPLIANCE: Self = Self(0b1);
-    pub const SCALING_LISTS: Self = Self(0b10);
+    pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(0b10);
-    pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED: Self = Self(0b100);
+    pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100);
-    pub const PCM_ENABLE: Self = Self(0b1000);
+    pub const DIFFERENT_SLICE_SEGMENT_TYPE: Self = Self(0b1000);
-    pub const SPS_TEMPORAL_MVP_ENABLED: Self = Self(0b1_0000);
+    pub const B_FRAME_IN_L0_LIST: Self = Self(0b1_0000);
-    pub const HRD_COMPLIANCE: Self = Self(0b10_0000);
+    pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000);
-    pub const INIT_QP_MINUS26: Self = Self(0b100_0000);
+    pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(0b100_0000);
-    pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1000_0000);
+    pub const PER_SLICE_SEGMENT_CONSTANT_QP: Self = Self(0b1000_0000);
-    pub const SIGN_DATA_HIDING_ENABLED: Self = Self(0b1_0000_0000);
+    pub const MULTIPLE_TILES_PER_SLICE_SEGMENT: Self = Self(0b1_0000_0000);
-    pub const TRANSFORM_SKIP_ENABLED: Self = Self(0b10_0000_0000);
+    pub const MULTIPLE_SLICE_SEGMENTS_PER_TILE: Self = Self(0b10_0000_0000);
-    pub const TRANSFORM_SKIP_DISABLED: Self = Self(0b100_0000_0000);
+}
-    pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT: Self = Self(0b1000_0000_0000);
+#[repr(transparent)]
-    pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000_0000);
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub const WEIGHTED_BIPRED: Self = Self(0b10_0000_0000_0000);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265StdFlagBitsEXT.html>"]
-    pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b100_0000_0000_0000);
+pub struct VideoEncodeH265StdFlagsEXT(pub(crate) Flags);
-    pub const TRANSQUANT_BYPASS_ENABLED: Self = Self(0b1000_0000_0000_0000);
+vk_bitflags_wrapped!(VideoEncodeH265StdFlagsEXT, Flags);
-    pub const ENTROPY_CODING_SYNC_ENABLED: Self = Self(0b1_0000_0000_0000_0000);
+impl VideoEncodeH265StdFlagsEXT {
-    pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED: Self = Self(0b10_0000_0000_0000_0000);
+    pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(0b1);
-    pub const MULTIPLE_TILE_PER_FRAME: Self = Self(0b100_0000_0000_0000_0000);
+    pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET: Self = Self(0b10);
-    pub const MULTIPLE_SLICE_PER_TILE: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const SCALING_LIST_DATA_PRESENT_FLAG_SET: Self = Self(0b100);
-    pub const MULTIPLE_TILE_PER_SLICE: Self = Self(0b1_0000_0000_0000_0000_0000);
+    pub const PCM_ENABLED_FLAG_SET: Self = Self(0b1000);
-    pub const SLICE_SEGMENT_CTB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const SPS_TEMPORAL_MVP_ENABLED_FLAG_SET: Self = Self(0b1_0000);
-    pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const INIT_QP_MINUS26: Self = Self(0b10_0000);
-    pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const WEIGHTED_PRED_FLAG_SET: Self = Self(0b100_0000);
-    pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+    pub const WEIGHTED_BIPRED_FLAG_SET: Self = Self(0b1000_0000);
-    pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+    pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1_0000_0000);
-    pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
+    pub const SIGN_DATA_HIDING_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000);
+    pub const TRANSFORM_SKIP_ENABLED_FLAG_SET: Self = Self(0b100_0000_0000);
+    pub const TRANSFORM_SKIP_ENABLED_FLAG_UNSET: Self = Self(0b1000_0000_0000);
+    pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET: Self = Self(0b1_0000_0000_0000);
+    pub const TRANSQUANT_BYPASS_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000_0000);
+    pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(0b100_0000_0000_0000);
+    pub const ENTROPY_CODING_SYNC_ENABLED_FLAG_SET: Self = Self(0b1000_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET: Self = Self(0b1_0000_0000_0000_0000);
+    pub const DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000_0000_0000);
+    pub const DEPENDENT_SLICE_SEGMENT_FLAG_SET: Self = Self(0b100_0000_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlFlagBitsEXT.html>"]
+pub struct VideoEncodeH265RateControlFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeH265RateControlFlagsEXT, Flags);
+impl VideoEncodeH265RateControlFlagsEXT {
+    pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(0b1);
+    pub const REGULAR_GOP: Self = Self(0b10);
+    pub const REFERENCE_PATTERN_FLAT: Self = Self(0b100);
+    pub const REFERENCE_PATTERN_DYADIC: Self = Self(0b1000);
+    pub const TEMPORAL_SUB_LAYER_PATTERN_DYADIC: Self = Self(0b1_0000);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]

ash/src/vk/const_debugs.rs

@@ -1129,6 +1129,23 @@ impl fmt::Debug for DependencyFlags {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for DepthBiasRepresentationEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::LEAST_REPRESENTABLE_VALUE_FORMAT => Some("LEAST_REPRESENTABLE_VALUE_FORMAT"),
+            Self::LEAST_REPRESENTABLE_VALUE_FORCE_UNORM => {
+                Some("LEAST_REPRESENTABLE_VALUE_FORCE_UNORM")
+            }
+            Self::FLOAT => Some("FLOAT"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for DescriptorBindingFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
@@ -1761,6 +1778,10 @@ impl fmt::Debug for ExternalMemoryHandleTypeFlags {
                 ExternalMemoryHandleTypeFlags::RDMA_ADDRESS_NV.0,
                 "RDMA_ADDRESS_NV",
             ),
+            (
+                ExternalMemoryHandleTypeFlags::SCREEN_BUFFER_QNX.0,
+                "SCREEN_BUFFER_QNX",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -4723,15 +4744,16 @@ impl fmt::Debug for StructureType {
             Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => {
                 Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT")
             }
-            Self::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT => {
+            Self::VIDEO_ENCODE_H264_PICTURE_INFO_EXT => Some("VIDEO_ENCODE_H264_PICTURE_INFO_EXT"),
-                Some("VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT")
-            }
             Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => {
                 Some("VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT")
             }
             Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => {
                 Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT")
             }
+            Self::VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT")
+            }
             Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"),
             Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => {
                 Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT")
@@ -4739,6 +4761,18 @@ impl fmt::Debug for StructureType {
             Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => {
                 Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT")
             }
+            Self::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT => {
+                Some("VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT")
+            }
+            Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT")
+            }
             Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"),
             Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => {
                 Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT")
@@ -4746,15 +4780,16 @@ impl fmt::Debug for StructureType {
             Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => {
                 Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT")
             }
-            Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => {
+            Self::VIDEO_ENCODE_H265_PICTURE_INFO_EXT => Some("VIDEO_ENCODE_H265_PICTURE_INFO_EXT"),
-                Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT")
-            }
             Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => {
                 Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT")
             }
             Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => {
                 Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT")
             }
+            Self::VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT")
+            }
             Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"),
             Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => {
                 Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT")
@@ -4762,6 +4797,18 @@ impl fmt::Debug for StructureType {
             Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => {
                 Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT")
             }
+            Self::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT => {
+                Some("VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT")
+            }
             Self::VIDEO_DECODE_H264_CAPABILITIES_KHR => Some("VIDEO_DECODE_H264_CAPABILITIES_KHR"),
             Self::VIDEO_DECODE_H264_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H264_PICTURE_INFO_KHR"),
             Self::VIDEO_DECODE_H264_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H264_PROFILE_INFO_KHR"),
@@ -5408,6 +5455,11 @@ impl fmt::Debug for StructureType {
             Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => {
                 Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM")
             }
+            Self::PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT")
+            }
+            Self::DEPTH_BIAS_INFO_EXT => Some("DEPTH_BIAS_INFO_EXT"),
+            Self::DEPTH_BIAS_REPRESENTATION_INFO_EXT => Some("DEPTH_BIAS_REPRESENTATION_INFO_EXT"),
             Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT")
             }
@@ -5456,6 +5508,21 @@ impl fmt::Debug for StructureType {
             Self::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR => {
                 Some("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR")
             }
+            Self::PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR => {
+                Some("PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR")
+            }
+            Self::VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR => {
+                Some("VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR")
+            }
+            Self::VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR => {
+                Some("VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR")
+            }
+            Self::VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR => {
+                Some("VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR")
+            }
+            Self::VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR => {
+                Some("VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR")
+            }
             Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV")
             }
@@ -5820,6 +5887,9 @@ impl fmt::Debug for StructureType {
             Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => {
                 Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM")
             }
+            Self::EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT => {
+                Some("EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT")
+            }
             Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT")
             }
@@ -5928,6 +5998,15 @@ impl fmt::Debug for StructureType {
             Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT")
             }
+            Self::SCREEN_BUFFER_PROPERTIES_QNX => Some("SCREEN_BUFFER_PROPERTIES_QNX"),
+            Self::SCREEN_BUFFER_FORMAT_PROPERTIES_QNX => {
+                Some("SCREEN_BUFFER_FORMAT_PROPERTIES_QNX")
+            }
+            Self::IMPORT_SCREEN_BUFFER_INFO_QNX => Some("IMPORT_SCREEN_BUFFER_INFO_QNX"),
+            Self::EXTERNAL_FORMAT_QNX => Some("EXTERNAL_FORMAT_QNX"),
+            Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX => {
+                Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX")
+            }
             Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => {
                 Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES")
             }
@@ -6672,8 +6751,8 @@ impl fmt::Debug for VideoCodingControlFlagsKHR {
                 "ENCODE_RATE_CONTROL",
             ),
             (
-                VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL_LAYER.0,
+                VideoCodingControlFlagsKHR::ENCODE_QUALITY_LEVEL.0,
-                "ENCODE_RATE_CONTROL_LAYER",
+                "ENCODE_QUALITY_LEVEL",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
@@ -6772,6 +6851,10 @@ impl fmt::Debug for VideoEncodeFeedbackFlagsKHR {
                 VideoEncodeFeedbackFlagsKHR::BITSTREAM_BYTES_WRITTEN.0,
                 "BITSTREAM_BYTES_WRITTEN",
             ),
+            (
+                VideoEncodeFeedbackFlagsKHR::BITSTREAM_HAS_OVERRIDES.0,
+                "BITSTREAM_HAS_OVERRIDES",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -6785,87 +6868,13 @@ impl fmt::Debug for VideoEncodeFlagsKHR {
 impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (
-                VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0,
-                "DIRECT_8X8_INFERENCE_ENABLED",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0,
-                "DIRECT_8X8_INFERENCE_DISABLED",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
-                "SEPARATE_COLOUR_PLANE",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS.0,
-                "QPPRIME_Y_ZERO_TRANSFORM_BYPASS",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::SCALING_LISTS.0,
-                "SCALING_LISTS",
-            ),
             (
                 VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0,
                 "HRD_COMPLIANCE",
             ),
             (
-                VideoEncodeH264CapabilityFlagsEXT::CHROMA_QP_OFFSET.0,
+                VideoEncodeH264CapabilityFlagsEXT::PREDICTION_WEIGHT_TABLE_GENERATED.0,
-                "CHROMA_QP_OFFSET",
+                "PREDICTION_WEIGHT_TABLE_GENERATED",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::SECOND_CHROMA_QP_OFFSET.0,
-                "SECOND_CHROMA_QP_OFFSET",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::PIC_INIT_QP_MINUS26.0,
-                "PIC_INIT_QP_MINUS26",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED.0,
-                "WEIGHTED_PRED",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_EXPLICIT.0,
-                "WEIGHTED_BIPRED_EXPLICIT",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_IMPLICIT.0,
-                "WEIGHTED_BIPRED_IMPLICIT",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
-                "WEIGHTED_PRED_NO_TABLE",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0,
-                "TRANSFORM_8X8",
-            ),
-            (VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"),
-            (VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_DISABLED.0,
-                "DEBLOCKING_FILTER_DISABLED",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_ENABLED.0,
-                "DEBLOCKING_FILTER_ENABLED",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0,
-                "DEBLOCKING_FILTER_PARTIAL",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::DISABLE_DIRECT_SPATIAL_MV_PRED.0,
-                "DISABLE_DIRECT_SPATIAL_MV_PRED",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::MULTIPLE_SLICE_PER_FRAME.0,
-                "MULTIPLE_SLICE_PER_FRAME",
-            ),
-            (
-                VideoEncodeH264CapabilityFlagsEXT::SLICE_MB_COUNT.0,
-                "SLICE_MB_COUNT",
             ),
             (
                 VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0,
@@ -6875,143 +6884,178 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
                 VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
                 "DIFFERENT_SLICE_TYPE",
             ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L0_LIST.0,
+                "B_FRAME_IN_L0_LIST",
+            ),
             (
                 VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
                 "B_FRAME_IN_L1_LIST",
             ),
             (
-                VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
+                VideoEncodeH264CapabilityFlagsEXT::PER_PICTURE_TYPE_MIN_MAX_QP.0,
-                "DIFFERENT_REFERENCE_FINAL_LISTS",
+                "PER_PICTURE_TYPE_MIN_MAX_QP",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::PER_SLICE_CONSTANT_QP.0,
+                "PER_SLICE_CONSTANT_QP",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::GENERATE_PREFIX_NALU.0,
+                "GENERATE_PREFIX_NALU",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoEncodeH264RateControlStructureEXT {
+impl fmt::Debug for VideoEncodeH264RateControlFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let name = match *self {
+        const KNOWN: &[(Flags, &str)] = &[
-            Self::UNKNOWN => Some("UNKNOWN"),
+            (
-            Self::FLAT => Some("FLAT"),
+                VideoEncodeH264RateControlFlagsEXT::ATTEMPT_HRD_COMPLIANCE.0,
-            Self::DYADIC => Some("DYADIC"),
+                "ATTEMPT_HRD_COMPLIANCE",
-            _ => None,
+            ),
-        };
+            (
-        if let Some(x) = name {
+                VideoEncodeH264RateControlFlagsEXT::REGULAR_GOP.0,
-            f.write_str(x)
+                "REGULAR_GOP",
-        } else {
+            ),
-            self.0.fmt(f)
+            (
+                VideoEncodeH264RateControlFlagsEXT::REFERENCE_PATTERN_FLAT.0,
+                "REFERENCE_PATTERN_FLAT",
+            ),
+            (
+                VideoEncodeH264RateControlFlagsEXT::REFERENCE_PATTERN_DYADIC.0,
+                "REFERENCE_PATTERN_DYADIC",
+            ),
+            (
+                VideoEncodeH264RateControlFlagsEXT::TEMPORAL_LAYER_PATTERN_DYADIC.0,
+                "TEMPORAL_LAYER_PATTERN_DYADIC",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
     }
+}
+impl fmt::Debug for VideoEncodeH264StdFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                VideoEncodeH264StdFlagsEXT::SEPARATE_COLOR_PLANE_FLAG_SET.0,
+                "SEPARATE_COLOR_PLANE_FLAG_SET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET.0,
+                "QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::SCALING_MATRIX_PRESENT_FLAG_SET.0,
+                "SCALING_MATRIX_PRESENT_FLAG_SET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::CHROMA_QP_INDEX_OFFSET.0,
+                "CHROMA_QP_INDEX_OFFSET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::SECOND_CHROMA_QP_INDEX_OFFSET.0,
+                "SECOND_CHROMA_QP_INDEX_OFFSET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::PIC_INIT_QP_MINUS26.0,
+                "PIC_INIT_QP_MINUS26",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::WEIGHTED_PRED_FLAG_SET.0,
+                "WEIGHTED_PRED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::WEIGHTED_BIPRED_IDC_EXPLICIT.0,
+                "WEIGHTED_BIPRED_IDC_EXPLICIT",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::WEIGHTED_BIPRED_IDC_IMPLICIT.0,
+                "WEIGHTED_BIPRED_IDC_IMPLICIT",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::TRANSFORM_8X8_MODE_FLAG_SET.0,
+                "TRANSFORM_8X8_MODE_FLAG_SET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::DIRECT_SPATIAL_MV_PRED_FLAG_UNSET.0,
+                "DIRECT_SPATIAL_MV_PRED_FLAG_UNSET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::ENTROPY_CODING_MODE_FLAG_UNSET.0,
+                "ENTROPY_CODING_MODE_FLAG_UNSET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::ENTROPY_CODING_MODE_FLAG_SET.0,
+                "ENTROPY_CODING_MODE_FLAG_SET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::DIRECT_8X8_INFERENCE_FLAG_UNSET.0,
+                "DIRECT_8X8_INFERENCE_FLAG_UNSET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::CONSTRAINED_INTRA_PRED_FLAG_SET.0,
+                "CONSTRAINED_INTRA_PRED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_DISABLED.0,
+                "DEBLOCKING_FILTER_DISABLED",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_ENABLED.0,
+                "DEBLOCKING_FILTER_ENABLED",
+            ),
+            (
+                VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0,
+                "DEBLOCKING_FILTER_PARTIAL",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
     }
 }
 impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (
-                VideoEncodeH265CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
-                "SEPARATE_COLOUR_PLANE",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::SCALING_LISTS.0,
-                "SCALING_LISTS",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED.0,
-                "SAMPLE_ADAPTIVE_OFFSET_ENABLED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::PCM_ENABLE.0,
-                "PCM_ENABLE",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::SPS_TEMPORAL_MVP_ENABLED.0,
-                "SPS_TEMPORAL_MVP_ENABLED",
-            ),
             (
                 VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0,
                 "HRD_COMPLIANCE",
             ),
             (
-                VideoEncodeH265CapabilityFlagsEXT::INIT_QP_MINUS26.0,
+                VideoEncodeH265CapabilityFlagsEXT::PREDICTION_WEIGHT_TABLE_GENERATED.0,
-                "INIT_QP_MINUS26",
+                "PREDICTION_WEIGHT_TABLE_GENERATED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0,
-                "LOG2_PARALLEL_MERGE_LEVEL_MINUS2",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::SIGN_DATA_HIDING_ENABLED.0,
-                "SIGN_DATA_HIDING_ENABLED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_ENABLED.0,
-                "TRANSFORM_SKIP_ENABLED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_DISABLED.0,
-                "TRANSFORM_SKIP_DISABLED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT.0,
-                "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED.0,
-                "WEIGHTED_PRED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_BIPRED.0,
-                "WEIGHTED_BIPRED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
-                "WEIGHTED_PRED_NO_TABLE",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::TRANSQUANT_BYPASS_ENABLED.0,
-                "TRANSQUANT_BYPASS_ENABLED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::ENTROPY_CODING_SYNC_ENABLED.0,
-                "ENTROPY_CODING_SYNC_ENABLED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED.0,
-                "DEBLOCKING_FILTER_OVERRIDE_ENABLED",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_FRAME.0,
-                "MULTIPLE_TILE_PER_FRAME",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_PER_TILE.0,
-                "MULTIPLE_SLICE_PER_TILE",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_SLICE.0,
-                "MULTIPLE_TILE_PER_SLICE",
-            ),
-            (
-                VideoEncodeH265CapabilityFlagsEXT::SLICE_SEGMENT_CTB_COUNT.0,
-                "SLICE_SEGMENT_CTB_COUNT",
             ),
             (
                 VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0,
                 "ROW_UNALIGNED_SLICE_SEGMENT",
             ),
             (
-                VideoEncodeH265CapabilityFlagsEXT::DEPENDENT_SLICE_SEGMENT.0,
+                VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_SEGMENT_TYPE.0,
-                "DEPENDENT_SLICE_SEGMENT",
+                "DIFFERENT_SLICE_SEGMENT_TYPE",
             ),
             (
-                VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
+                VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L0_LIST.0,
-                "DIFFERENT_SLICE_TYPE",
+                "B_FRAME_IN_L0_LIST",
             ),
             (
                 VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
                 "B_FRAME_IN_L1_LIST",
             ),
             (
-                VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
+                VideoEncodeH265CapabilityFlagsEXT::PER_PICTURE_TYPE_MIN_MAX_QP.0,
-                "DIFFERENT_REFERENCE_FINAL_LISTS",
+                "PER_PICTURE_TYPE_MIN_MAX_QP",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::PER_SLICE_SEGMENT_CONSTANT_QP.0,
+                "PER_SLICE_SEGMENT_CONSTANT_QP",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILES_PER_SLICE_SEGMENT.0,
+                "MULTIPLE_TILES_PER_SLICE_SEGMENT",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_SEGMENTS_PER_TILE.0,
+                "MULTIPLE_SLICE_SEGMENTS_PER_TILE",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
@@ -7027,19 +7071,114 @@ impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT {
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoEncodeH265RateControlStructureEXT {
+impl fmt::Debug for VideoEncodeH265RateControlFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let name = match *self {
+        const KNOWN: &[(Flags, &str)] = &[
-            Self::UNKNOWN => Some("UNKNOWN"),
+            (
-            Self::FLAT => Some("FLAT"),
+                VideoEncodeH265RateControlFlagsEXT::ATTEMPT_HRD_COMPLIANCE.0,
-            Self::DYADIC => Some("DYADIC"),
+                "ATTEMPT_HRD_COMPLIANCE",
-            _ => None,
+            ),
-        };
+            (
-        if let Some(x) = name {
+                VideoEncodeH265RateControlFlagsEXT::REGULAR_GOP.0,
-            f.write_str(x)
+                "REGULAR_GOP",
-        } else {
+            ),
-            self.0.fmt(f)
+            (
+                VideoEncodeH265RateControlFlagsEXT::REFERENCE_PATTERN_FLAT.0,
+                "REFERENCE_PATTERN_FLAT",
+            ),
+            (
+                VideoEncodeH265RateControlFlagsEXT::REFERENCE_PATTERN_DYADIC.0,
+                "REFERENCE_PATTERN_DYADIC",
+            ),
+            (
+                VideoEncodeH265RateControlFlagsEXT::TEMPORAL_SUB_LAYER_PATTERN_DYADIC.0,
+                "TEMPORAL_SUB_LAYER_PATTERN_DYADIC",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
     }
+}
+impl fmt::Debug for VideoEncodeH265StdFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                VideoEncodeH265StdFlagsEXT::SEPARATE_COLOR_PLANE_FLAG_SET.0,
+                "SEPARATE_COLOR_PLANE_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET.0,
+                "SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::SCALING_LIST_DATA_PRESENT_FLAG_SET.0,
+                "SCALING_LIST_DATA_PRESENT_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::PCM_ENABLED_FLAG_SET.0,
+                "PCM_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET.0,
+                "SPS_TEMPORAL_MVP_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::INIT_QP_MINUS26.0,
+                "INIT_QP_MINUS26",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::WEIGHTED_PRED_FLAG_SET.0,
+                "WEIGHTED_PRED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::WEIGHTED_BIPRED_FLAG_SET.0,
+                "WEIGHTED_BIPRED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0,
+                "LOG2_PARALLEL_MERGE_LEVEL_MINUS2",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::SIGN_DATA_HIDING_ENABLED_FLAG_SET.0,
+                "SIGN_DATA_HIDING_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::TRANSFORM_SKIP_ENABLED_FLAG_SET.0,
+                "TRANSFORM_SKIP_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::TRANSFORM_SKIP_ENABLED_FLAG_UNSET.0,
+                "TRANSFORM_SKIP_ENABLED_FLAG_UNSET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET.0,
+                "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::TRANSQUANT_BYPASS_ENABLED_FLAG_SET.0,
+                "TRANSQUANT_BYPASS_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::CONSTRAINED_INTRA_PRED_FLAG_SET.0,
+                "CONSTRAINED_INTRA_PRED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET.0,
+                "ENTROPY_CODING_SYNC_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET.0,
+                "DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET.0,
+                "DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET",
+            ),
+            (
+                VideoEncodeH265StdFlagsEXT::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0,
+                "DEPENDENT_SLICE_SEGMENT_FLAG_SET",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
     }
 }
 impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsEXT {
@@ -7119,10 +7258,16 @@ impl fmt::Debug for VideoEndCodingFlagsKHR {
 }
 impl fmt::Debug for VideoSessionCreateFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[(
+        const KNOWN: &[(Flags, &str)] = &[
+            (
                 VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0,
                 "PROTECTED_CONTENT",
-        )];
+            ),
+            (
+                VideoSessionCreateFlagsKHR::ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS.0,
+                "ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS",
+            ),
+        ];
         debug_flags(f, KNOWN, self.0)
     }
 }

ash/src/vk/enums.rs

@@ -2530,44 +2530,6 @@ impl VideoEncodeTuningModeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlStructureEXT.html>"]
-pub struct VideoEncodeH264RateControlStructureEXT(pub(crate) i32);
-impl VideoEncodeH264RateControlStructureEXT {
-    #[inline]
-    pub const fn from_raw(x: i32) -> Self {
-        Self(x)
-    }
-    #[inline]
-    pub const fn as_raw(self) -> i32 {
-        self.0
-    }
-}
-impl VideoEncodeH264RateControlStructureEXT {
-    pub const UNKNOWN: Self = Self(0);
-    pub const FLAT: Self = Self(1);
-    pub const DYADIC: Self = Self(2);
-}
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-#[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlStructureEXT.html>"]
-pub struct VideoEncodeH265RateControlStructureEXT(pub(crate) i32);
-impl VideoEncodeH265RateControlStructureEXT {
-    #[inline]
-    pub const fn from_raw(x: i32) -> Self {
-        Self(x)
-    }
-    #[inline]
-    pub const fn as_raw(self) -> i32 {
-        self.0
-    }
-}
-impl VideoEncodeH265RateControlStructureEXT {
-    pub const UNKNOWN: Self = Self(0);
-    pub const FLAT: Self = Self(1);
-    pub const DYADIC: Self = Self(2);
-}
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-#[repr(transparent)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRobustnessBufferBehaviorEXT.html>"]
 pub struct PipelineRobustnessBufferBehaviorEXT(pub(crate) i32);
 impl PipelineRobustnessBufferBehaviorEXT {
@@ -2745,6 +2707,25 @@ impl OpacityMicromapSpecialIndexEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDepthBiasRepresentationEXT.html>"]
+pub struct DepthBiasRepresentationEXT(pub(crate) i32);
+impl DepthBiasRepresentationEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl DepthBiasRepresentationEXT {
+    pub const LEAST_REPRESENTABLE_VALUE_FORMAT: Self = Self(0);
+    pub const LEAST_REPRESENTABLE_VALUE_FORCE_UNORM: Self = Self(1);
+    pub const FLOAT: Self = Self(2);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultAddressTypeEXT.html>"]
 pub struct DeviceFaultAddressTypeEXT(pub(crate) i32);
 impl DeviceFaultAddressTypeEXT {

ash/src/vk/extensions.rs

@@ -2752,7 +2752,7 @@ pub struct AmdShaderBallotFn;
 impl ExtVideoEncodeH264Fn {
     pub const NAME: &'static ::std::ffi::CStr =
         unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") };
-    pub const SPEC_VERSION: u32 = 10u32;
+    pub const SPEC_VERSION: u32 = 11u32;
 }
 #[derive(Clone)]
 pub struct ExtVideoEncodeH264Fn;
@@ -2761,12 +2761,17 @@ impl StructureType {
     pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000);
     pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001);
     pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002);
-    pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003);
+    pub const VIDEO_ENCODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_038_003);
     pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004);
     pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005);
+    pub const VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: Self = Self(1_000_038_006);
     pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007);
     pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008);
     pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009);
+    pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: Self = Self(1_000_038_010);
+    pub const VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: Self = Self(1_000_038_011);
+    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: Self = Self(1_000_038_012);
+    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: Self = Self(1_000_038_013);
 }
 #[doc = "Generated from 'VK_EXT_video_encode_h264'"]
 impl VideoCodecOperationFlagsKHR {
@@ -2775,7 +2780,7 @@ impl VideoCodecOperationFlagsKHR {
 impl ExtVideoEncodeH265Fn {
     pub const NAME: &'static ::std::ffi::CStr =
         unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") };
-    pub const SPEC_VERSION: u32 = 10u32;
+    pub const SPEC_VERSION: u32 = 11u32;
 }
 #[derive(Clone)]
 pub struct ExtVideoEncodeH265Fn;
@@ -2784,12 +2789,17 @@ impl StructureType {
     pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000);
     pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001);
     pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002);
-    pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003);
+    pub const VIDEO_ENCODE_H265_PICTURE_INFO_EXT: Self = Self(1_000_039_003);
     pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004);
     pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005);
+    pub const VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: Self = Self(1_000_039_006);
     pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007);
     pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009);
     pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010);
+    pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: Self = Self(1_000_039_011);
+    pub const VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: Self = Self(1_000_039_012);
+    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: Self = Self(1_000_039_013);
+    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: Self = Self(1_000_039_014);
 }
 #[doc = "Generated from 'VK_EXT_video_encode_h265'"]
 impl VideoCodecOperationFlagsKHR {
@@ -13195,6 +13205,56 @@ impl StructureType {
         Self(1_000_282_000);
     pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001);
 }
+impl ExtDepthBiasControlFn {
+    pub const NAME: &'static ::std::ffi::CStr =
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_bias_control\0") };
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDepthBias2EXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    p_depth_bias_info: *const DepthBiasInfoEXT,
+);
+#[derive(Clone)]
+pub struct ExtDepthBiasControlFn {
+    pub cmd_set_depth_bias2_ext: PFN_vkCmdSetDepthBias2EXT,
+}
+unsafe impl Send for ExtDepthBiasControlFn {}
+unsafe impl Sync for ExtDepthBiasControlFn {}
+impl ExtDepthBiasControlFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            cmd_set_depth_bias2_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bias2_ext(
+                    _command_buffer: CommandBuffer,
+                    _p_depth_bias_info: *const DepthBiasInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_bias2_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias2EXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bias2_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_EXT_depth_bias_control'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: Self = Self(1_000_283_000);
+    pub const DEPTH_BIAS_INFO_EXT: Self = Self(1_000_283_001);
+    pub const DEPTH_BIAS_REPRESENTATION_INFO_EXT: Self = Self(1_000_283_002);
+}
 impl ExtDeviceMemoryReportFn {
     pub const NAME: &'static ::std::ffi::CStr = unsafe {
         ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0")
@@ -13540,15 +13600,33 @@ impl StructureType {
 impl KhrVideoEncodeQueueFn {
     pub const NAME: &'static ::std::ffi::CStr =
         unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") };
-    pub const SPEC_VERSION: u32 = 8u32;
+    pub const SPEC_VERSION: u32 = 9u32;
 }
 #[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR =
+    unsafe extern "system" fn(
+        physical_device: PhysicalDevice,
+        p_quality_level_info: *const PhysicalDeviceVideoEncodeQualityLevelInfoKHR,
+        p_quality_level_properties: *mut VideoEncodeQualityLevelPropertiesKHR,
+    ) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetEncodedVideoSessionParametersKHR = unsafe extern "system" fn(
+    device: Device,
+    p_video_session_parameters_info: *const VideoEncodeSessionParametersGetInfoKHR,
+    p_feedback_info: *mut VideoEncodeSessionParametersFeedbackInfoKHR,
+    p_data_size: *mut usize,
+    p_data: *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
 pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     p_encode_info: *const VideoEncodeInfoKHR,
 );
 #[derive(Clone)]
 pub struct KhrVideoEncodeQueueFn {
+    pub get_physical_device_video_encode_quality_level_properties_khr:
+        PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR,
+    pub get_encoded_video_session_parameters_khr: PFN_vkGetEncodedVideoSessionParametersKHR,
     pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR,
 }
 unsafe impl Send for KhrVideoEncodeQueueFn {}
@@ -13559,6 +13637,50 @@ impl KhrVideoEncodeQueueFn {
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
         Self {
+            get_physical_device_video_encode_quality_level_properties_khr: unsafe {
+                unsafe extern "system" fn get_physical_device_video_encode_quality_level_properties_khr(
+                    _physical_device: PhysicalDevice,
+                    _p_quality_level_info: *const PhysicalDeviceVideoEncodeQualityLevelInfoKHR,
+                    _p_quality_level_properties: *mut VideoEncodeQualityLevelPropertiesKHR,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_video_encode_quality_level_properties_khr)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_video_encode_quality_level_properties_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_encoded_video_session_parameters_khr: unsafe {
+                unsafe extern "system" fn get_encoded_video_session_parameters_khr(
+                    _device: Device,
+                    _p_video_session_parameters_info: *const VideoEncodeSessionParametersGetInfoKHR,
+                    _p_feedback_info: *mut VideoEncodeSessionParametersFeedbackInfoKHR,
+                    _p_data_size: *mut usize,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_encoded_video_session_parameters_khr)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetEncodedVideoSessionParametersKHR\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_encoded_video_session_parameters_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
             cmd_encode_video_khr: unsafe {
                 unsafe extern "system" fn cmd_encode_video_khr(
                     _command_buffer: CommandBuffer,
@@ -13635,11 +13757,20 @@ impl StructureType {
     pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003);
     pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004);
     pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: Self = Self(1_000_299_005);
+    pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1_000_299_006);
+    pub const VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: Self = Self(1_000_299_007);
+    pub const VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1_000_299_008);
+    pub const VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: Self = Self(1_000_299_009);
+    pub const VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: Self = Self(1_000_299_010);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
 impl VideoCodingControlFlagsKHR {
     pub const ENCODE_RATE_CONTROL: Self = Self(0b10);
-    pub const ENCODE_RATE_CONTROL_LAYER: Self = Self(0b100);
+    pub const ENCODE_QUALITY_LEVEL: Self = Self(0b100);
+}
+#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
+impl VideoSessionCreateFlagsKHR {
+    pub const ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS: Self = Self(0b10);
 }
 impl NvDeviceDiagnosticsConfigFn {
     pub const NAME: &'static ::std::ffi::CStr = unsafe {
@@ -17854,6 +17985,20 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1_000_440_001);
     pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1_000_440_002);
 }
+impl ExtExternalMemoryAcquireUnmodifiedFn {
+    pub const NAME: &'static ::std::ffi::CStr = unsafe {
+        ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+            b"VK_EXT_external_memory_acquire_unmodified\0",
+        )
+    };
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtExternalMemoryAcquireUnmodifiedFn;
+#[doc = "Generated from 'VK_EXT_external_memory_acquire_unmodified'"]
+impl StructureType {
+    pub const EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: Self = Self(1_000_453_000);
+}
 impl ExtExtendedDynamicState3Fn {
     pub const NAME: &'static ::std::ffi::CStr = unsafe {
         ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0")
@@ -20571,3 +20716,64 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: Self =
         Self(1_000_524_000);
 }
+impl QnxExternalMemoryScreenBufferFn {
+    pub const NAME: &'static ::std::ffi::CStr = unsafe {
+        ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_external_memory_screen_buffer\0")
+    };
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetScreenBufferPropertiesQNX = unsafe extern "system" fn(
+    device: Device,
+    buffer: *const _screen_buffer,
+    p_properties: *mut ScreenBufferPropertiesQNX,
+) -> Result;
+#[derive(Clone)]
+pub struct QnxExternalMemoryScreenBufferFn {
+    pub get_screen_buffer_properties_qnx: PFN_vkGetScreenBufferPropertiesQNX,
+}
+unsafe impl Send for QnxExternalMemoryScreenBufferFn {}
+unsafe impl Sync for QnxExternalMemoryScreenBufferFn {}
+impl QnxExternalMemoryScreenBufferFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_screen_buffer_properties_qnx: unsafe {
+                unsafe extern "system" fn get_screen_buffer_properties_qnx(
+                    _device: Device,
+                    _buffer: *const _screen_buffer,
+                    _p_properties: *mut ScreenBufferPropertiesQNX,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_screen_buffer_properties_qnx)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetScreenBufferPropertiesQNX\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_screen_buffer_properties_qnx
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_QNX_external_memory_screen_buffer'"]
+impl ExternalMemoryHandleTypeFlags {
+    pub const SCREEN_BUFFER_QNX: Self = Self(0b100_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_QNX_external_memory_screen_buffer'"]
+impl StructureType {
+    pub const SCREEN_BUFFER_PROPERTIES_QNX: Self = Self(1_000_529_000);
+    pub const SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: Self = Self(1_000_529_001);
+    pub const IMPORT_SCREEN_BUFFER_INFO_QNX: Self = Self(1_000_529_002);
+    pub const EXTERNAL_FORMAT_QNX: Self = Self(1_000_529_003);
+    pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: Self =
+        Self(1_000_529_004);
+}

ash/src/vk/platform_types.rs

@@ -19,6 +19,7 @@ pub type HMONITOR = HANDLE;
 pub type DWORD = c_ulong;
 pub type LPCWSTR = *const u16;
 pub type zx_handle_t = u32;
+pub type _screen_buffer = c_void;
 pub type _screen_context = c_void;
 pub type _screen_window = c_void;
 pub type SECURITY_ATTRIBUTES = c_void;

generator/Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 3df77fb3e4e0961f7f01de9a9ae20dfdcfc4910a
+Subproject commit c1a8560c5cf5e7bd6dbc71fe69b1a317411c36b8