Update Vulkan-Headers to 1.2.201 (#504)

ash/src/vk/bitflags.rs

@@ -1160,7 +1160,7 @@ pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags);
 vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags);
 impl VideoEncodeRateControlFlagsKHR {
     pub const DEFAULT: Self = Self(0);
-    pub const RESET: Self = Self(0b1);
+    pub const RESERVED_0: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -1189,6 +1189,7 @@ impl VideoEncodeH264CapabilityFlagsEXT {
     pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b1_0000_0000);
     pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b10_0000_0000);
     pub const EVENLY_DISTRIBUTED_SLICE_SIZE: Self = Self(0b100_0000_0000);
+    pub const OPTIONAL_RC_EXTENSION_STRUCT: Self = Self(0b1000_0000_0000);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -1221,6 +1222,16 @@ impl VideoEncodeH264CreateFlagsEXT {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264RateControlStructureFlagBitsEXT.html>"]
+pub struct VideoEncodeH264RateControlStructureFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeH264RateControlStructureFlagsEXT, Flags);
+impl VideoEncodeH264RateControlStructureFlagsEXT {
+    pub const UNKNOWN: Self = Self(0);
+    pub const FLAT: Self = Self(0b1);
+    pub const DYADIC: Self = Self(0b10);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html>"]
 pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags);
 vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags);
@@ -1317,3 +1328,13 @@ impl RenderingFlagsKHR {
     pub const SUSPENDING: Self = Self(0b10);
     pub const RESUMING: Self = Self(0b100);
 }
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265RateControlStructureFlagBitsEXT.html>"]
+pub struct VideoEncodeH265RateControlStructureFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeH265RateControlStructureFlagsEXT, Flags);
+impl VideoEncodeH265RateControlStructureFlagsEXT {
+    pub const UNKNOWN: Self = Self(0);
+    pub const FLAT: Self = Self(0b1);
+    pub const DYADIC: Self = Self(0b10);
+}

ash/src/vk/const_debugs.rs

@@ -4143,6 +4143,12 @@ impl fmt::Debug for StructureType {
                 Some("VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT")
             }
             Self::VIDEO_ENCODE_H264_PROFILE_EXT => Some("VIDEO_ENCODE_H264_PROFILE_EXT"),
