From 7fc47de5c1253b918a3924066a29657351231edb Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Thu, 1 Dec 2022 15:57:05 +0100 Subject: [PATCH 1/3] Update Vulkan-Headers to 1.3.236 --- Changelog.md | 4 + ash/Cargo.toml | 2 +- ash/src/vk/const_debugs.rs | 25 ++++++ ash/src/vk/definitions.rs | 159 +++++++++++++++++++++++++++++++++++-- ash/src/vk/enums.rs | 18 +++++ ash/src/vk/extensions.rs | 56 ++++++++++++- generator/Vulkan-Headers | 2 +- 7 files changed, 255 insertions(+), 11 deletions(-) diff --git a/Changelog.md b/Changelog.md index 01dcb3625..48ee4f2a3 100644 --- a/Changelog.md +++ b/Changelog.md @@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Replaced builders with lifetimes/setters directly on Vulkan structs (#602) - Inlined struct setters (#602) +### Added + +- Update Vulkan-Headers to 1.3.236 (#688) + ### Removed - Removed all code generated for `"disabled"` extensions, typically with a number rather than a descriptive name (#448) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index e398790bd..2a93d8461 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.235" +version = "0.37.0+1.3.236" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT OR Apache-2.0" diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 00b7e2d89..6c47efd9e 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -1379,6 +1379,26 @@ impl fmt::Debug for DeviceQueueCreateFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for DirectDriverLoadingFlagsLUNARG { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DirectDriverLoadingModeLUNARG { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::INCLUSIVE => Some("INCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for DirectFBSurfaceCreateFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[]; @@ -5661,6 +5681,8 @@ impl fmt::Debug for StructureType { Self::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT => { Some("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT") } + Self::DIRECT_DRIVER_LOADING_INFO_LUNARG => Some("DIRECT_DRIVER_LOADING_INFO_LUNARG"), + Self::DIRECT_DRIVER_LOADING_LIST_LUNARG => Some("DIRECT_DRIVER_LOADING_LIST_LUNARG"), Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT => { Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT") } @@ -5705,6 +5727,9 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC") } Self::AMIGO_PROFILING_SUBMIT_INFO_SEC => Some("AMIGO_PROFILING_SUBMIT_INFO_SEC"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM") + } Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV => { Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV") } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index c8481a89b..093683dae 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -57,7 +57,7 @@ pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); -pub const HEADER_VERSION: u32 = 235u32; +pub const HEADER_VERSION: u32 = 236u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -149,6 +149,11 @@ pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags); vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DirectDriverLoadingFlagsLUNARG(pub(crate) Flags); +vk_bitflags_wrapped!(DirectDriverLoadingFlagsLUNARG, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags); @@ -520,6 +525,11 @@ pub type PFN_vkDeviceMemoryReportCallbackEXT = Option< p_user_data: *mut c_void, ), >; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkGetInstanceProcAddr = Option< + unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction, +>; #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] @@ -36925,8 +36935,8 @@ pub struct VideoDecodeH265PictureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo, - pub slice_count: u32, - pub p_slice_offsets: *const u32, + pub slice_segment_count: u32, + pub p_slice_segment_offsets: *const u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoDecodeH265PictureInfoEXT<'_> { @@ -36936,8 +36946,8 @@ impl ::std::default::Default for VideoDecodeH265PictureInfoEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), p_std_picture_info: ::std::ptr::null_mut(), - slice_count: u32::default(), - p_slice_offsets: ::std::ptr::null(), + slice_segment_count: u32::default(), + p_slice_segment_offsets: ::std::ptr::null(), _marker: PhantomData, } } @@ -36956,9 +36966,9 @@ impl<'a> VideoDecodeH265PictureInfoEXT<'a> { self } #[inline] - pub fn slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self { - self.slice_count = slice_offsets.len() as _; - self.p_slice_offsets = slice_offsets.as_ptr(); + pub fn slice_segment_offsets(mut self, slice_segment_offsets: &'a [u32]) -> Self { + self.slice_segment_count = slice_segment_offsets.len() as _; + self.p_slice_segment_offsets = slice_segment_offsets.as_ptr(); self } } @@ -46490,3 +46500,136 @@ impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { self } } +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectDriverLoadingInfoLUNARG<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DirectDriverLoadingFlagsLUNARG, + pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddr, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DirectDriverLoadingInfoLUNARG<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DirectDriverLoadingInfoLUNARG") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field( + "pfn_get_instance_proc_addr", + &(self.pfn_get_instance_proc_addr.map(|x| x as *const ())), + ) + .finish() + } +} +impl ::std::default::Default for DirectDriverLoadingInfoLUNARG<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DirectDriverLoadingFlagsLUNARG::default(), + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddr::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DirectDriverLoadingInfoLUNARG<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_INFO_LUNARG; +} +impl<'a> DirectDriverLoadingInfoLUNARG<'a> { + #[inline] + pub fn flags(mut self, flags: DirectDriverLoadingFlagsLUNARG) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn pfn_get_instance_proc_addr( + mut self, + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddr, + ) -> Self { + self.pfn_get_instance_proc_addr = pfn_get_instance_proc_addr; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectDriverLoadingListLUNARG<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub mode: DirectDriverLoadingModeLUNARG, + pub driver_count: u32, + pub p_drivers: *const DirectDriverLoadingInfoLUNARG<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DirectDriverLoadingListLUNARG<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + mode: DirectDriverLoadingModeLUNARG::default(), + driver_count: u32::default(), + p_drivers: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DirectDriverLoadingListLUNARG<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_LIST_LUNARG; +} +unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARG<'_> {} +impl<'a> DirectDriverLoadingListLUNARG<'a> { + #[inline] + pub fn mode(mut self, mode: DirectDriverLoadingModeLUNARG) -> Self { + self.mode = mode; + self + } + #[inline] + pub fn drivers(mut self, drivers: &'a [DirectDriverLoadingInfoLUNARG]) -> Self { + self.driver_count = drivers.len() as _; + self.p_drivers = drivers.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multiview_per_view_viewports: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multiview_per_view_viewports: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> { + #[inline] + pub fn multiview_per_view_viewports(mut self, multiview_per_view_viewports: bool) -> Self { + self.multiview_per_view_viewports = multiview_per_view_viewports.into(); + self + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 3113805d8..a27a55b40 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1103,6 +1103,24 @@ impl RayTracingInvocationReorderModeNV { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct DirectDriverLoadingModeLUNARG(pub(crate) i32); +impl DirectDriverLoadingModeLUNARG { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DirectDriverLoadingModeLUNARG { + pub const EXCLUSIVE: Self = Self(0); + pub const INCLUSIVE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct SemaphoreType(pub(crate) i32); impl SemaphoreType { diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 52533d6a5..4801890a5 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -10988,7 +10988,7 @@ impl ExtVideoDecodeH265Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h265\0") } } - pub const SPEC_VERSION: u32 = 5u32; + pub const SPEC_VERSION: u32 = 6u32; } #[derive(Clone)] pub struct ExtVideoDecodeH265Fn {} @@ -20817,6 +20817,32 @@ impl StructureType { pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_002); pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_003); } +impl LunargDirectDriverLoadingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_LUNARG_direct_driver_loading\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct LunargDirectDriverLoadingFn {} +unsafe impl Send for LunargDirectDriverLoadingFn {} +unsafe impl Sync for LunargDirectDriverLoadingFn {} +impl LunargDirectDriverLoadingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_LUNARG_direct_driver_loading'"] +impl StructureType { + pub const DIRECT_DRIVER_LOADING_INFO_LUNARG: Self = Self(1_000_459_000); + pub const DIRECT_DRIVER_LOADING_LIST_LUNARG: Self = Self(1_000_459_001); +} impl ExtShaderModuleIdentifierFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -21326,6 +21352,34 @@ impl StructureType { pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: Self = Self(1_000_485_000); pub const AMIGO_PROFILING_SUBMIT_INFO_SEC: Self = Self(1_000_485_001); } +impl QcomMultiviewPerViewViewportsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_QCOM_multiview_per_view_viewports\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomMultiviewPerViewViewportsFn {} +unsafe impl Send for QcomMultiviewPerViewViewportsFn {} +unsafe impl Sync for QcomMultiviewPerViewViewportsFn {} +impl QcomMultiviewPerViewViewportsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_multiview_per_view_viewports'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: Self = + Self(1_000_488_000); +} impl NvRayTracingInvocationReorderFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index b7a86d3b2..2826791be 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit b7a86d3b2bf8fbe73fcd40df9ec62a5966e9db89 +Subproject commit 2826791bed6a793f164bf534cd859968f13df8a9 From 68344eb8019ffe8a52097a4b4a59932b4d3359af Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Thu, 8 Dec 2022 15:57:29 +0100 Subject: [PATCH 2/3] Update Vulkan-Headers to 1.3.237 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/vk/bitflags.rs | 20 ++ ash/src/vk/const_debugs.rs | 46 +++++ ash/src/vk/definitions.rs | 374 ++++++++++++++++++++++++++++++++++++- ash/src/vk/extensions.rs | 87 +++++++++ generator/Vulkan-Headers | 2 +- 7 files changed, 524 insertions(+), 9 deletions(-) diff --git a/Changelog.md b/Changelog.md index 48ee4f2a3..7fdf75c85 100644 --- a/Changelog.md +++ b/Changelog.md @@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added -- Update Vulkan-Headers to 1.3.236 (#688) +- Update Vulkan-Headers to 1.3.237 (#688) ### Removed diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 2a93d8461..b95090155 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.236" +version = "0.37.0+1.3.237" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT OR Apache-2.0" diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index bc3ccdec2..ff1127e9b 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1143,6 +1143,26 @@ impl DeviceAddressBindingFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PresentScalingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PresentScalingFlagsEXT, Flags); +impl PresentScalingFlagsEXT { + pub const ONE_TO_ONE: Self = Self(0b1); + pub const ASPECT_RATIO_STRETCH: Self = Self(0b10); + pub const STRETCH: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PresentGravityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PresentGravityFlagsEXT, Flags); +impl PresentGravityFlagsEXT { + pub const MIN: Self = Self(0b1); + pub const MAX: Self = Self(0b10); + pub const CENTERED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 6c47efd9e..9f633330d 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -3766,6 +3766,16 @@ impl fmt::Debug for PolygonMode { } } } +impl fmt::Debug for PresentGravityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PresentGravityFlagsEXT::MIN.0, "MIN"), + (PresentGravityFlagsEXT::MAX.0, "MAX"), + (PresentGravityFlagsEXT::CENTERED.0, "CENTERED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for PresentModeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -3784,6 +3794,19 @@ impl fmt::Debug for PresentModeKHR { } } } +impl fmt::Debug for PresentScalingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PresentScalingFlagsEXT::ONE_TO_ONE.0, "ONE_TO_ONE"), + ( + PresentScalingFlagsEXT::ASPECT_RATIO_STRETCH.0, + "ASPECT_RATIO_STRETCH", + ), + (PresentScalingFlagsEXT::STRETCH.0, "STRETCH"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -5250,6 +5273,25 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => { Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT") } + Self::SURFACE_PRESENT_MODE_EXT => Some("SURFACE_PRESENT_MODE_EXT"), + Self::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT => { + Some("SURFACE_PRESENT_SCALING_CAPABILITIES_EXT") + } + Self::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT => { + Some("SURFACE_PRESENT_MODE_COMPATIBILITY_EXT") + } + Self::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT") + } + Self::SWAPCHAIN_PRESENT_FENCE_INFO_EXT => Some("SWAPCHAIN_PRESENT_FENCE_INFO_EXT"), + Self::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT => { + Some("SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT") + } + Self::SWAPCHAIN_PRESENT_MODE_INFO_EXT => Some("SWAPCHAIN_PRESENT_MODE_INFO_EXT"), + Self::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT => { + Some("SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT") + } + Self::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT => Some("RELEASE_SWAPCHAIN_IMAGES_INFO_EXT"), Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV => { Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV") } @@ -6242,6 +6284,10 @@ impl fmt::Debug for SwapchainCreateFlagsKHR { ), (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + ( + SwapchainCreateFlagsKHR::DEFERRED_MEMORY_ALLOCATION_EXT.0, + "DEFERRED_MEMORY_ALLOCATION_EXT", + ), ]; debug_flags(f, KNOWN, self.0) } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 093683dae..d2cf7445f 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -57,7 +57,7 @@ pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); -pub const HEADER_VERSION: u32 = 236u32; +pub const HEADER_VERSION: u32 = 237u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -526,8 +526,8 @@ pub type PFN_vkDeviceMemoryReportCallbackEXT = Option< ), >; #[allow(non_camel_case_types)] -#[doc = ""] -pub type PFN_vkGetInstanceProcAddr = Option< +#[doc = ""] +pub type PFN_vkGetInstanceProcAddrLUNARG = Option< unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction, >; #[repr(C)] @@ -46425,6 +46425,368 @@ impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentModeEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode: PresentModeKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SurfacePresentModeEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode: PresentModeKHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SurfacePresentModeEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_EXT; +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXT<'_> {} +impl<'a> SurfacePresentModeEXT<'a> { + #[inline] + pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self { + self.present_mode = present_mode; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentScalingCapabilitiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_present_scaling: PresentScalingFlagsEXT, + pub supported_present_gravity_x: PresentGravityFlagsEXT, + pub supported_present_gravity_y: PresentGravityFlagsEXT, + pub min_scaled_image_extent: Extent2D, + pub max_scaled_image_extent: Extent2D, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SurfacePresentScalingCapabilitiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_present_scaling: PresentScalingFlagsEXT::default(), + supported_present_gravity_x: PresentGravityFlagsEXT::default(), + supported_present_gravity_y: PresentGravityFlagsEXT::default(), + min_scaled_image_extent: Extent2D::default(), + max_scaled_image_extent: Extent2D::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SurfacePresentScalingCapabilitiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXT<'_> {} +impl<'a> SurfacePresentScalingCapabilitiesEXT<'a> { + #[inline] + pub fn supported_present_scaling( + mut self, + supported_present_scaling: PresentScalingFlagsEXT, + ) -> Self { + self.supported_present_scaling = supported_present_scaling; + self + } + #[inline] + pub fn supported_present_gravity_x( + mut self, + supported_present_gravity_x: PresentGravityFlagsEXT, + ) -> Self { + self.supported_present_gravity_x = supported_present_gravity_x; + self + } + #[inline] + pub fn supported_present_gravity_y( + mut self, + supported_present_gravity_y: PresentGravityFlagsEXT, + ) -> Self { + self.supported_present_gravity_y = supported_present_gravity_y; + self + } + #[inline] + pub fn min_scaled_image_extent(mut self, min_scaled_image_extent: Extent2D) -> Self { + self.min_scaled_image_extent = min_scaled_image_extent; + self + } + #[inline] + pub fn max_scaled_image_extent(mut self, max_scaled_image_extent: Extent2D) -> Self { + self.max_scaled_image_extent = max_scaled_image_extent; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentModeCompatibilityEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode_count: u32, + pub p_present_modes: *mut PresentModeKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SurfacePresentModeCompatibilityEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode_count: u32::default(), + p_present_modes: ::std::ptr::null_mut(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SurfacePresentModeCompatibilityEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXT<'_> {} +impl<'a> SurfacePresentModeCompatibilityEXT<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self { + self.present_mode_count = present_modes.len() as _; + self.p_present_modes = present_modes.as_mut_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_maintenance1: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_maintenance1: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'a> { + #[inline] + pub fn swapchain_maintenance1(mut self, swapchain_maintenance1: bool) -> Self { + self.swapchain_maintenance1 = swapchain_maintenance1.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentFenceInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_count: u32, + pub p_fences: *const Fence, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SwapchainPresentFenceInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_count: u32::default(), + p_fences: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SwapchainPresentFenceInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_FENCE_INFO_EXT; +} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXT<'_> {} +impl<'a> SwapchainPresentFenceInfoEXT<'a> { + #[inline] + pub fn fences(mut self, fences: &'a [Fence]) -> Self { + self.swapchain_count = fences.len() as _; + self.p_fences = fences.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentModesCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode_count: u32, + pub p_present_modes: *const PresentModeKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SwapchainPresentModesCreateInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode_count: u32::default(), + p_present_modes: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SwapchainPresentModesCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT; +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXT<'_> {} +impl<'a> SwapchainPresentModesCreateInfoEXT<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self { + self.present_mode_count = present_modes.len() as _; + self.p_present_modes = present_modes.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentModeInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_count: u32, + pub p_present_modes: *const PresentModeKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SwapchainPresentModeInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_count: u32::default(), + p_present_modes: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SwapchainPresentModeInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODE_INFO_EXT; +} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXT<'_> {} +impl<'a> SwapchainPresentModeInfoEXT<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self { + self.swapchain_count = present_modes.len() as _; + self.p_present_modes = present_modes.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentScalingCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub scaling_behavior: PresentScalingFlagsEXT, + pub present_gravity_x: PresentGravityFlagsEXT, + pub present_gravity_y: PresentGravityFlagsEXT, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SwapchainPresentScalingCreateInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + scaling_behavior: PresentScalingFlagsEXT::default(), + present_gravity_x: PresentGravityFlagsEXT::default(), + present_gravity_y: PresentGravityFlagsEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SwapchainPresentScalingCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT; +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXT<'_> {} +impl<'a> SwapchainPresentScalingCreateInfoEXT<'a> { + #[inline] + pub fn scaling_behavior(mut self, scaling_behavior: PresentScalingFlagsEXT) -> Self { + self.scaling_behavior = scaling_behavior; + self + } + #[inline] + pub fn present_gravity_x(mut self, present_gravity_x: PresentGravityFlagsEXT) -> Self { + self.present_gravity_x = present_gravity_x; + self + } + #[inline] + pub fn present_gravity_y(mut self, present_gravity_y: PresentGravityFlagsEXT) -> Self { + self.present_gravity_y = present_gravity_y; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ReleaseSwapchainImagesInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub image_index_count: u32, + pub p_image_indices: *const u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ReleaseSwapchainImagesInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + image_index_count: u32::default(), + p_image_indices: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ReleaseSwapchainImagesInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT; +} +impl<'a> ReleaseSwapchainImagesInfoEXT<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.swapchain = swapchain; + self + } + #[inline] + pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self { + self.image_index_count = image_indices.len() as _; + self.p_image_indices = image_indices.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { pub s_type: StructureType, @@ -46507,7 +46869,7 @@ pub struct DirectDriverLoadingInfoLUNARG<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: DirectDriverLoadingFlagsLUNARG, - pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddr, + pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG, pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] @@ -46531,7 +46893,7 @@ impl ::std::default::Default for DirectDriverLoadingInfoLUNARG<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), flags: DirectDriverLoadingFlagsLUNARG::default(), - pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddr::default(), + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG::default(), _marker: PhantomData, } } @@ -46548,7 +46910,7 @@ impl<'a> DirectDriverLoadingInfoLUNARG<'a> { #[inline] pub fn pfn_get_instance_proc_addr( mut self, - pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddr, + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG, ) -> Self { self.pfn_get_instance_proc_addr = pfn_get_instance_proc_addr; self diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 4801890a5..743ee928c 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -14411,6 +14411,93 @@ impl ExtShaderAtomicFloat2Fn { impl StructureType { pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000); } +impl ExtSurfaceMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_surface_maintenance1\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtSurfaceMaintenance1Fn {} +unsafe impl Send for ExtSurfaceMaintenance1Fn {} +unsafe impl Sync for ExtSurfaceMaintenance1Fn {} +impl ExtSurfaceMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_surface_maintenance1'"] +impl StructureType { + pub const SURFACE_PRESENT_MODE_EXT: Self = Self(1_000_274_000); + pub const SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: Self = Self(1_000_274_001); + pub const SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: Self = Self(1_000_274_002); +} +impl ExtSwapchainMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_maintenance1\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn( + device: Device, + p_release_info: *const ReleaseSwapchainImagesInfoEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtSwapchainMaintenance1Fn { + pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT, +} +unsafe impl Send for ExtSwapchainMaintenance1Fn {} +unsafe impl Sync for ExtSwapchainMaintenance1Fn {} +impl ExtSwapchainMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + release_swapchain_images_ext: unsafe { + unsafe extern "system" fn release_swapchain_images_ext( + _device: Device, + _p_release_info: *const ReleaseSwapchainImagesInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_swapchain_images_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkReleaseSwapchainImagesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + release_swapchain_images_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: Self = Self(1_000_275_000); + pub const SWAPCHAIN_PRESENT_FENCE_INFO_EXT: Self = Self(1_000_275_001); + pub const SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: Self = Self(1_000_275_002); + pub const SWAPCHAIN_PRESENT_MODE_INFO_EXT: Self = Self(1_000_275_003); + pub const SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: Self = Self(1_000_275_004); + pub const RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: Self = Self(1_000_275_005); +} +#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"] +impl SwapchainCreateFlagsKHR { + pub const DEFERRED_MEMORY_ALLOCATION_EXT: Self = Self(0b1000); +} impl ExtShaderDemoteToHelperInvocationFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 2826791be..bf3b3fb14 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 2826791bed6a793f164bf534cd859968f13df8a9 +Subproject commit bf3b3fb14e088c189be88edfc70f514b7d679656 From b014e8e8b4b6fccc42d3ebb6da36f0b8098a85c4 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Mon, 19 Dec 2022 13:35:51 +0100 Subject: [PATCH 3/3] Update Vulkan-Headers to 1.3.238 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/vk/bitflags.rs | 8 +- ash/src/vk/const_debugs.rs | 54 +++++------ ash/src/vk/definitions.rs | 188 ++++++++++++++++++------------------- ash/src/vk/extensions.rs | 68 +++++++------- generator/Vulkan-Headers | 2 +- 7 files changed, 159 insertions(+), 165 deletions(-) diff --git a/Changelog.md b/Changelog.md index 7fdf75c85..8a2214984 100644 --- a/Changelog.md +++ b/Changelog.md @@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added -- Update Vulkan-Headers to 1.3.237 (#688) +- Update Vulkan-Headers to 1.3.238 (#688) ### Removed diff --git a/ash/Cargo.toml b/ash/Cargo.toml index b95090155..b38fe08e5 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.237" +version = "0.37.0+1.3.238" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT OR Apache-2.0" diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index ff1127e9b..66699d721 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1211,10 +1211,10 @@ impl VideoSessionCreateFlagsKHR { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags); -vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, Flags); -impl VideoDecodeH264PictureLayoutFlagsEXT { +#[doc = ""] +pub struct VideoDecodeH264PictureLayoutFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsKHR, Flags); +impl VideoDecodeH264PictureLayoutFlagsKHR { pub const PROGRESSIVE: Self = Self(0); pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1); pub const INTERLACED_SEPARATE_PLANES: Self = Self(0b10); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 9f633330d..d23cde4a3 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -4683,17 +4683,17 @@ 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_DECODE_H264_CAPABILITIES_EXT => Some("VIDEO_DECODE_H264_CAPABILITIES_EXT"), - Self::VIDEO_DECODE_H264_PICTURE_INFO_EXT => Some("VIDEO_DECODE_H264_PICTURE_INFO_EXT"), - Self::VIDEO_DECODE_H264_PROFILE_INFO_EXT => Some("VIDEO_DECODE_H264_PROFILE_INFO_EXT"), - Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => { - Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_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"), + Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR") } - Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => { - Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT") + Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR => { + Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR") } - Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT => { - Some("VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT") + Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR => { + Some("VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR") } Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") @@ -5061,17 +5061,17 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => { Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD") } - Self::VIDEO_DECODE_H265_CAPABILITIES_EXT => Some("VIDEO_DECODE_H265_CAPABILITIES_EXT"), - Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { - Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") + Self::VIDEO_DECODE_H265_CAPABILITIES_KHR => Some("VIDEO_DECODE_H265_CAPABILITIES_KHR"), + Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR") } - Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => { - Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT") + Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR => { + Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR") } - Self::VIDEO_DECODE_H265_PROFILE_INFO_EXT => Some("VIDEO_DECODE_H265_PROFILE_INFO_EXT"), - Self::VIDEO_DECODE_H265_PICTURE_INFO_EXT => Some("VIDEO_DECODE_H265_PICTURE_INFO_EXT"), - Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT => { - Some("VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT") + Self::VIDEO_DECODE_H265_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H265_PROFILE_INFO_KHR"), + Self::VIDEO_DECODE_H265_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H265_PICTURE_INFO_KHR"), + Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR => { + Some("VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR") } Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR => { Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR") @@ -6518,14 +6518,8 @@ impl fmt::Debug for VideoCodecOperationFlagsKHR { VideoCodecOperationFlagsKHR::ENCODE_H265_EXT.0, "ENCODE_H265_EXT", ), - ( - VideoCodecOperationFlagsKHR::DECODE_H264_EXT.0, - "DECODE_H264_EXT", - ), - ( - VideoCodecOperationFlagsKHR::DECODE_H265_EXT.0, - "DECODE_H265_EXT", - ), + (VideoCodecOperationFlagsKHR::DECODE_H264.0, "DECODE_H264"), + (VideoCodecOperationFlagsKHR::DECODE_H265.0, "DECODE_H265"), ]; debug_flags(f, KNOWN, self.0) } @@ -6578,19 +6572,19 @@ impl fmt::Debug for VideoDecodeFlagsKHR { debug_flags(f, KNOWN, self.0) } } -impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsEXT { +impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - VideoDecodeH264PictureLayoutFlagsEXT::PROGRESSIVE.0, + VideoDecodeH264PictureLayoutFlagsKHR::PROGRESSIVE.0, "PROGRESSIVE", ), ( - VideoDecodeH264PictureLayoutFlagsEXT::INTERLACED_INTERLEAVED_LINES.0, + VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_INTERLEAVED_LINES.0, "INTERLACED_INTERLEAVED_LINES", ), ( - VideoDecodeH264PictureLayoutFlagsEXT::INTERLACED_SEPARATE_PLANES.0, + VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_SEPARATE_PLANES.0, "INTERLACED_SEPARATE_PLANES", ), ]; diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index d2cf7445f..040aef00a 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -57,7 +57,7 @@ pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); -pub const HEADER_VERSION: u32 = 237u32; +pub const HEADER_VERSION: u32 = 238u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -36488,39 +36488,39 @@ impl<'a> VideoDecodeInfoKHR<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264ProfileInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH264ProfileInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_profile_idc: StdVideoH264ProfileIdc, - pub picture_layout: VideoDecodeH264PictureLayoutFlagsEXT, + pub picture_layout: VideoDecodeH264PictureLayoutFlagsKHR, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264ProfileInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH264ProfileInfoKHR<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), std_profile_idc: StdVideoH264ProfileIdc::default(), - picture_layout: VideoDecodeH264PictureLayoutFlagsEXT::default(), + picture_layout: VideoDecodeH264PictureLayoutFlagsKHR::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH264ProfileInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PROFILE_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH264ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PROFILE_INFO_KHR; } -unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoEXT<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoEXT<'_> {} -impl<'a> VideoDecodeH264ProfileInfoEXT<'a> { +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHR<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHR<'_> {} +impl<'a> VideoDecodeH264ProfileInfoKHR<'a> { #[inline] pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self { self.std_profile_idc = std_profile_idc; self } #[inline] - pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsEXT) -> Self { + pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsKHR) -> Self { self.picture_layout = picture_layout; self } @@ -36528,15 +36528,15 @@ impl<'a> VideoDecodeH264ProfileInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264CapabilitiesEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH264CapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_level_idc: StdVideoH264LevelIdc, pub field_offset_granularity: Offset2D, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT<'_> { +impl ::std::default::Default for VideoDecodeH264CapabilitiesKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36548,11 +36548,11 @@ impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH264CapabilitiesEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_CAPABILITIES_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH264CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_CAPABILITIES_KHR; } -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT<'_> {} -impl<'a> VideoDecodeH264CapabilitiesEXT<'a> { +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHR<'_> {} +impl<'a> VideoDecodeH264CapabilitiesKHR<'a> { #[inline] pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self { self.max_level_idc = max_level_idc; @@ -36567,8 +36567,8 @@ impl<'a> VideoDecodeH264CapabilitiesEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264SessionParametersAddInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH264SessionParametersAddInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_sps_count: u32, @@ -36577,7 +36577,7 @@ pub struct VideoDecodeH264SessionParametersAddInfoEXT<'a> { pub p_std_pp_ss: *const StdVideoH264PictureParameterSet, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36591,15 +36591,15 @@ impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT<'_> } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH264SessionParametersAddInfoEXT<'a> { +unsafe impl<'a> TaggedStructure for VideoDecodeH264SessionParametersAddInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT; + StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; } unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoDecodeH264SessionParametersAddInfoEXT<'_> + for VideoDecodeH264SessionParametersAddInfoKHR<'_> { } -impl<'a> VideoDecodeH264SessionParametersAddInfoEXT<'a> { +impl<'a> VideoDecodeH264SessionParametersAddInfoKHR<'a> { #[inline] pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self { self.std_sps_count = std_sp_ss.len() as _; @@ -36616,16 +36616,16 @@ impl<'a> VideoDecodeH264SessionParametersAddInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264SessionParametersCreateInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH264SessionParametersCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_std_sps_count: u32, pub max_std_pps_count: u32, - pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoEXT<'a>, + pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoKHR<'a>, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36638,15 +36638,15 @@ impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT<' } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH264SessionParametersCreateInfoEXT<'a> { +unsafe impl<'a> TaggedStructure for VideoDecodeH264SessionParametersCreateInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT; + StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; } unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoDecodeH264SessionParametersCreateInfoEXT<'_> + for VideoDecodeH264SessionParametersCreateInfoKHR<'_> { } -impl<'a> VideoDecodeH264SessionParametersCreateInfoEXT<'a> { +impl<'a> VideoDecodeH264SessionParametersCreateInfoKHR<'a> { #[inline] pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { self.max_std_sps_count = max_std_sps_count; @@ -36660,7 +36660,7 @@ impl<'a> VideoDecodeH264SessionParametersCreateInfoEXT<'a> { #[inline] pub fn parameters_add_info( mut self, - parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoEXT<'a>, + parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoKHR<'a>, ) -> Self { self.p_parameters_add_info = parameters_add_info; self @@ -36669,8 +36669,8 @@ impl<'a> VideoDecodeH264SessionParametersCreateInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264PictureInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH264PictureInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo, @@ -36678,7 +36678,7 @@ pub struct VideoDecodeH264PictureInfoEXT<'a> { pub p_slice_offsets: *const u32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264PictureInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH264PictureInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36691,11 +36691,11 @@ impl ::std::default::Default for VideoDecodeH264PictureInfoEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH264PictureInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PICTURE_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH264PictureInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PICTURE_INFO_KHR; } -unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT<'_> {} -impl<'a> VideoDecodeH264PictureInfoEXT<'a> { +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHR<'_> {} +impl<'a> VideoDecodeH264PictureInfoKHR<'a> { #[inline] pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self { self.p_std_picture_info = std_picture_info; @@ -36711,14 +36711,14 @@ impl<'a> VideoDecodeH264PictureInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264DpbSlotInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH264DpbSlotInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264DpbSlotInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH264DpbSlotInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36729,11 +36729,11 @@ impl ::std::default::Default for VideoDecodeH264DpbSlotInfoEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH264DpbSlotInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH264DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; } -unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoEXT<'_> {} -impl<'a> VideoDecodeH264DpbSlotInfoEXT<'a> { +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHR<'_> {} +impl<'a> VideoDecodeH264DpbSlotInfoKHR<'a> { #[inline] pub fn std_reference_info( mut self, @@ -36746,14 +36746,14 @@ impl<'a> VideoDecodeH264DpbSlotInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH265ProfileInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH265ProfileInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_profile_idc: StdVideoH265ProfileIdc, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265ProfileInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH265ProfileInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36764,12 +36764,12 @@ impl ::std::default::Default for VideoDecodeH265ProfileInfoEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH265ProfileInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PROFILE_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH265ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PROFILE_INFO_KHR; } -unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoEXT<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoEXT<'_> {} -impl<'a> VideoDecodeH265ProfileInfoEXT<'a> { +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHR<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHR<'_> {} +impl<'a> VideoDecodeH265ProfileInfoKHR<'a> { #[inline] pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { self.std_profile_idc = std_profile_idc; @@ -36779,14 +36779,14 @@ impl<'a> VideoDecodeH265ProfileInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH265CapabilitiesEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH265CapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_level_idc: StdVideoH265LevelIdc, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT<'_> { +impl ::std::default::Default for VideoDecodeH265CapabilitiesKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36797,11 +36797,11 @@ impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH265CapabilitiesEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_CAPABILITIES_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH265CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_CAPABILITIES_KHR; } -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT<'_> {} -impl<'a> VideoDecodeH265CapabilitiesEXT<'a> { +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHR<'_> {} +impl<'a> VideoDecodeH265CapabilitiesKHR<'a> { #[inline] pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self { self.max_level_idc = max_level_idc; @@ -36811,8 +36811,8 @@ impl<'a> VideoDecodeH265CapabilitiesEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH265SessionParametersAddInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH265SessionParametersAddInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_vps_count: u32, @@ -36823,7 +36823,7 @@ pub struct VideoDecodeH265SessionParametersAddInfoEXT<'a> { pub p_std_pp_ss: *const StdVideoH265PictureParameterSet, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36839,15 +36839,15 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT<'_> } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH265SessionParametersAddInfoEXT<'a> { +unsafe impl<'a> TaggedStructure for VideoDecodeH265SessionParametersAddInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT; + StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; } unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoDecodeH265SessionParametersAddInfoEXT<'_> + for VideoDecodeH265SessionParametersAddInfoKHR<'_> { } -impl<'a> VideoDecodeH265SessionParametersAddInfoEXT<'a> { +impl<'a> VideoDecodeH265SessionParametersAddInfoKHR<'a> { #[inline] pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self { self.std_vps_count = std_vp_ss.len() as _; @@ -36870,17 +36870,17 @@ impl<'a> VideoDecodeH265SessionParametersAddInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH265SessionParametersCreateInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH265SessionParametersCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_std_vps_count: u32, pub max_std_sps_count: u32, pub max_std_pps_count: u32, - pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT<'a>, + pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoKHR<'a>, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36894,15 +36894,15 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT<' } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH265SessionParametersCreateInfoEXT<'a> { +unsafe impl<'a> TaggedStructure for VideoDecodeH265SessionParametersCreateInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT; + StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; } unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoDecodeH265SessionParametersCreateInfoEXT<'_> + for VideoDecodeH265SessionParametersCreateInfoKHR<'_> { } -impl<'a> VideoDecodeH265SessionParametersCreateInfoEXT<'a> { +impl<'a> VideoDecodeH265SessionParametersCreateInfoKHR<'a> { #[inline] pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { self.max_std_vps_count = max_std_vps_count; @@ -36921,7 +36921,7 @@ impl<'a> VideoDecodeH265SessionParametersCreateInfoEXT<'a> { #[inline] pub fn parameters_add_info( mut self, - parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoEXT<'a>, + parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoKHR<'a>, ) -> Self { self.p_parameters_add_info = parameters_add_info; self @@ -36930,8 +36930,8 @@ impl<'a> VideoDecodeH265SessionParametersCreateInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH265PictureInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH265PictureInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo, @@ -36939,7 +36939,7 @@ pub struct VideoDecodeH265PictureInfoEXT<'a> { pub p_slice_segment_offsets: *const u32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265PictureInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH265PictureInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36952,11 +36952,11 @@ impl ::std::default::Default for VideoDecodeH265PictureInfoEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH265PictureInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PICTURE_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH265PictureInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PICTURE_INFO_KHR; } -unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXT<'_> {} -impl<'a> VideoDecodeH265PictureInfoEXT<'a> { +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHR<'_> {} +impl<'a> VideoDecodeH265PictureInfoKHR<'a> { #[inline] pub fn std_picture_info( mut self, @@ -36975,14 +36975,14 @@ impl<'a> VideoDecodeH265PictureInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH265DpbSlotInfoEXT<'a> { +#[doc = ""] +pub struct VideoDecodeH265DpbSlotInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265DpbSlotInfoEXT<'_> { +impl ::std::default::Default for VideoDecodeH265DpbSlotInfoKHR<'_> { #[inline] fn default() -> Self { Self { @@ -36993,11 +36993,11 @@ impl ::std::default::Default for VideoDecodeH265DpbSlotInfoEXT<'_> { } } } -unsafe impl<'a> TaggedStructure for VideoDecodeH265DpbSlotInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT; +unsafe impl<'a> TaggedStructure for VideoDecodeH265DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; } -unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoEXT<'_> {} -impl<'a> VideoDecodeH265DpbSlotInfoEXT<'a> { +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHR<'_> {} +impl<'a> VideoDecodeH265DpbSlotInfoKHR<'a> { #[inline] pub fn std_reference_info( mut self, diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 743ee928c..16a375e2b 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -1770,7 +1770,7 @@ impl KhrVideoQueueFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") } } - pub const SPEC_VERSION: u32 = 7u32; + pub const SPEC_VERSION: u32 = 8u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn( @@ -2172,7 +2172,7 @@ impl KhrVideoDecodeQueueFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_queue\0") } } - pub const SPEC_VERSION: u32 = 6u32; + pub const SPEC_VERSION: u32 = 7u32; } #[allow(non_camel_case_types)] pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn( @@ -3013,18 +3013,18 @@ impl StructureType { impl VideoCodecOperationFlagsKHR { pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000); } -impl ExtVideoDecodeH264Fn { +impl KhrVideoDecodeH264Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h264\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h264\0") } } - pub const SPEC_VERSION: u32 = 7u32; + pub const SPEC_VERSION: u32 = 8u32; } #[derive(Clone)] -pub struct ExtVideoDecodeH264Fn {} -unsafe impl Send for ExtVideoDecodeH264Fn {} -unsafe impl Sync for ExtVideoDecodeH264Fn {} -impl ExtVideoDecodeH264Fn { +pub struct KhrVideoDecodeH264Fn {} +unsafe impl Send for KhrVideoDecodeH264Fn {} +unsafe impl Sync for KhrVideoDecodeH264Fn {} +impl KhrVideoDecodeH264Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -3032,18 +3032,18 @@ impl ExtVideoDecodeH264Fn { Self {} } } -#[doc = "Generated from 'VK_EXT_video_decode_h264'"] +#[doc = "Generated from 'VK_KHR_video_decode_h264'"] impl StructureType { - pub const VIDEO_DECODE_H264_CAPABILITIES_EXT: Self = Self(1_000_040_000); - pub const VIDEO_DECODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_040_001); - pub const VIDEO_DECODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_040_003); - pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_040_004); - pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_040_005); - pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_040_006); + pub const VIDEO_DECODE_H264_CAPABILITIES_KHR: Self = Self(1_000_040_000); + pub const VIDEO_DECODE_H264_PICTURE_INFO_KHR: Self = Self(1_000_040_001); + pub const VIDEO_DECODE_H264_PROFILE_INFO_KHR: Self = Self(1_000_040_003); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_040_004); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_040_005); + pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: Self = Self(1_000_040_006); } -#[doc = "Generated from 'VK_EXT_video_decode_h264'"] +#[doc = "Generated from 'VK_KHR_video_decode_h264'"] impl VideoCodecOperationFlagsKHR { - pub const DECODE_H264_EXT: Self = Self(0b1); + pub const DECODE_H264: Self = Self(0b1); } impl AmdTextureGatherBiasLodFn { #[inline] @@ -10983,18 +10983,18 @@ impl AmdShaderCorePropertiesFn { impl StructureType { pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000); } -impl ExtVideoDecodeH265Fn { +impl KhrVideoDecodeH265Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h265\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h265\0") } } - pub const SPEC_VERSION: u32 = 6u32; + pub const SPEC_VERSION: u32 = 7u32; } #[derive(Clone)] -pub struct ExtVideoDecodeH265Fn {} -unsafe impl Send for ExtVideoDecodeH265Fn {} -unsafe impl Sync for ExtVideoDecodeH265Fn {} -impl ExtVideoDecodeH265Fn { +pub struct KhrVideoDecodeH265Fn {} +unsafe impl Send for KhrVideoDecodeH265Fn {} +unsafe impl Sync for KhrVideoDecodeH265Fn {} +impl KhrVideoDecodeH265Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -11002,18 +11002,18 @@ impl ExtVideoDecodeH265Fn { Self {} } } -#[doc = "Generated from 'VK_EXT_video_decode_h265'"] +#[doc = "Generated from 'VK_KHR_video_decode_h265'"] impl StructureType { - pub const VIDEO_DECODE_H265_CAPABILITIES_EXT: Self = Self(1_000_187_000); - pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_187_001); - pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_187_002); - pub const VIDEO_DECODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_187_003); - pub const VIDEO_DECODE_H265_PICTURE_INFO_EXT: Self = Self(1_000_187_004); - pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_187_005); + pub const VIDEO_DECODE_H265_CAPABILITIES_KHR: Self = Self(1_000_187_000); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_187_001); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_187_002); + pub const VIDEO_DECODE_H265_PROFILE_INFO_KHR: Self = Self(1_000_187_003); + pub const VIDEO_DECODE_H265_PICTURE_INFO_KHR: Self = Self(1_000_187_004); + pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: Self = Self(1_000_187_005); } -#[doc = "Generated from 'VK_EXT_video_decode_h265'"] +#[doc = "Generated from 'VK_KHR_video_decode_h265'"] impl VideoCodecOperationFlagsKHR { - pub const DECODE_H265_EXT: Self = Self(0b10); + pub const DECODE_H265: Self = Self(0b10); } impl KhrGlobalPriorityFn { #[inline] diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index bf3b3fb14..00671c64b 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit bf3b3fb14e088c189be88edfc70f514b7d679656 +Subproject commit 00671c64ba5c488ade22ad572a0ef81d5e64c803