diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index c60ff9f..e854e10 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -321,7 +321,10 @@ impl fmt::Debug for AccessFlags2KHR { AccessFlags2KHR::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), - (AccessFlags2KHR::RESERVED_39_HUAWEI.0, "RESERVED_39_HUAWEI"), + ( + AccessFlags2KHR::INVOCATION_MASK_READ_HUAWEI.0, + "INVOCATION_MASK_READ_HUAWEI", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -2251,7 +2254,11 @@ impl fmt::Debug for ImageUsageFlags { ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0, "VIDEO_ENCODE_DPB_KHR", ), - (ImageUsageFlags::RESERVED_18_HUAWEI.0, "RESERVED_18_HUAWEI"), + (ImageUsageFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"), + ( + ImageUsageFlags::INVOCATION_MASK_HUAWEI.0, + "INVOCATION_MASK_HUAWEI", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -3134,8 +3141,8 @@ impl fmt::Debug for PipelineStageFlags2KHR { "SUBPASS_SHADING_HUAWEI", ), ( - PipelineStageFlags2KHR::RESERVED_40_HUAWEI.0, - "RESERVED_40_HUAWEI", + PipelineStageFlags2KHR::INVOCATION_MASK_HUAWEI.0, + "INVOCATION_MASK_HUAWEI", ), ]; debug_flags(f, KNOWN, self.0) @@ -4573,6 +4580,9 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT") } Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"), + Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR") + } Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => { Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV") } @@ -4642,6 +4652,9 @@ impl fmt::Debug for StructureType { Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => { Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR") } + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT") + } Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT => { Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT") } @@ -4708,6 +4721,10 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT") } Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"), + Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"), + Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR") + } Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT") } @@ -4836,6 +4853,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI => { Some("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI") } + Self::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI => { + Some("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI") + } Self::MEMORY_GET_REMOTE_ADDRESS_INFO_NV => Some("MEMORY_GET_REMOTE_ADDRESS_INFO_NV"), Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => { Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV") diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 9a439eb..a18d31f 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -53,7 +53,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 = 184u32; +pub const HEADER_VERSION: u32 = 186u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION); #[doc = ""] @@ -18771,6 +18771,178 @@ impl<'a> XYColorEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDevicePresentIdFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_id: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR { + fn default() -> PhysicalDevicePresentIdFeaturesKHR { + PhysicalDevicePresentIdFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + present_id: Bool32::default(), + } + } +} +impl PhysicalDevicePresentIdFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + PhysicalDevicePresentIdFeaturesKHRBuilder { + inner: PhysicalDevicePresentIdFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePresentIdFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePresentIdFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + pub fn present_id(mut self, present_id: bool) -> Self { + self.inner.present_id = present_id.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) -> PhysicalDevicePresentIdFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PresentIdKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_present_ids: *const u64, +} +impl ::std::default::Default for PresentIdKHR { + fn default() -> PresentIdKHR { + PresentIdKHR { + s_type: StructureType::PRESENT_ID_KHR, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_present_ids: ::std::ptr::null(), + } + } +} +impl PresentIdKHR { + pub fn builder<'a>() -> PresentIdKHRBuilder<'a> { + PresentIdKHRBuilder { + inner: PresentIdKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentIdKHRBuilder<'a> { + inner: PresentIdKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {} +impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> { + type Target = PresentIdKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentIdKHRBuilder<'a> { + pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self { + self.inner.swapchain_count = present_ids.len() as _; + self.inner.p_present_ids = present_ids.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) -> PresentIdKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDevicePresentWaitFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_wait: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR { + fn default() -> PhysicalDevicePresentWaitFeaturesKHR { + PhysicalDevicePresentWaitFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + present_wait: Bool32::default(), + } + } +} +impl PhysicalDevicePresentWaitFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + PhysicalDevicePresentWaitFeaturesKHRBuilder { + inner: PhysicalDevicePresentWaitFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePresentWaitFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePresentWaitFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + pub fn present_wait(mut self, present_wait: bool) -> Self { + self.inner.present_wait = present_wait.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) -> PhysicalDevicePresentWaitFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct HdrMetadataEXT { pub s_type: StructureType, @@ -28772,6 +28944,168 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_float16_atomics: Bool32, + pub shader_buffer_float16_atomic_add: Bool32, + pub shader_buffer_float16_atomic_min_max: Bool32, + pub shader_buffer_float32_atomic_min_max: Bool32, + pub shader_buffer_float64_atomic_min_max: Bool32, + pub shader_shared_float16_atomics: Bool32, + pub shader_shared_float16_atomic_add: Bool32, + pub shader_shared_float16_atomic_min_max: Bool32, + pub shader_shared_float32_atomic_min_max: Bool32, + pub shader_shared_float64_atomic_min_max: Bool32, + pub shader_image_float32_atomic_min_max: Bool32, + pub sparse_image_float32_atomic_min_max: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + fn default() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + shader_buffer_float16_atomics: Bool32::default(), + shader_buffer_float16_atomic_add: Bool32::default(), + shader_buffer_float16_atomic_min_max: Bool32::default(), + shader_buffer_float32_atomic_min_max: Bool32::default(), + shader_buffer_float64_atomic_min_max: Bool32::default(), + shader_shared_float16_atomics: Bool32::default(), + shader_shared_float16_atomic_add: Bool32::default(), + shader_shared_float16_atomic_min_max: Bool32::default(), + shader_shared_float32_atomic_min_max: Bool32::default(), + shader_shared_float64_atomic_min_max: Bool32::default(), + shader_image_float32_atomic_min_max: Bool32::default(), + sparse_image_float32_atomic_min_max: Bool32::default(), + } + } +} +impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder { + inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self { + self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into(); + self + } + pub fn shader_buffer_float16_atomic_add( + mut self, + shader_buffer_float16_atomic_add: bool, + ) -> Self { + self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into(); + self + } + pub fn shader_buffer_float16_atomic_min_max( + mut self, + shader_buffer_float16_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float16_atomic_min_max = + shader_buffer_float16_atomic_min_max.into(); + self + } + pub fn shader_buffer_float32_atomic_min_max( + mut self, + shader_buffer_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float32_atomic_min_max = + shader_buffer_float32_atomic_min_max.into(); + self + } + pub fn shader_buffer_float64_atomic_min_max( + mut self, + shader_buffer_float64_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float64_atomic_min_max = + shader_buffer_float64_atomic_min_max.into(); + self + } + pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self { + self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into(); + self + } + pub fn shader_shared_float16_atomic_add( + mut self, + shader_shared_float16_atomic_add: bool, + ) -> Self { + self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into(); + self + } + pub fn shader_shared_float16_atomic_min_max( + mut self, + shader_shared_float16_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float16_atomic_min_max = + shader_shared_float16_atomic_min_max.into(); + self + } + pub fn shader_shared_float32_atomic_min_max( + mut self, + shader_shared_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float32_atomic_min_max = + shader_shared_float32_atomic_min_max.into(); + self + } + pub fn shader_shared_float64_atomic_min_max( + mut self, + shader_shared_float64_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float64_atomic_min_max = + shader_shared_float64_atomic_min_max.into(); + self + } + pub fn shader_image_float32_atomic_min_max( + mut self, + shader_image_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into(); + self + } + pub fn sparse_image_float32_atomic_min_max( + mut self, + sparse_image_float32_atomic_min_max: bool, + ) -> Self { + self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.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) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { pub s_type: StructureType, @@ -30332,6 +30666,66 @@ impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { } } #[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub invocation_mask: Bool32, +} +impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI { + fn default() -> PhysicalDeviceInvocationMaskFeaturesHUAWEI { + PhysicalDeviceInvocationMaskFeaturesHUAWEI { + s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, + p_next: ::std::ptr::null_mut(), + invocation_mask: Bool32::default(), + } + } +} +impl PhysicalDeviceInvocationMaskFeaturesHUAWEI { + pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder { + inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + pub fn invocation_mask(mut self, invocation_mask: bool) -> Self { + self.inner.invocation_mask = invocation_mask.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) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI { + self.inner + } +} +#[repr(C)] #[derive(Copy, Clone, Default, Debug)] #[doc = ""] pub struct CoarseSampleLocationNV { diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 0350f44..6fdd7f0 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -17996,24 +17996,66 @@ impl ExtValidationFeaturesFn { impl StructureType { pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000); } -impl KhrExtension249Fn { +impl KhrPresentWaitFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_249\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_wait\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkWaitForPresentKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + present_id: u64, + timeout: u64, +) -> Result; #[derive(Clone)] -pub struct KhrExtension249Fn {} -unsafe impl Send for KhrExtension249Fn {} -unsafe impl Sync for KhrExtension249Fn {} -impl KhrExtension249Fn { +pub struct KhrPresentWaitFn { + pub wait_for_present_khr: PFN_vkWaitForPresentKHR, +} +unsafe impl Send for KhrPresentWaitFn {} +unsafe impl Sync for KhrPresentWaitFn {} +impl KhrPresentWaitFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension249Fn {} + KhrPresentWaitFn { + wait_for_present_khr: unsafe { + unsafe extern "system" fn wait_for_present_khr( + _device: Device, + _swapchain: SwapchainKHR, + _present_id: u64, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_for_present_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0"); + let val = _f(cname); + if val.is_null() { + wait_for_present_khr + } else { + ::std::mem::transmute(val) + } + }, + } } + #[doc = ""] + pub unsafe fn wait_for_present_khr( + &self, + device: Device, + swapchain: SwapchainKHR, + present_id: u64, + timeout: u64, + ) -> Result { + (self.wait_for_present_khr)(device, swapchain, present_id, timeout) + } +} +#[doc = "Generated from 'VK_KHR_present_wait'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000); } impl NvCooperativeMatrixFn { pub fn name() -> &'static ::std::ffi::CStr { @@ -19929,25 +19971,29 @@ impl IntelExtension273Fn { IntelExtension273Fn {} } } -impl IntelExtension274Fn { +impl ExtShaderAtomicFloat2Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_274\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_atomic_float2\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct IntelExtension274Fn {} -unsafe impl Send for IntelExtension274Fn {} -unsafe impl Sync for IntelExtension274Fn {} -impl IntelExtension274Fn { +pub struct ExtShaderAtomicFloat2Fn {} +unsafe impl Send for ExtShaderAtomicFloat2Fn {} +unsafe impl Sync for ExtShaderAtomicFloat2Fn {} +impl ExtShaderAtomicFloat2Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelExtension274Fn {} + ExtShaderAtomicFloat2Fn {} } } +#[doc = "Generated from 'VK_EXT_shader_atomic_float2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000); +} impl KhrExtension275Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_275\0") @@ -20898,25 +20944,33 @@ impl KhrShaderNonSemanticInfoFn { KhrShaderNonSemanticInfoFn {} } } -impl KhrExtension295Fn { +impl KhrPresentIdFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_295\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_id\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct KhrExtension295Fn {} -unsafe impl Send for KhrExtension295Fn {} -unsafe impl Sync for KhrExtension295Fn {} -impl KhrExtension295Fn { +pub struct KhrPresentIdFn {} +unsafe impl Send for KhrPresentIdFn {} +unsafe impl Sync for KhrPresentIdFn {} +impl KhrPresentIdFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension295Fn {} + KhrPresentIdFn {} } } +#[doc = "Generated from 'VK_KHR_present_id'"] +impl StructureType { + pub const PRESENT_ID_KHR: Self = Self(1_000_294_000); +} +#[doc = "Generated from 'VK_KHR_present_id'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001); +} impl ExtPrivateDataFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_private_data\0") @@ -22946,6 +23000,10 @@ impl ExtExtension340Fn { ExtExtension340Fn {} } } +#[doc = "Generated from 'VK_EXT_extension_340'"] +impl ImageUsageFlags { + pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} impl Ext4444FormatsFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_4444_formats\0") @@ -24018,36 +24076,80 @@ impl PipelineStageFlags2KHR { impl ShaderStageFlags { pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000); } -impl HuaweiExtension371Fn { +impl HuaweiInvocationMaskFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_371\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_invocation_mask\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image_view: ImageView, + image_layout: ImageLayout, +); #[derive(Clone)] -pub struct HuaweiExtension371Fn {} -unsafe impl Send for HuaweiExtension371Fn {} -unsafe impl Sync for HuaweiExtension371Fn {} -impl HuaweiExtension371Fn { +pub struct HuaweiInvocationMaskFn { + pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI, +} +unsafe impl Send for HuaweiInvocationMaskFn {} +unsafe impl Sync for HuaweiInvocationMaskFn {} +impl HuaweiInvocationMaskFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - HuaweiExtension371Fn {} + HuaweiInvocationMaskFn { + cmd_bind_invocation_mask_huawei: unsafe { + unsafe extern "system" fn cmd_bind_invocation_mask_huawei( + _command_buffer: CommandBuffer, + _image_view: ImageView, + _image_layout: ImageLayout, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_invocation_mask_huawei) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindInvocationMaskHUAWEI\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_invocation_mask_huawei + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_bind_invocation_mask_huawei( + &self, + command_buffer: CommandBuffer, + image_view: ImageView, + image_layout: ImageLayout, + ) { + (self.cmd_bind_invocation_mask_huawei)(command_buffer, image_view, image_layout) } } -#[doc = "Generated from 'VK_HUAWEI_extension_371'"] +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000); +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] impl AccessFlags2KHR { - pub const RESERVED_39_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const INVOCATION_MASK_READ_HUAWEI: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_HUAWEI_extension_371'"] +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] impl ImageUsageFlags { - pub const RESERVED_18_HUAWEI: Self = Self(0b100_0000_0000_0000_0000); + pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_HUAWEI_extension_371'"] +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] impl PipelineStageFlags2KHR { - pub const RESERVED_40_HUAWEI: Self = + pub const INVOCATION_MASK_HUAWEI: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } impl NvExternalMemoryRdmaFn { @@ -24060,7 +24162,7 @@ impl NvExternalMemoryRdmaFn { #[allow(non_camel_case_types)] pub type PFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn( device: Device, - get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV, + p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV, p_address: *mut RemoteAddressNV, ) -> Result; #[derive(Clone)] @@ -24078,7 +24180,7 @@ impl NvExternalMemoryRdmaFn { get_memory_remote_address_nv: unsafe { unsafe extern "system" fn get_memory_remote_address_nv( _device: Device, - _get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV, + _p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV, _p_address: *mut RemoteAddressNV, ) -> Result { panic!(concat!( @@ -24102,10 +24204,10 @@ impl NvExternalMemoryRdmaFn { pub unsafe fn get_memory_remote_address_nv( &self, device: Device, - get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV, + p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV, p_address: *mut RemoteAddressNV, ) -> Result { - (self.get_memory_remote_address_nv)(device, get_memory_remote_address_info, p_address) + (self.get_memory_remote_address_nv)(device, p_memory_get_remote_address_info, p_address) } } #[doc = "Generated from 'VK_NV_external_memory_rdma'"] @@ -25498,3 +25600,22 @@ impl ExtExtension420Fn { ExtExtension420Fn {} } } +impl KhrExtension421Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_421\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension421Fn {} +unsafe impl Send for KhrExtension421Fn {} +unsafe impl Sync for KhrExtension421Fn {} +impl KhrExtension421Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension421Fn {} + } +} diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 0193e15..b8c57b0 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 0193e158bc9f4d17e3c3a61c9311a0439ed5572d +Subproject commit b8c57b0a09f7324fec5a7c363f5e26ff4d5a3222