+            Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT")
+            }
             Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"),
             Self::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT => {
                 Some("VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT")
@@ -4167,6 +4173,12 @@ impl fmt::Debug for StructureType {
             Self::VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT => {
                 Some("VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT")
             }
+            Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT")
+            }
             Self::VIDEO_DECODE_H264_CAPABILITIES_EXT => Some("VIDEO_DECODE_H264_CAPABILITIES_EXT"),
             Self::VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT => {
                 Some("VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT")
@@ -4882,6 +4894,9 @@ impl fmt::Debug for StructureType {
             }
             Self::VIDEO_ENCODE_INFO_KHR => Some("VIDEO_ENCODE_INFO_KHR"),
             Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => Some("VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"),
+            Self::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR => {
+                Some("VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR")
+            }
             Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV")
             }
@@ -5812,6 +5827,10 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
                 VideoEncodeH264CapabilityFlagsEXT::EVENLY_DISTRIBUTED_SLICE_SIZE.0,
                 "EVENLY_DISTRIBUTED_SLICE_SIZE",
             ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::OPTIONAL_RC_EXTENSION_STRUCT.0,
+                "OPTIONAL_RC_EXTENSION_STRUCT",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -5845,6 +5864,22 @@ impl fmt::Debug for VideoEncodeH264OutputModeFlagsEXT {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for VideoEncodeH264RateControlStructureFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                VideoEncodeH264RateControlStructureFlagsEXT::UNKNOWN.0,
+                "UNKNOWN",
+            ),
+            (VideoEncodeH264RateControlStructureFlagsEXT::FLAT.0, "FLAT"),
+            (
+                VideoEncodeH264RateControlStructureFlagsEXT::DYADIC.0,
+                "DYADIC",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
@@ -5888,11 +5923,27 @@ impl fmt::Debug for VideoEncodeH265OutputModeFlagsEXT {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for VideoEncodeH265RateControlStructureFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                VideoEncodeH265RateControlStructureFlagsEXT::UNKNOWN.0,
+                "UNKNOWN",
+            ),
+            (VideoEncodeH265RateControlStructureFlagsEXT::FLAT.0, "FLAT"),
+            (
+                VideoEncodeH265RateControlStructureFlagsEXT::DYADIC.0,
+                "DYADIC",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for VideoEncodeRateControlFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
             (VideoEncodeRateControlFlagsKHR::DEFAULT.0, "DEFAULT"),
-            (VideoEncodeRateControlFlagsKHR::RESET.0, "RESET"),
+            (VideoEncodeRateControlFlagsKHR::RESERVED_0.0, "RESERVED_0"),
         ];
         debug_flags(f, KNOWN, self.0)
     }

ash/src/vk/definitions.rs

@@ -54,7 +54,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 = 200u32;
+pub const HEADER_VERSION: u32 = 201u32;
 #[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>"]
@@ -49313,6 +49313,7 @@ pub struct VideoEncodeInfoKHR {
     pub p_setup_reference_slot: *const VideoReferenceSlotKHR,
     pub reference_slot_count: u32,
     pub p_reference_slots: *const VideoReferenceSlotKHR,
+    pub preceding_externally_encoded_bytes: u32,
 }
 impl ::std::default::Default for VideoEncodeInfoKHR {
     fn default() -> Self {
@@ -49329,6 +49330,7 @@ impl ::std::default::Default for VideoEncodeInfoKHR {
             p_setup_reference_slot: ::std::ptr::null(),
             reference_slot_count: u32::default(),
             p_reference_slots: ::std::ptr::null(),
+            preceding_externally_encoded_bytes: u32::default(),
         }
     }
 }
@@ -49398,6 +49400,13 @@ impl<'a> VideoEncodeInfoKHRBuilder<'a> {
         self.inner.p_reference_slots = reference_slots.as_ptr();
         self
     }
+    pub fn preceding_externally_encoded_bytes(
+        mut self,
+        preceding_externally_encoded_bytes: u32,
+    ) -> Self {
+        self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes;
+        self
+    }
     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
     #[doc = r" valid extension structs can be pushed into the chain."]
@@ -49427,11 +49436,8 @@ pub struct VideoEncodeRateControlInfoKHR {
     pub p_next: *const c_void,
     pub flags: VideoEncodeRateControlFlagsKHR,
     pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
-    pub average_bitrate: u32,
+    pub layer_count: u8,
-    pub peak_to_average_bitrate_ratio: u16,
+    pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR,
-    pub frame_rate_numerator: u16,
-    pub frame_rate_denominator: u16,
-    pub virtual_buffer_size_in_ms: u32,
 }
 impl ::std::default::Default for VideoEncodeRateControlInfoKHR {
     fn default() -> Self {
@@ -49440,11 +49446,8 @@ impl ::std::default::Default for VideoEncodeRateControlInfoKHR {
             p_next: ::std::ptr::null(),
             flags: VideoEncodeRateControlFlagsKHR::default(),
             rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(),
-            average_bitrate: u32::default(),
+            layer_count: u8::default(),
-            peak_to_average_bitrate_ratio: u16::default(),
+            p_layer_configs: ::std::ptr::null(),
-            frame_rate_numerator: u16::default(),
-            frame_rate_denominator: u16::default(),
-            virtual_buffer_size_in_ms: u32::default(),
         }
     }
 }
@@ -49463,6 +49466,7 @@ pub struct VideoEncodeRateControlInfoKHRBuilder<'a> {
 }
 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHRBuilder<'_> {}
 unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR {}
+pub unsafe trait ExtendsVideoEncodeRateControlInfoKHR {}
 impl<'a> ::std::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> {
     type Target = VideoEncodeRateControlInfoKHR;
     fn deref(&self) -> &Self::Target {
@@ -49486,19 +49490,103 @@ impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
         self.inner.rate_control_mode = rate_control_mode;
         self
     }
