From a7d5c4902994562fc31ebe6e4f4a3deb06344547 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Mon, 20 Dec 2021 16:53:29 +0100 Subject: [PATCH] Update Vulkan-Headers to 1.2.203 --- ash/src/vk/bitflags.rs | 1 - ash/src/vk/const_debugs.rs | 52 ++++-- ash/src/vk/definitions.rs | 332 ++++++++++++++++++++++++++++++++++++- ash/src/vk/extensions.rs | 324 +++++++++++++++++++++++++++++++++--- generator/Vulkan-Headers | 2 +- generator/src/lib.rs | 18 ++ 6 files changed, 690 insertions(+), 39 deletions(-) diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index b2745fa..cf9d121 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1189,7 +1189,6 @@ impl VideoEncodeH264CapabilityFlagsEXT { pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b1_0000_0000); pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b10_0000_0000); pub const EVENLY_DISTRIBUTED_SLICE_SIZE: Self = Self(0b100_0000_0000); - pub const OPTIONAL_RC_EXTENSION_STRUCT: Self = Self(0b1000_0000_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index f1309e3..93be0d5 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -768,10 +768,16 @@ impl fmt::Debug for CommandPoolCreateFlags { } impl fmt::Debug for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + ), + ( + CommandPoolResetFlags::RESERVED_1_COREAVI.0, + "RESERVED_1_COREAVI", + ), + ]; debug_flags(f, KNOWN, self.0) } } @@ -1238,7 +1244,10 @@ impl fmt::Debug for DeviceMemoryReportFlagsEXT { } impl fmt::Debug for DeviceQueueCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + const KNOWN: &[(Flags, &str)] = &[ + (DeviceQueueCreateFlags::RESERVED_1_QCOM.0, "RESERVED_1_QCOM"), + (DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED"), + ]; debug_flags(f, KNOWN, self.0) } } @@ -1938,7 +1947,7 @@ impl fmt::Debug for FormatFeatureFlags { } impl fmt::Debug for FormatFeatureFlags2KHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2KHR :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2KHR :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2KHR :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2KHR :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2KHR :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2KHR :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2KHR :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2KHR :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2KHR :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2KHR :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2KHR :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2KHR :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_CUBIC_EXT . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_EXT") , (FormatFeatureFlags2KHR :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2KHR :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2KHR :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2KHR :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2KHR :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2KHR :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2KHR :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2KHR :: VIDEO_DECODE_OUTPUT . 0 , "VIDEO_DECODE_OUTPUT") , (FormatFeatureFlags2KHR :: VIDEO_DECODE_DPB . 0 , "VIDEO_DECODE_DPB") , (FormatFeatureFlags2KHR :: ACCELERATION_STRUCTURE_VERTEX_BUFFER . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER") , (FormatFeatureFlags2KHR :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2KHR :: FRAGMENT_SHADING_RATE_ATTACHMENT . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT") , (FormatFeatureFlags2KHR :: VIDEO_ENCODE_INPUT . 0 , "VIDEO_ENCODE_INPUT") , (FormatFeatureFlags2KHR :: VIDEO_ENCODE_DPB . 0 , "VIDEO_ENCODE_DPB")] ; + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2KHR :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2KHR :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2KHR :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2KHR :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2KHR :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2KHR :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2KHR :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2KHR :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2KHR :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2KHR :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2KHR :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2KHR :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_CUBIC_EXT . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_EXT") , (FormatFeatureFlags2KHR :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2KHR :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2KHR :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2KHR :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2KHR :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2KHR :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2KHR :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2KHR :: VIDEO_DECODE_OUTPUT . 0 , "VIDEO_DECODE_OUTPUT") , (FormatFeatureFlags2KHR :: VIDEO_DECODE_DPB . 0 , "VIDEO_DECODE_DPB") , (FormatFeatureFlags2KHR :: ACCELERATION_STRUCTURE_VERTEX_BUFFER . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER") , (FormatFeatureFlags2KHR :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2KHR :: FRAGMENT_SHADING_RATE_ATTACHMENT . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT") , (FormatFeatureFlags2KHR :: VIDEO_ENCODE_INPUT . 0 , "VIDEO_ENCODE_INPUT") , (FormatFeatureFlags2KHR :: VIDEO_ENCODE_DPB . 0 , "VIDEO_ENCODE_DPB") , (FormatFeatureFlags2KHR :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2KHR :: RESERVED_34_QCOM . 0 , "RESERVED_34_QCOM") , (FormatFeatureFlags2KHR :: RESERVED_35_QCOM . 0 , "RESERVED_35_QCOM") , (FormatFeatureFlags2KHR :: RESERVED_36_QCOM . 0 , "RESERVED_36_QCOM") , (FormatFeatureFlags2KHR :: RESERVED_37_QCOM . 0 , "RESERVED_37_QCOM")] ; debug_flags(f, KNOWN, self.0) } } @@ -2154,7 +2163,10 @@ impl fmt::Debug for ImageCreateFlags { (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), (ImageCreateFlags::RESERVED_16_AMD.0, "RESERVED_16_AMD"), (ImageCreateFlags::RESERVED_394_EXT.0, "RESERVED_394_EXT"), - (ImageCreateFlags::RESERVED_426_QCOM.0, "RESERVED_426_QCOM"), + ( + ImageCreateFlags::FRAGMENT_DENSITY_MAP_OFFSET_QCOM.0, + "FRAGMENT_DENSITY_MAP_OFFSET_QCOM", + ), (ImageCreateFlags::ALIAS.0, "ALIAS"), ( ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, @@ -2318,6 +2330,8 @@ impl fmt::Debug for ImageUsageFlags { ImageUsageFlags::INVOCATION_MASK_HUAWEI.0, "INVOCATION_MASK_HUAWEI", ), + (ImageUsageFlags::RESERVED_20_QCOM.0, "RESERVED_20_QCOM"), + (ImageUsageFlags::RESERVED_21_QCOM.0, "RESERVED_21_QCOM"), ]; debug_flags(f, KNOWN, self.0) } @@ -3482,6 +3496,7 @@ impl fmt::Debug for QueueFlags { (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), (QueueFlags::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"), (QueueFlags::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"), + (QueueFlags::RESERVED_7_QCOM.0, "RESERVED_7_QCOM"), (QueueFlags::PROTECTED.0, "PROTECTED"), ]; debug_flags(f, KNOWN, self.0) @@ -3663,6 +3678,10 @@ impl fmt::Debug for SamplerCreateFlags { ), (SamplerCreateFlags::RESERVED_3_AMD.0, "RESERVED_3_AMD"), (SamplerCreateFlags::RESERVED_2_EXT.0, "RESERVED_2_EXT"), + ( + SamplerCreateFlags::IMAGE_PROCESSING_QCOM.0, + "IMAGE_PROCESSING_QCOM", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -4099,6 +4118,9 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR") } Self::VIDEO_FORMAT_PROPERTIES_KHR => Some("VIDEO_FORMAT_PROPERTIES_KHR"), + Self::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR => { + Some("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR") + } Self::VIDEO_DECODE_INFO_KHR => Some("VIDEO_DECODE_INFO_KHR"), Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") @@ -5108,6 +5130,18 @@ impl fmt::Debug for StructureType { Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR => { Some("DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR") } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM") + } + Self::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM => { + Some("SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV") + } Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -5828,10 +5862,6 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { VideoEncodeH264CapabilityFlagsEXT::EVENLY_DISTRIBUTED_SLICE_SIZE.0, "EVENLY_DISTRIBUTED_SLICE_SIZE", ), - ( - VideoEncodeH264CapabilityFlagsEXT::OPTIONAL_RC_EXTENSION_STRUCT.0, - "OPTIONAL_RC_EXTENSION_STRUCT", - ), ]; debug_flags(f, KNOWN, self.0) } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index fdeb755..156d2ce 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -54,7 +54,7 @@ pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0); pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); #[doc = ""] pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); -pub const HEADER_VERSION: u32 = 202u32; +pub const HEADER_VERSION: u32 = 203u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION); #[doc = ""] @@ -27624,6 +27624,7 @@ pub struct SubpassEndInfoBuilder<'a> { inner: SubpassEndInfo, marker: ::std::marker::PhantomData<&'a ()>, } +pub unsafe trait ExtendsSubpassEndInfo {} impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> { type Target = SubpassEndInfo; fn deref(&self) -> &Self::Target { @@ -27636,6 +27637,20 @@ impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> { } } impl<'a> SubpassEndInfoBuilder<'a> { + #[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 = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -33783,6 +33798,69 @@ impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map_offset: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, + p_next: ::std::ptr::null_mut(), + fragment_density_map_offset: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self { + self.inner.fragment_density_map_offset = fragment_density_map_offset.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) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { pub s_type: StructureType, @@ -33942,6 +34020,70 @@ impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_offset_granularity: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, + p_next: ::std::ptr::null_mut(), + fragment_density_offset_granularity: Extent2D::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + pub fn fragment_density_offset_granularity( + mut self, + fragment_density_offset_granularity: Extent2D, + ) -> Self { + self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity; + 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) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct RenderPassFragmentDensityMapCreateInfoEXT { pub s_type: StructureType, @@ -34002,6 +34144,64 @@ impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_density_offset_count: u32, + pub p_fragment_density_offsets: *const Offset2D, +} +impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM { + fn default() -> Self { + Self { + s_type: StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, + p_next: ::std::ptr::null(), + fragment_density_offset_count: u32::default(), + p_fragment_density_offsets: ::std::ptr::null(), + } + } +} +impl SubpassFragmentDensityMapOffsetEndInfoQCOM { + pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + inner: SubpassFragmentDensityMapOffsetEndInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {} +unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {} +impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self { + self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _; + self.inner.p_fragment_density_offsets = fragment_density_offsets.as_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) -> SubpassFragmentDensityMapOffsetEndInfoQCOM { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceScalarBlockLayoutFeatures { pub s_type: StructureType, @@ -47024,6 +47224,64 @@ impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct QueueFamilyQueryResultStatusProperties2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported: Bool32, +} +impl ::std::default::Default for QueueFamilyQueryResultStatusProperties2KHR { + fn default() -> Self { + Self { + s_type: StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR, + p_next: ::std::ptr::null_mut(), + supported: Bool32::default(), + } + } +} +impl QueueFamilyQueryResultStatusProperties2KHR { + pub fn builder<'a>() -> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { + QueueFamilyQueryResultStatusProperties2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { + inner: QueueFamilyQueryResultStatusProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 + for QueueFamilyQueryResultStatusProperties2KHRBuilder<'_> +{ +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusProperties2KHR {} +impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { + type Target = QueueFamilyQueryResultStatusProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { + pub fn supported(mut self, supported: bool) -> Self { + self.inner.supported = supported.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) -> QueueFamilyQueryResultStatusProperties2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct VideoProfilesKHR { pub s_type: StructureType, @@ -50340,6 +50598,7 @@ pub struct VideoEncodeH264RateControlInfoEXT { pub idr_period: u32, pub consecutive_b_frame_count: u32, pub rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT, + pub temporal_layer_count: u8, } impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT { fn default() -> Self { @@ -50350,6 +50609,7 @@ impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT { idr_period: u32::default(), consecutive_b_frame_count: u32::default(), rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT::default(), + temporal_layer_count: u8::default(), } } } @@ -50399,6 +50659,10 @@ impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> { self.inner.rate_control_structure = rate_control_structure; self } + pub fn temporal_layer_count(mut self, temporal_layer_count: u8) -> Self { + self.inner.temporal_layer_count = temporal_layer_count; + 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."] @@ -51198,6 +51462,7 @@ pub struct VideoEncodeH265RateControlInfoEXT { pub idr_period: u32, pub consecutive_b_frame_count: u32, pub rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT, + pub sub_layer_count: u8, } impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT { fn default() -> Self { @@ -51208,6 +51473,7 @@ impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT { idr_period: u32::default(), consecutive_b_frame_count: u32::default(), rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT::default(), + sub_layer_count: u8::default(), } } } @@ -51257,6 +51523,10 @@ impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> { self.inner.rate_control_structure = rate_control_structure; self } + pub fn sub_layer_count(mut self, sub_layer_count: u8) -> Self { + self.inner.sub_layer_count = sub_layer_count; + 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."] @@ -55292,3 +55562,63 @@ impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_color_attachment: Bool32, +} +impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, + p_next: ::std::ptr::null_mut(), + linear_color_attachment: Bool32::default(), + } + } +} +impl PhysicalDeviceLinearColorAttachmentFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + inner: PhysicalDeviceLinearColorAttachmentFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self { + self.inner.linear_color_attachment = linear_color_attachment.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) -> PhysicalDeviceLinearColorAttachmentFeaturesNV { + self.inner + } +} diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index feae818..07e429e 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -2865,6 +2865,7 @@ impl StructureType { pub const VIDEO_PROFILES_KHR: Self = Self(1_000_023_013); pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1_000_023_014); pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1_000_023_015); + pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR: Self = Self(1_000_023_016); } impl KhrVideoDecodeQueueFn { pub fn name() -> &'static ::std::ffi::CStr { @@ -3921,7 +3922,7 @@ impl ExtVideoEncodeH264Fn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_encode_h264\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[derive(Clone)] pub struct ExtVideoEncodeH264Fn {} @@ -3958,7 +3959,7 @@ impl ExtVideoEncodeH265Fn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_encode_h265\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[derive(Clone)] pub struct ExtVideoEncodeH265Fn {} @@ -24372,18 +24373,18 @@ impl ArmExtension425Fn { Self {} } } -impl QcomExtension426Fn { +impl QcomFragmentDensityMapOffsetFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_426\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_fragment_density_map_offset\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct QcomExtension426Fn {} -unsafe impl Send for QcomExtension426Fn {} -unsafe impl Sync for QcomExtension426Fn {} -impl QcomExtension426Fn { +pub struct QcomFragmentDensityMapOffsetFn {} +unsafe impl Send for QcomFragmentDensityMapOffsetFn {} +unsafe impl Sync for QcomFragmentDensityMapOffsetFn {} +impl QcomFragmentDensityMapOffsetFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -24391,9 +24392,16 @@ impl QcomExtension426Fn { Self {} } } -#[doc = "Generated from 'VK_QCOM_extension_426'"] +#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"] impl ImageCreateFlags { - pub const RESERVED_426_QCOM: Self = Self(0b1000_0000_0000_0000); + pub const FRAGMENT_DENSITY_MAP_OFFSET_QCOM: Self = Self(0b1000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: Self = Self(1_000_425_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: Self = + Self(1_000_425_001); + pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1_000_425_002); } impl NvExtension427Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -24471,18 +24479,18 @@ impl NvExtension430Fn { Self {} } } -impl NvExtension431Fn { +impl NvLinearColorAttachmentFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_431\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_linear_color_attachment\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct NvExtension431Fn {} -unsafe impl Send for NvExtension431Fn {} -unsafe impl Sync for NvExtension431Fn {} -impl NvExtension431Fn { +pub struct NvLinearColorAttachmentFn {} +unsafe impl Send for NvLinearColorAttachmentFn {} +unsafe impl Sync for NvLinearColorAttachmentFn {} +impl NvLinearColorAttachmentFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -24490,6 +24498,16 @@ impl NvExtension431Fn { Self {} } } +#[doc = "Generated from 'VK_NV_linear_color_attachment'"] +impl FormatFeatureFlags2KHR { + #[doc = "Format support linear image as render target, it cannot be mixed with non linear attachment"] + pub const LINEAR_COLOR_ATTACHMENT_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_linear_color_attachment'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self(1_000_430_000); +} impl NvExtension432Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_432\0") @@ -24528,18 +24546,18 @@ impl NvExtension433Fn { Self {} } } -impl ExtExtension434Fn { +impl GoogleSurfacelessQueryFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_434\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_surfaceless_query\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension434Fn {} -unsafe impl Send for ExtExtension434Fn {} -unsafe impl Sync for ExtExtension434Fn {} -impl ExtExtension434Fn { +pub struct GoogleSurfacelessQueryFn {} +unsafe impl Send for GoogleSurfacelessQueryFn {} +unsafe impl Sync for GoogleSurfacelessQueryFn {} +impl GoogleSurfacelessQueryFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -24642,3 +24660,259 @@ impl SecExtension439Fn { Self {} } } +impl QcomExtension440Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_440\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension440Fn {} +unsafe impl Send for QcomExtension440Fn {} +unsafe impl Sync for QcomExtension440Fn {} +impl QcomExtension440Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_440'"] +impl DeviceQueueCreateFlags { + pub const RESERVED_1_QCOM: Self = Self(0b10); +} +#[doc = "Generated from 'VK_QCOM_extension_440'"] +impl QueueFlags { + pub const RESERVED_7_QCOM: Self = Self(0b1000_0000); +} +impl QcomExtension441Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_441\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension441Fn {} +unsafe impl Send for QcomExtension441Fn {} +unsafe impl Sync for QcomExtension441Fn {} +impl QcomExtension441Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_441'"] +impl FormatFeatureFlags2KHR { + pub const RESERVED_34_QCOM: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESERVED_35_QCOM: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESERVED_36_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESERVED_37_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_extension_441'"] +impl ImageUsageFlags { + pub const RESERVED_20_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const RESERVED_21_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_extension_441'"] +impl SamplerCreateFlags { + pub const IMAGE_PROCESSING_QCOM: Self = Self(0b1_0000); +} +impl CoreaviExtension442Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_COREAVI_extension_442\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension442Fn {} +unsafe impl Send for CoreaviExtension442Fn {} +unsafe impl Sync for CoreaviExtension442Fn {} +impl CoreaviExtension442Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension443Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_COREAVI_extension_443\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension443Fn {} +unsafe impl Send for CoreaviExtension443Fn {} +unsafe impl Sync for CoreaviExtension443Fn {} +impl CoreaviExtension443Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension444Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_COREAVI_extension_444\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension444Fn {} +unsafe impl Send for CoreaviExtension444Fn {} +unsafe impl Sync for CoreaviExtension444Fn {} +impl CoreaviExtension444Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_COREAVI_extension_444'"] +impl CommandPoolResetFlags { + pub const RESERVED_1_COREAVI: Self = Self(0b10); +} +impl CoreaviExtension445Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_COREAVI_extension_445\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension445Fn {} +unsafe impl Send for CoreaviExtension445Fn {} +unsafe impl Sync for CoreaviExtension445Fn {} +impl CoreaviExtension445Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension446Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_COREAVI_extension_446\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension446Fn {} +unsafe impl Send for CoreaviExtension446Fn {} +unsafe impl Sync for CoreaviExtension446Fn {} +impl CoreaviExtension446Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension447Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_COREAVI_extension_447\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension447Fn {} +unsafe impl Send for CoreaviExtension447Fn {} +unsafe impl Sync for CoreaviExtension447Fn {} +impl CoreaviExtension447Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension448Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_SEC_extension_448\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension448Fn {} +unsafe impl Send for SecExtension448Fn {} +unsafe impl Sync for SecExtension448Fn {} +impl SecExtension448Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension449Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_SEC_extension_449\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension449Fn {} +unsafe impl Send for SecExtension449Fn {} +unsafe impl Sync for SecExtension449Fn {} +impl SecExtension449Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension450Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_SEC_extension_450\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension450Fn {} +unsafe impl Send for SecExtension450Fn {} +unsafe impl Sync for SecExtension450Fn {} +impl SecExtension450Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension451Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_SEC_extension_451\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension451Fn {} +unsafe impl Send for SecExtension451Fn {} +unsafe impl Sync for SecExtension451Fn {} +impl SecExtension451Fn { + 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 e005e1f..52a76fd 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit e005e1f8175d006adc3676b40ac3dd2212961a68 +Subproject commit 52a76fd0a693708eb8c25bd0ab7a1008091f64d4 diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 73935f0..66a6bd0 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -2877,7 +2877,25 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { bindings = bindings.allowlist_type(typ); } + #[derive(Debug)] + struct ParseCallbacks; + impl bindgen::callbacks::ParseCallbacks for ParseCallbacks { + fn enum_variant_behavior( + &self, + _enum_name: Option<&str>, + original_variant_name: &str, + _variant_value: bindgen::callbacks::EnumVariantValue, + ) -> Option { + if original_variant_name.ends_with("_MAX_ENUM") { + Some(bindgen::callbacks::EnumVariantCustomBehavior::Hide) + } else { + None + } + } + } + bindings + .parse_callbacks(Box::new(ParseCallbacks)) .generate() .expect("Unable to generate native bindings") .write_to_file(vk_dir.join("native.rs"))