From 2bf1bc5e6c1bed66ad7195a0ccdfa91b0d23eef0 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Tue, 16 Nov 2021 15:41:45 +0100 Subject: [PATCH 1/2] Update Vulkan-Headers to 1.2.199 --- ash/src/vk/const_debugs.rs | 6 ++ ash/src/vk/definitions.rs | 114 ++++++++++++++++++++++++++++++++++++- ash/src/vk/enums.rs | 2 + ash/src/vk/extensions.rs | 64 ++++++++++++++++++--- generator/Vulkan-Headers | 2 +- 5 files changed, 179 insertions(+), 9 deletions(-) diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 0fc2401ff..aebb6cbd6 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -321,6 +321,7 @@ impl fmt::Debug for AccessFlags2KHR { AccessFlags2KHR::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), + (AccessFlags2KHR::RESERVED_41_AMD.0, "RESERVED_41_AMD"), ( AccessFlags2KHR::INVOCATION_MASK_READ_HUAWEI.0, "INVOCATION_MASK_READ_HUAWEI", @@ -1338,6 +1339,7 @@ impl fmt::Debug for DriverId { Self::MESA_TURNIP => Some("MESA_TURNIP"), Self::MESA_V3DV => Some("MESA_V3DV"), Self::MESA_PANVK => Some("MESA_PANVK"), + Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"), _ => None, }; if let Some(x) = name { @@ -5047,6 +5049,10 @@ impl fmt::Debug for StructureType { Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT => { Some("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT") } + Self::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT") + } + Self::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT => Some("IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"), Self::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT => { Some("PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT") } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index a99559fd8..3bd64fd30 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 = 198u32; +pub const HEADER_VERSION: u32 = 199u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION); #[doc = ""] @@ -54305,3 +54305,115 @@ impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceImageViewMinLodFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_lod: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + min_lod: Bool32::default(), + } + } +} +impl PhysicalDeviceImageViewMinLodFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + PhysicalDeviceImageViewMinLodFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageViewMinLodFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImageViewMinLodFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + pub fn min_lod(mut self, min_lod: bool) -> Self { + self.inner.min_lod = min_lod.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) -> PhysicalDeviceImageViewMinLodFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImageViewMinLodCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_lod: f32, +} +impl ::std::default::Default for ImageViewMinLodCreateInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + min_lod: f32::default(), + } + } +} +impl ImageViewMinLodCreateInfoEXT { + pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> { + ImageViewMinLodCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> { + inner: ImageViewMinLodCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> { + type Target = ImageViewMinLodCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> { + pub fn min_lod(mut self, min_lod: f32) -> Self { + self.inner.min_lod = min_lod; + 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) -> ImageViewMinLodCreateInfoEXT { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index d266c0b4d..0ced8761b 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1663,6 +1663,8 @@ impl DriverId { pub const MESA_V3DV: Self = Self(19); #[doc = "Mesa open source project"] pub const MESA_PANVK: Self = Self(20); + #[doc = "Samsung Electronics Co., Ltd."] + pub const SAMSUNG_PROPRIETARY: Self = Self(21); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index c40f82b5b..39dbdc640 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -22398,6 +22398,10 @@ impl ImageCreateFlags { impl SamplerCreateFlags { pub const RESERVED_3_AMD: Self = Self(0b1000); } +#[doc = "Generated from 'VK_AMD_extension_317'"] +impl AccessFlags2KHR { + pub const RESERVED_41_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} impl AmdExtension318Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_318\0") @@ -25430,18 +25434,18 @@ impl ExtExtension391Fn { Self {} } } -impl ExtExtension392Fn { +impl ExtImageViewMinLodFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_392\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_image_view_min_lod\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension392Fn {} -unsafe impl Send for ExtExtension392Fn {} -unsafe impl Sync for ExtExtension392Fn {} -impl ExtExtension392Fn { +pub struct ExtImageViewMinLodFn {} +unsafe impl Send for ExtImageViewMinLodFn {} +unsafe impl Sync for ExtImageViewMinLodFn {} +impl ExtImageViewMinLodFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -25449,6 +25453,14 @@ impl ExtExtension392Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_image_view_min_lod'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1_000_391_000); +} +#[doc = "Generated from 'VK_EXT_image_view_min_lod'"] +impl StructureType { + pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: Self = Self(1_000_391_001); +} impl ExtMultiDrawFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_multi_draw\0") @@ -26548,3 +26560,41 @@ impl NvExtension433Fn { Self {} } } +impl ExtExtension434Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_434\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension434Fn {} +unsafe impl Send for ExtExtension434Fn {} +unsafe impl Sync for ExtExtension434Fn {} +impl ExtExtension434Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension435Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_435\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension435Fn {} +unsafe impl Send for KhrExtension435Fn {} +unsafe impl Sync for KhrExtension435Fn {} +impl KhrExtension435Fn { + 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 8c1c27d5a..83e1a9ed8 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 8c1c27d5a9b9de8a17f500053bd08c7ca6bba19c +Subproject commit 83e1a9ed8ce289cebb1c02c8167d663dc1befb24 From 1c1940c4bd93a4fba2179855958b19360b4f0e87 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Tue, 23 Nov 2021 17:11:40 +0100 Subject: [PATCH 2/2] Update Vulkan-Headers to 1.2.200 --- ash/src/vk/bitflags.rs | 14 ++- ash/src/vk/const_debugs.rs | 36 +++++-- ash/src/vk/definitions.rs | 215 +++++++++++++++++++++++++++++++++++-- ash/src/vk/enums.rs | 3 + ash/src/vk/extensions.rs | 119 +++++++++++++++++--- generator/Vulkan-Headers | 2 +- 6 files changed, 353 insertions(+), 36 deletions(-) diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index 1edce2707..88f210d31 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -498,7 +498,7 @@ impl StencilFaceFlags { pub const BACK: Self = Self(0b10); #[doc = "Front and back faces"] pub const FRONT_AND_BACK: Self = Self(0x0000_0003); - #[deprecated = "Alias for backwards compatibility"] + #[deprecated = "Backwards-compatible alias containing a typo"] pub const STENCIL_FRONT_AND_BACK: Self = Self::FRONT_AND_BACK; } #[repr(transparent)] @@ -1049,6 +1049,18 @@ vk_bitflags_wrapped!(PipelineLayoutCreateFlags, Flags); impl PipelineLayoutCreateFlags {} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags); +impl PipelineColorBlendStateCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags); +impl PipelineDepthStencilStateCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index aebb6cbd6..2ece3dc1f 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -2819,7 +2819,10 @@ impl fmt::Debug for PipelineCacheHeaderVersion { } impl fmt::Debug for PipelineColorBlendStateCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[]; + const KNOWN: &[(Flags, &str)] = &[( + PipelineColorBlendStateCreateFlags::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM.0, + "RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM", + )]; debug_flags(f, KNOWN, self.0) } } @@ -2860,12 +2863,12 @@ impl fmt::Debug for PipelineCreateFlags { ), (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), ( - PipelineCreateFlags::RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, - "RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + PipelineCreateFlags::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", ), ( - PipelineCreateFlags::RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0, - "RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT", + PipelineCreateFlags::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0, + "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT", ), ( PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0, @@ -2950,7 +2953,7 @@ impl fmt::Debug for PipelineCreationFeedbackFlagsEXT { } impl fmt::Debug for PipelineDepthStencilStateCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[]; + const KNOWN : & [(Flags , & str)] = & [(PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM . 0 , "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM") , (PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM . 0 , "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM")] ; debug_flags(f, KNOWN, self.0) } } @@ -4954,6 +4957,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM => { + Some("PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM") + } Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT") } @@ -4974,6 +4980,12 @@ impl fmt::Debug for StructureType { Some("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT") } Self::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT => Some("PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT") + } + Self::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT => { + Some("PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT") + } Self::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT") } @@ -5379,6 +5391,18 @@ impl fmt::Debug for SubpassDescriptionFlags { SubpassDescriptionFlags::SHADER_RESOLVE_QCOM.0, "SHADER_RESOLVE_QCOM", ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM.0, + "RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM.0, + "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM.0, + "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM", + ), ]; debug_flags(f, KNOWN, self.0) } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 3bd64fd30..602683570 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 = 199u32; +pub const HEADER_VERSION: u32 = 200u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION); #[doc = ""] @@ -76,21 +76,11 @@ pub struct QueryPoolCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); -vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags); -vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags); @@ -45676,6 +45666,127 @@ impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceDepthClipControlFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_clip_control: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + depth_clip_control: Bool32::default(), + } + } +} +impl PhysicalDeviceDepthClipControlFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + PhysicalDeviceDepthClipControlFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDepthClipControlFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDepthClipControlFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self { + self.inner.depth_clip_control = depth_clip_control.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) -> PhysicalDeviceDepthClipControlFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PipelineViewportDepthClipControlCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub negative_one_to_one: Bool32, +} +impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + negative_one_to_one: Bool32::default(), + } + } +} +impl PipelineViewportDepthClipControlCreateInfoEXT { + pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + PipelineViewportDepthClipControlCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + inner: PipelineViewportDepthClipControlCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportDepthClipControlCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + type Target = PipelineViewportDepthClipControlCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self { + self.inner.negative_one_to_one = negative_one_to_one.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) -> PipelineViewportDepthClipControlCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT { pub s_type: StructureType, @@ -54417,3 +54528,85 @@ impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub rasterization_order_color_attachment_access: Bool32, + pub rasterization_order_depth_attachment_access: Bool32, + pub rasterization_order_stencil_attachment_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { + fn default() -> Self { + Self { + s_type: + StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM, + p_next: ::std::ptr::null(), + rasterization_order_color_attachment_access: Bool32::default(), + rasterization_order_depth_attachment_access: Bool32::default(), + rasterization_order_stencil_attachment_access: Bool32::default(), + } + } +} +impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { + pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> { + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> { + inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> +{ + type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> { + pub fn rasterization_order_color_attachment_access( + mut self, + rasterization_order_color_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_color_attachment_access = + rasterization_order_color_attachment_access.into(); + self + } + pub fn rasterization_order_depth_attachment_access( + mut self, + rasterization_order_depth_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_depth_attachment_access = + rasterization_order_depth_attachment_access.into(); + self + } + pub fn rasterization_order_stencil_attachment_access( + mut self, + rasterization_order_stencil_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_stencil_attachment_access = + rasterization_order_stencil_attachment_access.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) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 0ced8761b..c69bf179b 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1957,8 +1957,11 @@ impl PerformanceCounterScopeKHR { pub const COMMAND_BUFFER: Self = Self(0); pub const RENDER_PASS: Self = Self(1); pub const COMMAND: Self = Self(2); + #[deprecated = "Backwards-compatible alias containing a typo"] pub const QUERY_SCOPE_COMMAND_BUFFER: Self = Self::COMMAND_BUFFER; + #[deprecated = "Backwards-compatible alias containing a typo"] pub const QUERY_SCOPE_RENDER_PASS: Self = Self::RENDER_PASS; + #[deprecated = "Backwards-compatible alias containing a typo"] pub const QUERY_SCOPE_COMMAND: Self = Self::COMMAND; } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 39dbdc640..0f22cb39b 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -4467,19 +4467,29 @@ impl AttachmentStoreOp { } #[doc = "Generated from 'VK_KHR_dynamic_rendering'"] impl PipelineCreateFlags { - pub const RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl PipelineCreateFlags { + pub const RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] impl StructureType { pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_006); } #[doc = "Generated from 'VK_KHR_dynamic_rendering'"] impl PipelineCreateFlags { - pub const RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl PipelineCreateFlags { + pub const RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = + Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT; +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] impl StructureType { pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1_000_044_007); } @@ -23280,18 +23290,18 @@ impl ExtExtension342Fn { Self {} } } -impl ArmExtension343Fn { +impl ArmRasterizationOrderAttachmentAccessFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_343\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_rasterization_order_attachment_access\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ArmExtension343Fn {} -unsafe impl Send for ArmExtension343Fn {} -unsafe impl Sync for ArmExtension343Fn {} -impl ArmExtension343Fn { +pub struct ArmRasterizationOrderAttachmentAccessFn {} +unsafe impl Send for ArmRasterizationOrderAttachmentAccessFn {} +unsafe impl Sync for ArmRasterizationOrderAttachmentAccessFn {} +impl ArmRasterizationOrderAttachmentAccessFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -23299,6 +23309,35 @@ impl ArmExtension343Fn { Self {} } } +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: Self = + Self(1_000_342_000); +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl PipelineColorBlendStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM: Self = Self(0b1); +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl PipelineDepthStencilStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = Self(0b1); +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl PipelineDepthStencilStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = Self(0b10); +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl SubpassDescriptionFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl SubpassDescriptionFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl SubpassDescriptionFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = Self(0b100_0000); +} impl ArmExtension344Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_344\0") @@ -23738,18 +23777,18 @@ impl ExtExtension355Fn { Self {} } } -impl ExtVertexAttributeAliasingFn { +impl ExtDepthClipControlFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_vertex_attribute_aliasing\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_depth_clip_control\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtVertexAttributeAliasingFn {} -unsafe impl Send for ExtVertexAttributeAliasingFn {} -unsafe impl Sync for ExtVertexAttributeAliasingFn {} -impl ExtVertexAttributeAliasingFn { +pub struct ExtDepthClipControlFn {} +unsafe impl Send for ExtDepthClipControlFn {} +unsafe impl Sync for ExtDepthClipControlFn {} +impl ExtDepthClipControlFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -23757,6 +23796,14 @@ impl ExtVertexAttributeAliasingFn { Self {} } } +#[doc = "Generated from 'VK_EXT_depth_clip_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1_000_355_000); +} +#[doc = "Generated from 'VK_EXT_depth_clip_control'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: Self = Self(1_000_355_001); +} impl ExtPrimitiveTopologyListRestartFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_primitive_topology_list_restart\0") @@ -26039,7 +26086,7 @@ impl KhrMaintenance4Fn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_maintenance4\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetDeviceBufferMemoryRequirementsKHR = unsafe extern "system" fn( @@ -26598,3 +26645,41 @@ impl KhrExtension435Fn { Self {} } } +impl NvExtension436Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_436\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension436Fn {} +unsafe impl Send for NvExtension436Fn {} +unsafe impl Sync for NvExtension436Fn {} +impl NvExtension436Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension437Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_437\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension437Fn {} +unsafe impl Send for ExtExtension437Fn {} +unsafe impl Sync for ExtExtension437Fn {} +impl ExtExtension437Fn { + 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 83e1a9ed8..a15237165 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 83e1a9ed8ce289cebb1c02c8167d663dc1befb24 +Subproject commit a15237165443ba1ef430ed332745f9a99ec509ad