+    pub fn layer_configs(
+        mut self,
+        layer_configs: &'a [VideoEncodeRateControlLayerInfoKHR],
+    ) -> Self {
+        self.inner.layer_count = layer_configs.len() as _;
+        self.inner.p_layer_configs = layer_configs.as_ptr();
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsVideoEncodeRateControlInfoKHR>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr as _;
+        }
+        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) -> VideoEncodeRateControlInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlLayerInfoKHR.html>"]
+pub struct VideoEncodeRateControlLayerInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub average_bitrate: u32,
+    pub max_bitrate: u32,
+    pub frame_rate_numerator: u32,
+    pub frame_rate_denominator: u32,
+    pub virtual_buffer_size_in_ms: u32,
+    pub initial_virtual_buffer_size_in_ms: u32,
+}
+impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR {
+    fn default() -> Self {
+        Self {
+            s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR,
+            p_next: ::std::ptr::null(),
+            average_bitrate: u32::default(),
+            max_bitrate: u32::default(),
+            frame_rate_numerator: u32::default(),
+            frame_rate_denominator: u32::default(),
+            virtual_buffer_size_in_ms: u32::default(),
+            initial_virtual_buffer_size_in_ms: u32::default(),
+        }
+    }
+}
+impl VideoEncodeRateControlLayerInfoKHR {
+    pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+        VideoEncodeRateControlLayerInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+    inner: VideoEncodeRateControlLayerInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {}
+pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+    type Target = VideoEncodeRateControlLayerInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
     pub fn average_bitrate(mut self, average_bitrate: u32) -> Self {
         self.inner.average_bitrate = average_bitrate;
         self
     }
-    pub fn peak_to_average_bitrate_ratio(mut self, peak_to_average_bitrate_ratio: u16) -> Self {
+    pub fn max_bitrate(mut self, max_bitrate: u32) -> Self {
-        self.inner.peak_to_average_bitrate_ratio = peak_to_average_bitrate_ratio;
+        self.inner.max_bitrate = max_bitrate;
         self
     }
-    pub fn frame_rate_numerator(mut self, frame_rate_numerator: u16) -> Self {
+    pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self {
         self.inner.frame_rate_numerator = frame_rate_numerator;
         self
     }
-    pub fn frame_rate_denominator(mut self, frame_rate_denominator: u16) -> Self {
+    pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self {
         self.inner.frame_rate_denominator = frame_rate_denominator;
         self
     }
@@ -49506,10 +49594,34 @@ impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
         self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms;
         self
     }
+    pub fn initial_virtual_buffer_size_in_ms(
+        mut self,
+        initial_virtual_buffer_size_in_ms: u32,
+    ) -> Self {
+        self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms;
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>(
+        mut self,
+        next: &'a mut T,
+    ) -> Self {
+        unsafe {
+            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr as _;
+        }
+        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) -> VideoEncodeRateControlInfoKHR {
+    pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR {
         self.inner
     }
 }
@@ -50147,9 +50259,6 @@ pub struct VideoEncodeH264NaluSliceEXT {
     pub p_ref_final_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT,
     pub ref_final_list1_entry_count: u8,
     pub p_ref_final_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT,
-    pub preceding_nalu_bytes: u32,
-    pub min_qp: u8,
-    pub max_qp: u8,
 }
 impl ::std::default::Default for VideoEncodeH264NaluSliceEXT {
     fn default() -> Self {
@@ -50162,9 +50271,6 @@ impl ::std::default::Default for VideoEncodeH264NaluSliceEXT {
             p_ref_final_list0_entries: ::std::ptr::null(),
             ref_final_list1_entry_count: u8::default(),
             p_ref_final_list1_entries: ::std::ptr::null(),
-            preceding_nalu_bytes: u32::default(),
-            min_qp: u8::default(),
-            max_qp: u8::default(),
         }
     }
 }
@@ -50217,22 +50323,296 @@ impl<'a> VideoEncodeH264NaluSliceEXTBuilder<'a> {
         self.inner.p_ref_final_list1_entries = ref_final_list1_entries.as_ptr();
         self
     }
-    pub fn preceding_nalu_bytes(mut self, preceding_nalu_bytes: u32) -> Self {
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
-        self.inner.preceding_nalu_bytes = preceding_nalu_bytes;
+    #[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) -> VideoEncodeH264NaluSliceEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264RateControlInfoEXT.html>"]
+pub struct VideoEncodeH264RateControlInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub gop_frame_count: u32,
+    pub idr_period: u32,
+    pub consecutive_b_frame_count: u32,
+    pub rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT,
+}
+impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT {
+    fn default() -> Self {
+        Self {
+            s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT,
+            p_next: ::std::ptr::null(),
+            gop_frame_count: u32::default(),
+            idr_period: u32::default(),
+            consecutive_b_frame_count: u32::default(),
+            rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT::default(),
+        }
+    }
+}
+impl VideoEncodeH264RateControlInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+        VideoEncodeH264RateControlInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    inner: VideoEncodeH264RateControlInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH264RateControlInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
+        self.inner.gop_frame_count = gop_frame_count;
         self
     }
-    pub fn min_qp(mut self, min_qp: u8) -> Self {
+    pub fn idr_period(mut self, idr_period: u32) -> Self {
-        self.inner.min_qp = min_qp;
+        self.inner.idr_period = idr_period;
         self
     }
-    pub fn max_qp(mut self, max_qp: u8) -> Self {
+    pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
-        self.inner.max_qp = max_qp;
+        self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
+        self
+    }
+    pub fn rate_control_structure(
+        mut self,
+        rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT,
+    ) -> Self {
+        self.inner.rate_control_structure = rate_control_structure;
         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) -> VideoEncodeH264NaluSliceEXT {
+    pub fn build(self) -> VideoEncodeH264RateControlInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264QpEXT.html>"]
+pub struct VideoEncodeH264QpEXT {
+    pub qp_i: i32,
+    pub qp_p: i32,
+    pub qp_b: i32,
+}
+impl VideoEncodeH264QpEXT {
+    pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> {
+        VideoEncodeH264QpEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264QpEXTBuilder<'a> {
+    inner: VideoEncodeH264QpEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> {
+    type Target = VideoEncodeH264QpEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264QpEXTBuilder<'a> {
+    pub fn qp_i(mut self, qp_i: i32) -> Self {
+        self.inner.qp_i = qp_i;
+        self
+    }
+    pub fn qp_p(mut self, qp_p: i32) -> Self {
+        self.inner.qp_p = qp_p;
+        self
+    }
+    pub fn qp_b(mut self, qp_b: i32) -> Self {
+        self.inner.qp_b = qp_b;
+        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) -> VideoEncodeH264QpEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264FrameSizeEXT.html>"]
+pub struct VideoEncodeH264FrameSizeEXT {
+    pub frame_i_size: u32,
+    pub frame_p_size: u32,
+    pub frame_b_size: u32,
+}
+impl VideoEncodeH264FrameSizeEXT {
+    pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> {
+        VideoEncodeH264FrameSizeEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    inner: VideoEncodeH264FrameSizeEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    type Target = VideoEncodeH264FrameSizeEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
+        self.inner.frame_i_size = frame_i_size;
+        self
+    }
+    pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
+        self.inner.frame_p_size = frame_p_size;
+        self
+    }
+    pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
+        self.inner.frame_b_size = frame_b_size;
+        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) -> VideoEncodeH264FrameSizeEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264RateControlLayerInfoEXT.html>"]
+pub struct VideoEncodeH264RateControlLayerInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub temporal_layer_id: u8,
+    pub use_initial_rc_qp: Bool32,
+    pub initial_rc_qp: VideoEncodeH264QpEXT,
+    pub use_min_qp: Bool32,
+    pub min_qp: VideoEncodeH264QpEXT,
+    pub use_max_qp: Bool32,
+    pub max_qp: VideoEncodeH264QpEXT,
+    pub use_max_frame_size: Bool32,
+    pub max_frame_size: VideoEncodeH264FrameSizeEXT,
+}
+impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT {
+    fn default() -> Self {
+        Self {
+            s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT,
+            p_next: ::std::ptr::null(),
+            temporal_layer_id: u8::default(),
+            use_initial_rc_qp: Bool32::default(),
+            initial_rc_qp: VideoEncodeH264QpEXT::default(),
+            use_min_qp: Bool32::default(),
+            min_qp: VideoEncodeH264QpEXT::default(),
+            use_max_qp: Bool32::default(),
+            max_qp: VideoEncodeH264QpEXT::default(),
+            use_max_frame_size: Bool32::default(),
+            max_frame_size: VideoEncodeH264FrameSizeEXT::default(),
+        }
+    }
+}
+impl VideoEncodeH264RateControlLayerInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+        VideoEncodeH264RateControlLayerInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    inner: VideoEncodeH264RateControlLayerInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
+    for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH264RateControlLayerInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    pub fn temporal_layer_id(mut self, temporal_layer_id: u8) -> Self {
+        self.inner.temporal_layer_id = temporal_layer_id;
+        self
+    }
+    pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
+        self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
+        self
+    }
+    pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self {
+        self.inner.initial_rc_qp = initial_rc_qp;
+        self
+    }
+    pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
+        self.inner.use_min_qp = use_min_qp.into();
+        self
+    }
+    pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self {
+        self.inner.min_qp = min_qp;
+        self
+    }
+    pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
+        self.inner.use_max_qp = use_max_qp.into();
+        self
+    }
+    pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self {
+        self.inner.max_qp = max_qp;
+        self
+    }
+    pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
+        self.inner.use_max_frame_size = use_max_frame_size.into();
+        self
+    }
+    pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self {
+        self.inner.max_frame_size = max_frame_size;
+        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) -> VideoEncodeH264RateControlLayerInfoEXT {
         self.inner
     }
 }
@@ -50810,6 +51190,292 @@ impl<'a> VideoEncodeH265NaluSliceEXTBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265RateControlInfoEXT.html>"]
+pub struct VideoEncodeH265RateControlInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub gop_frame_count: u32,
+    pub idr_period: u32,
+    pub consecutive_b_frame_count: u32,
+    pub rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT,
+}
+impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT {
+    fn default() -> Self {
+        Self {
+            s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT,
+            p_next: ::std::ptr::null(),
+            gop_frame_count: u32::default(),
+            idr_period: u32::default(),
+            consecutive_b_frame_count: u32::default(),
+            rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT::default(),
+        }
+    }
+}
+impl VideoEncodeH265RateControlInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+        VideoEncodeH265RateControlInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265RateControlInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265RateControlInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
+        self.inner.gop_frame_count = gop_frame_count;
+        self
+    }
+    pub fn idr_period(mut self, idr_period: u32) -> Self {
+        self.inner.idr_period = idr_period;
+        self
+    }
+    pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
+        self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
+        self
+    }
+    pub fn rate_control_structure(
+        mut self,
+        rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT,
+    ) -> Self {
+        self.inner.rate_control_structure = rate_control_structure;
+        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) -> VideoEncodeH265RateControlInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265QpEXT.html>"]
+pub struct VideoEncodeH265QpEXT {
+    pub qp_i: i32,
+    pub qp_p: i32,
+    pub qp_b: i32,
+}
+impl VideoEncodeH265QpEXT {
+    pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> {
+        VideoEncodeH265QpEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265QpEXTBuilder<'a> {
+    inner: VideoEncodeH265QpEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> {
+    type Target = VideoEncodeH265QpEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265QpEXTBuilder<'a> {
+    pub fn qp_i(mut self, qp_i: i32) -> Self {
+        self.inner.qp_i = qp_i;
+        self
+    }
+    pub fn qp_p(mut self, qp_p: i32) -> Self {
+        self.inner.qp_p = qp_p;
+        self
+    }
+    pub fn qp_b(mut self, qp_b: i32) -> Self {
+        self.inner.qp_b = qp_b;
+        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) -> VideoEncodeH265QpEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265FrameSizeEXT.html>"]
+pub struct VideoEncodeH265FrameSizeEXT {
+    pub frame_i_size: u32,
+    pub frame_p_size: u32,
+    pub frame_b_size: u32,
+}
+impl VideoEncodeH265FrameSizeEXT {
+    pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> {
+        VideoEncodeH265FrameSizeEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    inner: VideoEncodeH265FrameSizeEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    type Target = VideoEncodeH265FrameSizeEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
+        self.inner.frame_i_size = frame_i_size;
+        self
+    }
+    pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
+        self.inner.frame_p_size = frame_p_size;
+        self
+    }
+    pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
+        self.inner.frame_b_size = frame_b_size;
+        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) -> VideoEncodeH265FrameSizeEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265RateControlLayerInfoEXT.html>"]
+pub struct VideoEncodeH265RateControlLayerInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub temporal_id: u8,
+    pub use_initial_rc_qp: Bool32,
+    pub initial_rc_qp: VideoEncodeH265QpEXT,
+    pub use_min_qp: Bool32,
+    pub min_qp: VideoEncodeH265QpEXT,
+    pub use_max_qp: Bool32,
+    pub max_qp: VideoEncodeH265QpEXT,
+    pub use_max_frame_size: Bool32,
+    pub max_frame_size: VideoEncodeH265FrameSizeEXT,
+}
+impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT {
+    fn default() -> Self {
+        Self {
+            s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT,
+            p_next: ::std::ptr::null(),
+            temporal_id: u8::default(),
+            use_initial_rc_qp: Bool32::default(),
+            initial_rc_qp: VideoEncodeH265QpEXT::default(),
+            use_min_qp: Bool32::default(),
+            min_qp: VideoEncodeH265QpEXT::default(),
+            use_max_qp: Bool32::default(),
+            max_qp: VideoEncodeH265QpEXT::default(),
+            use_max_frame_size: Bool32::default(),
+            max_frame_size: VideoEncodeH265FrameSizeEXT::default(),
+        }
+    }
+}
+impl VideoEncodeH265RateControlLayerInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+        VideoEncodeH265RateControlLayerInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265RateControlLayerInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
+    for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265RateControlLayerInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    pub fn temporal_id(mut self, temporal_id: u8) -> Self {
+        self.inner.temporal_id = temporal_id;
+        self
+    }
+    pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
+        self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
+        self
+    }
+    pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self {
+        self.inner.initial_rc_qp = initial_rc_qp;
+        self
+    }
+    pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
+        self.inner.use_min_qp = use_min_qp.into();
+        self
+    }
+    pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self {
+        self.inner.min_qp = min_qp;
+        self
+    }
+    pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
+        self.inner.use_max_qp = use_max_qp.into();
+        self
+    }
+    pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self {
+        self.inner.max_qp = max_qp;
+        self
+    }
+    pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
+        self.inner.use_max_frame_size = use_max_frame_size.into();
+        self
+    }
+    pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self {
+        self.inner.max_frame_size = max_frame_size;
+        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) -> VideoEncodeH265RateControlLayerInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH265ProfileEXT.html>"]
 pub struct VideoEncodeH265ProfileEXT {
     pub s_type: StructureType,
@@ -54563,6 +55229,22 @@ pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a
     inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
+{
+}
 impl<'a> ::std::ops::Deref
     for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a>
 {

ash/src/vk/extensions.rs

@@ -4134,6 +4134,14 @@ impl StructureType {
     pub const VIDEO_ENCODE_H264_PROFILE_EXT: Self = Self(1_000_038_008);
 }
 #[doc = "Generated from 'VK_EXT_video_encode_h264'"]
+impl StructureType {
+    pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_009);
+}
+#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
+impl StructureType {
+    pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_010);
+}
+#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
 impl VideoCodecOperationFlagsKHR {
     pub const ENCODE_H264_EXT: Self = Self(0b1_0000_0000_0000_0000);
 }
@@ -4197,6 +4205,14 @@ impl StructureType {
     pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT: Self = Self(1_000_039_009);
 }
 #[doc = "Generated from 'VK_EXT_video_encode_h265'"]
+impl StructureType {
+    pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_010);
+}
+#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
+impl StructureType {
+    pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_011);
+}
+#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
 impl VideoCodecOperationFlagsKHR {
     pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000);
 }
@@ -21520,6 +21536,10 @@ impl StructureType {
     pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
+impl StructureType {
+    pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1_000_299_002);
+}
+#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
 impl QueueFlags {
     pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000);
 }
@@ -26671,3 +26691,22 @@ impl ExtExtension437Fn {
         Self {}
     }
 }
+impl ExtExtension438Fn {
+    pub fn name() -> &'static ::std::ffi::CStr {
+        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_438\0")
+            .expect("Wrong extension string")
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension438Fn {}
+unsafe impl Send for ExtExtension438Fn {}
+unsafe impl Sync for ExtExtension438Fn {}
+impl ExtExtension438Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}

generator/Vulkan-Headers

@@ -1 +1 @@
-Subproject commit a15237165443ba1ef430ed332745f9a99ec509ad
+Subproject commit ea61f32f24d2ce28b358e154910fb4eb410ffd79