diff --git a/Changelog.md b/Changelog.md index b5abc3c..ee9d615 100644 --- a/Changelog.md +++ b/Changelog.md @@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- Update Vulkan-Headers to 1.3.208 (#597) - Added `VK_EXT_headless_surface` instance extension (#589) ## [0.36.0] - 2022-02-21 diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 25cc12a..d8a24b5 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.36.0+1.3.206" +version = "0.36.0+1.3.208" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT" diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index 4a6fcc8..5d7bf6d 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1193,6 +1193,16 @@ impl VideoCodingControlFlagsKHR { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeCapabilityFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeCapabilityFlagsKHR, Flags); +impl VideoDecodeCapabilityFlagsKHR { + pub const DEFAULT: Self = Self(0); + pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(0b1); + pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct VideoDecodeFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags); @@ -1490,3 +1500,9 @@ impl VideoEncodeH265TransformBlockSizeFlagsEXT { pub const TYPE_16: Self = Self(0b100); pub const TYPE_32: Self = Self(0b1000); } +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct InstanceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(InstanceCreateFlags, Flags); +impl InstanceCreateFlags {} diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index d7da276..83a5f13 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -2141,6 +2141,7 @@ impl fmt::Debug for ImageCreateFlags { ), (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), (ImageCreateFlags::RESERVED_16_AMD.0, "RESERVED_16_AMD"), + (ImageCreateFlags::RESERVED_18_EXT.0, "RESERVED_18_EXT"), (ImageCreateFlags::RESERVED_394_EXT.0, "RESERVED_394_EXT"), ( ImageCreateFlags::FRAGMENT_DENSITY_MAP_OFFSET_QCOM.0, @@ -2292,6 +2293,7 @@ impl fmt::Debug for ImageUsageFlags { ImageUsageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", ), + (ImageUsageFlags::RESERVED_22_EXT.0, "RESERVED_22_EXT"), ( ImageUsageFlags::VIDEO_ENCODE_DST_KHR.0, "VIDEO_ENCODE_DST_KHR", @@ -2414,7 +2416,10 @@ impl fmt::Debug for IndirectStateFlagsNV { } impl fmt::Debug for InstanceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[]; + const KNOWN: &[(Flags, &str)] = &[( + InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR.0, + "ENUMERATE_PORTABILITY_KHR", + )]; debug_flags(f, KNOWN, self.0) } } @@ -3988,6 +3993,7 @@ impl fmt::Debug for StructureType { Some("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR") } Self::VIDEO_DECODE_INFO_KHR => Some("VIDEO_DECODE_INFO_KHR"), + Self::VIDEO_DECODE_CAPABILITIES_KHR => Some("VIDEO_DECODE_CAPABILITIES_KHR"), Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") } @@ -4898,6 +4904,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE") + } + Self::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE => { + Some("DESCRIPTOR_SET_BINDING_REFERENCE_VALVE") + } + Self::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE => { + Some("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE") + } Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => { Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM") } @@ -5642,6 +5657,22 @@ impl fmt::Debug for VideoComponentBitDepthFlagsKHR { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for VideoDecodeCapabilityFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoDecodeCapabilityFlagsKHR::DEFAULT.0, "DEFAULT"), + ( + VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_COINCIDE.0, + "DPB_AND_OUTPUT_COINCIDE", + ), + ( + VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_DISTINCT.0, + "DPB_AND_OUTPUT_DISTINCT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for VideoDecodeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 1c3c9e9..a70b321 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -56,7 +56,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 = 206u32; +pub const HEADER_VERSION: u32 = 208u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -118,11 +118,6 @@ pub struct BufferViewCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(BufferViewCreateFlags, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct InstanceCreateFlags(pub(crate) Flags); -vk_bitflags_wrapped!(InstanceCreateFlags, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct DeviceCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(DeviceCreateFlags, Flags); @@ -48546,12 +48541,9 @@ impl<'a> ::std::ops::DerefMut for VideoProfilesKHRBuilder<'a> { } } impl<'a> VideoProfilesKHRBuilder<'a> { - pub fn profile_count(mut self, profile_count: u32) -> Self { - self.inner.profile_count = profile_count; - self - } - pub fn profiles(mut self, profiles: &'a VideoProfileKHR) -> Self { - self.inner.p_profiles = profiles; + pub fn profiles(mut self, profiles: &'a [VideoProfileKHR]) -> Self { + self.inner.profile_count = profiles.len() as _; + self.inner.p_profiles = profiles.as_ptr(); self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] @@ -49186,6 +49178,77 @@ impl<'a> VideoReferenceSlotKHRBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoDecodeCapabilityFlagsKHR, +} +impl ::std::default::Default for VideoDecodeCapabilitiesKHR { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_DECODE_CAPABILITIES_KHR, + p_next: ::std::ptr::null_mut(), + flags: VideoDecodeCapabilityFlagsKHR::default(), + } + } +} +impl VideoDecodeCapabilitiesKHR { + pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> { + VideoDecodeCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeCapabilitiesKHRBuilder<'a> { + inner: VideoDecodeCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {} +pub unsafe trait ExtendsVideoDecodeCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> { + type Target = VideoDecodeCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> { + pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct VideoDecodeInfoKHR { pub s_type: StructureType, @@ -49410,8 +49473,8 @@ pub struct VideoDecodeH264CapabilitiesEXTBuilder<'a> { inner: VideoDecodeH264CapabilitiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesEXTBuilder<'_> {} -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT {} +unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesEXTBuilder<'a> { type Target = VideoDecodeH264CapabilitiesEXT; fn deref(&self) -> &Self::Target { @@ -49950,8 +50013,8 @@ pub struct VideoDecodeH265CapabilitiesEXTBuilder<'a> { inner: VideoDecodeH265CapabilitiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesEXTBuilder<'_> {} -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT {} +unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesEXTBuilder<'a> { type Target = VideoDecodeH265CapabilitiesEXT; fn deref(&self) -> &Self::Target { @@ -57193,3 +57256,187 @@ impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { self.inner } } +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_set_host_mapping: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, + p_next: ::std::ptr::null_mut(), + descriptor_set_host_mapping: Bool32::default(), + } + } +} +impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self { + self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetBindingReferenceVALVE { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_set_layout: DescriptorSetLayout, + pub binding: u32, +} +impl ::std::default::Default for DescriptorSetBindingReferenceVALVE { + fn default() -> Self { + Self { + s_type: StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE, + p_next: ::std::ptr::null(), + descriptor_set_layout: DescriptorSetLayout::default(), + binding: u32::default(), + } + } +} +impl DescriptorSetBindingReferenceVALVE { + pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> { + DescriptorSetBindingReferenceVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> { + inner: DescriptorSetBindingReferenceVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> { + type Target = DescriptorSetBindingReferenceVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> { + pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { + self.inner.descriptor_set_layout = descriptor_set_layout; + self + } + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetBindingReferenceVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutHostMappingInfoVALVE { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_offset: usize, + pub descriptor_size: u32, +} +impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE { + fn default() -> Self { + Self { + s_type: StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE, + p_next: ::std::ptr::null_mut(), + descriptor_offset: usize::default(), + descriptor_size: u32::default(), + } + } +} +impl DescriptorSetLayoutHostMappingInfoVALVE { + pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + DescriptorSetLayoutHostMappingInfoVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + inner: DescriptorSetLayoutHostMappingInfoVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + type Target = DescriptorSetLayoutHostMappingInfoVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self { + self.inner.descriptor_offset = descriptor_offset; + self + } + pub fn descriptor_size(mut self, descriptor_size: u32) -> Self { + self.inner.descriptor_size = descriptor_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE { + self.inner + } +} diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 8e6c90b..6e71906 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -2861,7 +2861,7 @@ impl KhrVideoDecodeQueueFn { pub 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 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[allow(non_camel_case_types)] pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn( @@ -2950,6 +2950,7 @@ impl QueueFlags { #[doc = "Generated from 'VK_KHR_video_decode_queue'"] impl StructureType { pub const VIDEO_DECODE_INFO_KHR: Self = Self(1_000_024_000); + pub const VIDEO_DECODE_CAPABILITIES_KHR: Self = Self(1_000_024_001); } impl AmdGcnShaderFn { pub fn name() -> &'static ::std::ffi::CStr { @@ -9654,7 +9655,7 @@ impl AndroidExternalMemoryAndroidHardwareBufferFn { ) } } - pub const SPEC_VERSION: u32 = 4u32; + pub const SPEC_VERSION: u32 = 5u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn( @@ -18459,6 +18460,10 @@ impl IntelExtension271Fn { Self {} } } +#[doc = "Generated from 'VK_INTEL_extension_271'"] +impl ImageUsageFlags { + pub const RESERVED_22_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); +} impl IntelExtension272Fn { pub fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_272\0") } @@ -22771,6 +22776,10 @@ impl ExtExtension377Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_extension_377'"] +impl ImageCreateFlags { + pub const RESERVED_18_EXT: Self = Self(0b100_0000_0000_0000_0000); +} impl ExtExtendedDynamicState2Fn { pub fn name() -> &'static ::std::ffi::CStr { unsafe { @@ -23524,17 +23533,19 @@ impl ExtExtension394Fn { impl ImageCreateFlags { pub const RESERVED_394_EXT: Self = Self(0b10_0000_0000_0000_0000); } -impl KhrExtension395Fn { +impl KhrPortabilityEnumerationFn { pub fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_395\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_enumeration\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct KhrExtension395Fn {} -unsafe impl Send for KhrExtension395Fn {} -unsafe impl Sync for KhrExtension395Fn {} -impl KhrExtension395Fn { +pub struct KhrPortabilityEnumerationFn {} +unsafe impl Send for KhrPortabilityEnumerationFn {} +unsafe impl Sync for KhrPortabilityEnumerationFn {} +impl KhrPortabilityEnumerationFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -23542,6 +23553,10 @@ impl KhrExtension395Fn { Self {} } } +#[doc = "Generated from 'VK_KHR_portability_enumeration'"] +impl InstanceCreateFlags { + pub const ENUMERATE_PORTABILITY_KHR: Self = Self(0b1); +} impl KhrExtension396Fn { pub fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_396\0") } @@ -24184,23 +24199,115 @@ impl ExtExtension420Fn { Self {} } } -impl KhrExtension421Fn { +impl ValveDescriptorSetHostMappingFn { pub fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_421\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_VALVE_descriptor_set_host_mapping\0", + ) + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn( + device: Device, + p_binding_reference: *const DescriptorSetBindingReferenceVALVE, + p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn( + device: Device, + descriptor_set: DescriptorSet, + pp_data: *mut *mut c_void, +); #[derive(Clone)] -pub struct KhrExtension421Fn {} -unsafe impl Send for KhrExtension421Fn {} -unsafe impl Sync for KhrExtension421Fn {} -impl KhrExtension421Fn { +pub struct ValveDescriptorSetHostMappingFn { + pub get_descriptor_set_layout_host_mapping_info_valve: + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE, + pub get_descriptor_set_host_mapping_valve: PFN_vkGetDescriptorSetHostMappingVALVE, +} +unsafe impl Send for ValveDescriptorSetHostMappingFn {} +unsafe impl Sync for ValveDescriptorSetHostMappingFn {} +impl ValveDescriptorSetHostMappingFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_descriptor_set_layout_host_mapping_info_valve: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_host_mapping_info_valve( + _device: Device, + _p_binding_reference: *const DescriptorSetBindingReferenceVALVE, + _p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_host_mapping_info_valve) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutHostMappingInfoVALVE\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_host_mapping_info_valve + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_host_mapping_valve: unsafe { + unsafe extern "system" fn get_descriptor_set_host_mapping_valve( + _device: Device, + _descriptor_set: DescriptorSet, + _pp_data: *mut *mut c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_host_mapping_valve) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetHostMappingVALVE\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_host_mapping_valve + } else { + ::std::mem::transmute(val) + } + }, + } } + #[doc = ""] + pub unsafe fn get_descriptor_set_layout_host_mapping_info_valve( + &self, + device: Device, + p_binding_reference: *const DescriptorSetBindingReferenceVALVE, + p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE, + ) { + (self.get_descriptor_set_layout_host_mapping_info_valve)( + device, + p_binding_reference, + p_host_mapping, + ) + } + #[doc = ""] + pub unsafe fn get_descriptor_set_host_mapping_valve( + &self, + device: Device, + descriptor_set: DescriptorSet, + pp_data: *mut *mut c_void, + ) { + (self.get_descriptor_set_host_mapping_valve)(device, descriptor_set, pp_data) + } +} +#[doc = "Generated from 'VK_VALVE_descriptor_set_host_mapping'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self = + Self(1_000_420_000); + pub const DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: Self = Self(1_000_420_001); + pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: Self = Self(1_000_420_002); } impl ExtExtension422Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -24875,3 +24982,93 @@ impl GoogleExtension455Fn { Self {} } } +impl NvExtension456Fn { + pub fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_456\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension456Fn {} +unsafe impl Send for NvExtension456Fn {} +unsafe impl Sync for NvExtension456Fn {} +impl NvExtension456Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension457Fn { + pub fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_457\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension457Fn {} +unsafe impl Send for ExtExtension457Fn {} +unsafe impl Sync for ExtExtension457Fn {} +impl ExtExtension457Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension458Fn { + pub fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_458\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension458Fn {} +unsafe impl Send for ExtExtension458Fn {} +unsafe impl Sync for ExtExtension458Fn {} +impl ExtExtension458Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension459Fn { + pub fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_459\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension459Fn {} +unsafe impl Send for ArmExtension459Fn {} +unsafe impl Sync for ArmExtension459Fn {} +impl ArmExtension459Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension460Fn { + pub fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_460\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension460Fn {} +unsafe impl Send for ExtExtension460Fn {} +unsafe impl Sync for ExtExtension460Fn {} +impl ExtExtension460Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index aa18f18..384881c 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit aa18f182ebba65438b1cfdbd571f020bb2e34d04 +Subproject commit 384881cc90fe243b4d29bfbc359f59752c2be995