alex/ash
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Update Vulkan-Headers to 1.3.238 (#688)

Browse source 
* Update Vulkan-Headers to 1.3.236

* Update Vulkan-Headers to 1.3.237

* Update Vulkan-Headers to 1.3.238
This commit is contained in:
Marijn Suijten 2022-12-19 19:42:05 +01:00 committed by GitHub
parent 4ba8df1af8
commit 720eb81048
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 924 additions and 171 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Changelog.md
View file

@ -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.238 (#688)
### Removed
- Removed all code generated for `"disabled"` extensions, typically with a number rather than a descriptive name (#448)

2
ash/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ash"
version = "0.37.0+1.3.235"
version = "0.37.0+1.3.238"
authors = ["maik klein <maikklein@googlemail.com>"]
description = "Vulkan bindings for Rust"
license = "MIT OR Apache-2.0"

28
ash/src/vk/bitflags.rs
View file

@ -1143,6 +1143,26 @@ impl DeviceAddressBindingFlagsEXT {
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentScalingFlagBitsEXT.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentGravityFlagBitsEXT.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"]
pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags);
@ -1191,10 +1211,10 @@ impl VideoSessionCreateFlagsKHR {
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsEXT.html>"]
pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, Flags);
impl VideoDecodeH264PictureLayoutFlagsEXT {
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsKHR.html>"]
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);

125
ash/src/vk/const_debugs.rs
View file

@ -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)] = &[];
@ -3746,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 {
@ -3764,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 {
@ -4640,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")
@ -5018,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")
@ -5230,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")
}
@ -5661,6 +5723,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 +5769,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")
}
@ -6217,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)
}
@ -6447,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)
}
@ -6507,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",
),
];

707
ash/src/vk/definitions.rs
View file

File diff suppressed because it is too large Load diff

18
ash/src/vk/enums.rs
View file

@ -1103,6 +1103,24 @@ impl RayTracingInvocationReorderModeNV {
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingModeLUNARG.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreType.html>"]
pub struct SemaphoreType(pub(crate) i32);
impl SemaphoreType {

209
ash/src/vk/extensions.rs
View file

@ -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<F>(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 = 5u32;
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<F>(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]
@ -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<F>(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<F>(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 {
@ -20817,6 +20904,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<F>(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 +21439,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<F>(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 {

2
generator/Vulkan-Headers

@ -1 +1 @@
Subproject commit b7a86d3b2bf8fbe73fcd40df9ec62a5966e9db89
Subproject commit 00671c64ba5c488ade22ad572a0ef81d5e64c803