From 11f632a00eabc5dfdb3298f706a59fc9805f4216 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Thu, 17 Nov 2022 20:12:28 +0100 Subject: [PATCH] Update Vulkan-Headers to 1.3.235 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/vk/const_debugs.rs | 95 +++- ash/src/vk/definitions.rs | 886 ++++++++++++++++++++++++++++++++++++- ash/src/vk/enums.rs | 2 + ash/src/vk/extensions.rs | 488 ++++++++++++++++++-- generator/Vulkan-Headers | 2 +- 7 files changed, 1431 insertions(+), 46 deletions(-) diff --git a/Changelog.md b/Changelog.md index 90659dca3..104b14763 100644 --- a/Changelog.md +++ b/Changelog.md @@ -16,7 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Added `VK_EXT_image_drm_format_modifier` device extension (#603) -- Update Vulkan-Headers to 1.3.233 (#605, #608, #619, #655, #667) +- Update Vulkan-Headers to 1.3.235 (#605, #608, #619, #655, #667) - Added `const STRUCTURE_TYPE` to all Vulkan structures for matching with `match_struct!` macro (#614) - Added `VK_EXT_sample_locations` device extension (#616) - Added `VK_NV_coverage_reduction_mode` device extension (#617) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index c64cc0711..e398790bd 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.233" +version = "0.37.0+1.3.235" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT OR Apache-2.0" diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index b294edb39..141718ebc 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -40,8 +40,8 @@ impl fmt::Debug for AccelerationStructureCreateFlagsKHR { "DEVICE_ADDRESS_CAPTURE_REPLAY", ), ( - AccelerationStructureCreateFlagsKHR::RESERVED_3_AMD.0, - "RESERVED_3_AMD", + AccelerationStructureCreateFlagsKHR::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", ), ( AccelerationStructureCreateFlagsKHR::MOTION_NV.0, @@ -304,7 +304,10 @@ impl fmt::Debug for AccessFlags2 { AccessFlags2::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), - (AccessFlags2::RESERVED_41_AMD.0, "RESERVED_41_AMD"), + ( + AccessFlags2::DESCRIPTOR_BUFFER_READ_EXT.0, + "DESCRIPTOR_BUFFER_READ_EXT", + ), ( AccessFlags2::INVOCATION_MASK_READ_HUAWEI.0, "INVOCATION_MASK_READ_HUAWEI", @@ -508,7 +511,10 @@ impl fmt::Debug for BufferCreateFlags { (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::RESERVED_5_AMD.0, "RESERVED_5_AMD"), + ( + BufferCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ( BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, @@ -578,8 +584,18 @@ impl fmt::Debug for BufferUsageFlags { BufferUsageFlags::VIDEO_ENCODE_SRC_KHR.0, "VIDEO_ENCODE_SRC_KHR", ), - (BufferUsageFlags::RESERVED_21_AMD.0, "RESERVED_21_AMD"), - (BufferUsageFlags::RESERVED_22_AMD.0, "RESERVED_22_AMD"), + ( + BufferUsageFlags::SAMPLER_DESCRIPTOR_BUFFER_EXT.0, + "SAMPLER_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::RESOURCE_DESCRIPTOR_BUFFER_EXT.0, + "RESOURCE_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0, + "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT", + ), ( BufferUsageFlags::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0, "MICROMAP_BUILD_INPUT_READ_ONLY_EXT", @@ -1173,12 +1189,12 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags { "PUSH_DESCRIPTOR_KHR", ), ( - DescriptorSetLayoutCreateFlags::RESERVED_4_AMD.0, - "RESERVED_4_AMD", + DescriptorSetLayoutCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", ), ( - DescriptorSetLayoutCreateFlags::RESERVED_5_AMD.0, - "RESERVED_5_AMD", + DescriptorSetLayoutCreateFlags::EMBEDDED_IMMUTABLE_SAMPLERS_EXT.0, + "EMBEDDED_IMMUTABLE_SAMPLERS_EXT", ), ( DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0, @@ -1488,6 +1504,7 @@ impl fmt::Debug for DriverId { Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"), Self::MESA_VENUS => Some("MESA_VENUS"), Self::MESA_DOZEN => Some("MESA_DOZEN"), + Self::MESA_NVK => Some("MESA_NVK"), _ => None, }; if let Some(x) = name { @@ -2493,7 +2510,10 @@ impl fmt::Debug for ImageCreateFlags { ), (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), (ImageCreateFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"), - (ImageCreateFlags::RESERVED_16_AMD.0, "RESERVED_16_AMD"), + ( + ImageCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), ( ImageCreateFlags::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT.0, "MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT", @@ -2692,7 +2712,10 @@ impl fmt::Debug for ImageViewCreateFlags { ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", ), - (ImageViewCreateFlags::RESERVED_2_AMD.0, "RESERVED_2_AMD"), + ( + ImageViewCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), ( ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0, "FRAGMENT_DENSITY_MAP_DEFERRED_EXT", @@ -3383,7 +3406,10 @@ impl fmt::Debug for PipelineCreateFlags { "INDIRECT_BINDABLE_NV", ), (PipelineCreateFlags::LIBRARY_KHR.0, "LIBRARY_KHR"), - (PipelineCreateFlags::RESERVED_29_AMD.0, "RESERVED_29_AMD"), + ( + PipelineCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", + ), ( PipelineCreateFlags::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0, "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT", @@ -3753,6 +3779,10 @@ impl fmt::Debug for PipelineStageFlags2 { PipelineStageFlags2::MICROMAP_BUILD_EXT.0, "MICROMAP_BUILD_EXT", ), + ( + PipelineStageFlags2::RESEVED_41_HUAWEI.0, + "RESEVED_41_HUAWEI", + ), (PipelineStageFlags2::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), ]; debug_flags(f, KNOWN, self.0) @@ -4176,7 +4206,10 @@ impl fmt::Debug for SamplerCreateFlags { SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", ), - (SamplerCreateFlags::RESERVED_3_AMD.0, "RESERVED_3_AMD"), + ( + SamplerCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), ( SamplerCreateFlags::NON_SEAMLESS_CUBE_MAP_EXT.0, "NON_SEAMLESS_CUBE_MAP_EXT", @@ -4390,6 +4423,7 @@ impl fmt::Debug for ShaderStageFlags { ShaderStageFlags::SUBPASS_SHADING_HUAWEI.0, "SUBPASS_SHADING_HUAWEI", ), + (ShaderStageFlags::RESERVED_19_HUAWEI.0, "RESERVED_19_HUAWEI"), (ShaderStageFlags::EXT_483_RESERVE_15.0, "EXT_483_RESERVE_15"), (ShaderStageFlags::EXT_483_RESERVE_16.0, "EXT_483_RESERVE_16"), (ShaderStageFlags::EXT_483_RESERVE_17.0, "EXT_483_RESERVE_17"), @@ -5407,6 +5441,39 @@ impl fmt::Debug for StructureType { Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV") } Self::CHECKPOINT_DATA_2_NV => Some("CHECKPOINT_DATA_2_NV"), + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT") + } + Self::DESCRIPTOR_ADDRESS_INFO_EXT => Some("DESCRIPTOR_ADDRESS_INFO_EXT"), + Self::DESCRIPTOR_GET_INFO_EXT => Some("DESCRIPTOR_GET_INFO_EXT"), + Self::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT => { + Some("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT") + } + Self::DESCRIPTOR_BUFFER_BINDING_INFO_EXT => Some("DESCRIPTOR_BUFFER_BINDING_INFO_EXT"), + Self::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT => { + Some("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT") + } + Self::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT => { Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT") } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 1f189ae84..d6ba96f9a 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -57,7 +57,7 @@ pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); -pub const HEADER_VERSION: u32 = 233u32; +pub const HEADER_VERSION: u32 = 235u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -23464,6 +23464,7 @@ impl ::std::default::Default for AccelerationStructureCreateInfoNV<'_> { unsafe impl<'a> TaggedStructure for AccelerationStructureCreateInfoNV<'a> { const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV; } +pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {} impl<'a> AccelerationStructureCreateInfoNV<'a> { #[inline] pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self { @@ -23475,6 +23476,23 @@ impl<'a> AccelerationStructureCreateInfoNV<'a> { self.info = info; self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.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 = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -39668,6 +39686,872 @@ impl<'a> CuLaunchInfoNVX<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_buffer: Bool32, + pub descriptor_buffer_capture_replay: Bool32, + pub descriptor_buffer_image_layout_ignored: Bool32, + pub descriptor_buffer_push_descriptors: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_buffer: Bool32::default(), + descriptor_buffer_capture_replay: Bool32::default(), + descriptor_buffer_image_layout_ignored: Bool32::default(), + descriptor_buffer_push_descriptors: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + #[inline] + pub fn descriptor_buffer(mut self, descriptor_buffer: bool) -> Self { + self.descriptor_buffer = descriptor_buffer.into(); + self + } + #[inline] + pub fn descriptor_buffer_capture_replay( + mut self, + descriptor_buffer_capture_replay: bool, + ) -> Self { + self.descriptor_buffer_capture_replay = descriptor_buffer_capture_replay.into(); + self + } + #[inline] + pub fn descriptor_buffer_image_layout_ignored( + mut self, + descriptor_buffer_image_layout_ignored: bool, + ) -> Self { + self.descriptor_buffer_image_layout_ignored = descriptor_buffer_image_layout_ignored.into(); + self + } + #[inline] + pub fn descriptor_buffer_push_descriptors( + mut self, + descriptor_buffer_push_descriptors: bool, + ) -> Self { + self.descriptor_buffer_push_descriptors = descriptor_buffer_push_descriptors.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_descriptor_single_array: Bool32, + pub bufferless_push_descriptors: Bool32, + pub allow_sampler_image_view_post_submit_creation: Bool32, + pub descriptor_buffer_offset_alignment: DeviceSize, + pub max_descriptor_buffer_bindings: u32, + pub max_resource_descriptor_buffer_bindings: u32, + pub max_sampler_descriptor_buffer_bindings: u32, + pub max_embedded_immutable_sampler_bindings: u32, + pub max_embedded_immutable_samplers: u32, + pub buffer_capture_replay_descriptor_data_size: usize, + pub image_capture_replay_descriptor_data_size: usize, + pub image_view_capture_replay_descriptor_data_size: usize, + pub sampler_capture_replay_descriptor_data_size: usize, + pub acceleration_structure_capture_replay_descriptor_data_size: usize, + pub sampler_descriptor_size: usize, + pub combined_image_sampler_descriptor_size: usize, + pub sampled_image_descriptor_size: usize, + pub storage_image_descriptor_size: usize, + pub uniform_texel_buffer_descriptor_size: usize, + pub robust_uniform_texel_buffer_descriptor_size: usize, + pub storage_texel_buffer_descriptor_size: usize, + pub robust_storage_texel_buffer_descriptor_size: usize, + pub uniform_buffer_descriptor_size: usize, + pub robust_uniform_buffer_descriptor_size: usize, + pub storage_buffer_descriptor_size: usize, + pub robust_storage_buffer_descriptor_size: usize, + pub input_attachment_descriptor_size: usize, + pub acceleration_structure_descriptor_size: usize, + pub max_sampler_descriptor_buffer_range: DeviceSize, + pub max_resource_descriptor_buffer_range: DeviceSize, + pub sampler_descriptor_buffer_address_space_size: DeviceSize, + pub resource_descriptor_buffer_address_space_size: DeviceSize, + pub descriptor_buffer_address_space_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_descriptor_single_array: Bool32::default(), + bufferless_push_descriptors: Bool32::default(), + allow_sampler_image_view_post_submit_creation: Bool32::default(), + descriptor_buffer_offset_alignment: DeviceSize::default(), + max_descriptor_buffer_bindings: u32::default(), + max_resource_descriptor_buffer_bindings: u32::default(), + max_sampler_descriptor_buffer_bindings: u32::default(), + max_embedded_immutable_sampler_bindings: u32::default(), + max_embedded_immutable_samplers: u32::default(), + buffer_capture_replay_descriptor_data_size: usize::default(), + image_capture_replay_descriptor_data_size: usize::default(), + image_view_capture_replay_descriptor_data_size: usize::default(), + sampler_capture_replay_descriptor_data_size: usize::default(), + acceleration_structure_capture_replay_descriptor_data_size: usize::default(), + sampler_descriptor_size: usize::default(), + combined_image_sampler_descriptor_size: usize::default(), + sampled_image_descriptor_size: usize::default(), + storage_image_descriptor_size: usize::default(), + uniform_texel_buffer_descriptor_size: usize::default(), + robust_uniform_texel_buffer_descriptor_size: usize::default(), + storage_texel_buffer_descriptor_size: usize::default(), + robust_storage_texel_buffer_descriptor_size: usize::default(), + uniform_buffer_descriptor_size: usize::default(), + robust_uniform_buffer_descriptor_size: usize::default(), + storage_buffer_descriptor_size: usize::default(), + robust_storage_buffer_descriptor_size: usize::default(), + input_attachment_descriptor_size: usize::default(), + acceleration_structure_descriptor_size: usize::default(), + max_sampler_descriptor_buffer_range: DeviceSize::default(), + max_resource_descriptor_buffer_range: DeviceSize::default(), + sampler_descriptor_buffer_address_space_size: DeviceSize::default(), + resource_descriptor_buffer_address_space_size: DeviceSize::default(), + descriptor_buffer_address_space_size: DeviceSize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + #[inline] + pub fn combined_image_sampler_descriptor_single_array( + mut self, + combined_image_sampler_descriptor_single_array: bool, + ) -> Self { + self.combined_image_sampler_descriptor_single_array = + combined_image_sampler_descriptor_single_array.into(); + self + } + #[inline] + pub fn bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self { + self.bufferless_push_descriptors = bufferless_push_descriptors.into(); + self + } + #[inline] + pub fn allow_sampler_image_view_post_submit_creation( + mut self, + allow_sampler_image_view_post_submit_creation: bool, + ) -> Self { + self.allow_sampler_image_view_post_submit_creation = + allow_sampler_image_view_post_submit_creation.into(); + self + } + #[inline] + pub fn descriptor_buffer_offset_alignment( + mut self, + descriptor_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment; + self + } + #[inline] + pub fn max_descriptor_buffer_bindings(mut self, max_descriptor_buffer_bindings: u32) -> Self { + self.max_descriptor_buffer_bindings = max_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_bindings( + mut self, + max_resource_descriptor_buffer_bindings: u32, + ) -> Self { + self.max_resource_descriptor_buffer_bindings = max_resource_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_bindings( + mut self, + max_sampler_descriptor_buffer_bindings: u32, + ) -> Self { + self.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_sampler_bindings( + mut self, + max_embedded_immutable_sampler_bindings: u32, + ) -> Self { + self.max_embedded_immutable_sampler_bindings = max_embedded_immutable_sampler_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_samplers(mut self, max_embedded_immutable_samplers: u32) -> Self { + self.max_embedded_immutable_samplers = max_embedded_immutable_samplers; + self + } + #[inline] + pub fn buffer_capture_replay_descriptor_data_size( + mut self, + buffer_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.buffer_capture_replay_descriptor_data_size = + buffer_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_capture_replay_descriptor_data_size( + mut self, + image_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.image_capture_replay_descriptor_data_size = image_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_view_capture_replay_descriptor_data_size( + mut self, + image_view_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.image_view_capture_replay_descriptor_data_size = + image_view_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_capture_replay_descriptor_data_size( + mut self, + sampler_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.sampler_capture_replay_descriptor_data_size = + sampler_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn acceleration_structure_capture_replay_descriptor_data_size( + mut self, + acceleration_structure_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.acceleration_structure_capture_replay_descriptor_data_size = + acceleration_structure_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self { + self.sampler_descriptor_size = sampler_descriptor_size; + self + } + #[inline] + pub fn combined_image_sampler_descriptor_size( + mut self, + combined_image_sampler_descriptor_size: usize, + ) -> Self { + self.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size; + self + } + #[inline] + pub fn sampled_image_descriptor_size(mut self, sampled_image_descriptor_size: usize) -> Self { + self.sampled_image_descriptor_size = sampled_image_descriptor_size; + self + } + #[inline] + pub fn storage_image_descriptor_size(mut self, storage_image_descriptor_size: usize) -> Self { + self.storage_image_descriptor_size = storage_image_descriptor_size; + self + } + #[inline] + pub fn uniform_texel_buffer_descriptor_size( + mut self, + uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_texel_buffer_descriptor_size( + mut self, + robust_uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.robust_uniform_texel_buffer_descriptor_size = + robust_uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_texel_buffer_descriptor_size( + mut self, + storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_texel_buffer_descriptor_size( + mut self, + robust_storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.robust_storage_texel_buffer_descriptor_size = + robust_storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn uniform_buffer_descriptor_size(mut self, uniform_buffer_descriptor_size: usize) -> Self { + self.uniform_buffer_descriptor_size = uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_buffer_descriptor_size( + mut self, + robust_uniform_buffer_descriptor_size: usize, + ) -> Self { + self.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_buffer_descriptor_size(mut self, storage_buffer_descriptor_size: usize) -> Self { + self.storage_buffer_descriptor_size = storage_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_buffer_descriptor_size( + mut self, + robust_storage_buffer_descriptor_size: usize, + ) -> Self { + self.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size; + self + } + #[inline] + pub fn input_attachment_descriptor_size( + mut self, + input_attachment_descriptor_size: usize, + ) -> Self { + self.input_attachment_descriptor_size = input_attachment_descriptor_size; + self + } + #[inline] + pub fn acceleration_structure_descriptor_size( + mut self, + acceleration_structure_descriptor_size: usize, + ) -> Self { + self.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_range( + mut self, + max_sampler_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_range( + mut self, + max_resource_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range; + self + } + #[inline] + pub fn sampler_descriptor_buffer_address_space_size( + mut self, + sampler_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.sampler_descriptor_buffer_address_space_size = + sampler_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn resource_descriptor_buffer_address_space_size( + mut self, + resource_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.resource_descriptor_buffer_address_space_size = + resource_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn descriptor_buffer_address_space_size( + mut self, + descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.descriptor_buffer_address_space_size = descriptor_buffer_address_space_size; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_density_map_descriptor_size: usize, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_density_map_descriptor_size: usize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + #[inline] + pub fn combined_image_sampler_density_map_descriptor_size( + mut self, + combined_image_sampler_density_map_descriptor_size: usize, + ) -> Self { + self.combined_image_sampler_density_map_descriptor_size = + combined_image_sampler_density_map_descriptor_size; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorAddressInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub range: DeviceSize, + pub format: Format, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DescriptorAddressInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + range: DeviceSize::default(), + format: Format::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorAddressInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_ADDRESS_INFO_EXT; +} +impl<'a> DescriptorAddressInfoEXT<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.address = address; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.range = range; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.format = format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub usage: BufferUsageFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DescriptorBufferBindingInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + usage: BufferUsageFlags::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorBufferBindingInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT; +} +pub unsafe trait ExtendsDescriptorBufferBindingInfoEXT {} +impl<'a> DescriptorBufferBindingInfoEXT<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.address = address; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.usage = usage; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer: Buffer::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; +} +unsafe impl ExtendsDescriptorBufferBindingInfoEXT + for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_> +{ +} +impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.buffer = buffer; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DescriptorDataEXT<'a> { + pub p_sampler: *const Sampler, + pub p_combined_image_sampler: *const DescriptorImageInfo, + pub p_input_attachment_image: *const DescriptorImageInfo, + pub p_sampled_image: *const DescriptorImageInfo, + pub p_storage_image: *const DescriptorImageInfo, + pub p_uniform_texel_buffer: *const DescriptorAddressInfoEXT<'a>, + pub p_storage_texel_buffer: *const DescriptorAddressInfoEXT<'a>, + pub p_uniform_buffer: *const DescriptorAddressInfoEXT<'a>, + pub p_storage_buffer: *const DescriptorAddressInfoEXT<'a>, + pub acceleration_structure: DeviceAddress, +} +impl<'a> ::std::default::Default for DescriptorDataEXT<'a> { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorGetInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: DescriptorType, + pub data: DescriptorDataEXT<'a>, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DescriptorGetInfoEXT<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DescriptorGetInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("data", &"union") + .finish() + } +} +impl ::std::default::Default for DescriptorGetInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: DescriptorType::default(), + data: DescriptorDataEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorGetInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_GET_INFO_EXT; +} +impl<'a> DescriptorGetInfoEXT<'a> { + #[inline] + pub fn ty(mut self, ty: DescriptorType) -> Self { + self.ty = ty; + self + } + #[inline] + pub fn data(mut self, data: DescriptorDataEXT<'a>) -> Self { + self.data = data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> BufferCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.buffer = buffer; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> ImageCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.image = image; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageViewCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageViewCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> ImageViewCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.image_view = image_view; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sampler: Sampler, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SamplerCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sampler: Sampler::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SamplerCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> SamplerCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.sampler = sampler; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureKHR, + pub acceleration_structure_nv: AccelerationStructureNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for AccelerationStructureCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureKHR::default(), + acceleration_structure_nv: AccelerationStructureNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + #[inline] + pub fn acceleration_structure_nv( + mut self, + acceleration_structure_nv: AccelerationStructureNV, + ) -> Self { + self.acceleration_structure_nv = acceleration_structure_nv; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_descriptor_data: *const c_void, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_descriptor_data: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; +} +unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR + for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoNV + for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> +{ +} +impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + #[inline] + pub fn opaque_capture_descriptor_data( + mut self, + opaque_capture_descriptor_data: *const c_void, + ) -> Self { + self.opaque_capture_descriptor_data = opaque_capture_descriptor_data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceShaderIntegerDotProductFeatures<'a> { pub s_type: StructureType, diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index b96ffd055..40c534daf 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1821,6 +1821,8 @@ impl DriverId { pub const MESA_VENUS: Self = Self(22); #[doc = "Mesa open source project"] pub const MESA_DOZEN: Self = Self(23); + #[doc = "Mesa open source project"] + pub const MESA_NVK: Self = Self(24); } #[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 b5c58a488..4f12a2fa8 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -17361,62 +17361,409 @@ impl AmdExtension316Fn { Self {} } } -impl AmdExtension317Fn { +impl ExtDescriptorBufferFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_317\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_buffer\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + p_layout_size_in_bytes: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + binding: u32, + p_offset: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorEXT = unsafe extern "system" fn( + device: Device, + p_descriptor_info: *const DescriptorGetInfoEXT, + data_size: usize, + p_descriptor: *mut c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer_count: u32, + p_binding_infos: *const DescriptorBufferBindingInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: u32, + set_count: u32, + p_buffer_indices: *const u32, + p_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const BufferCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const SamplerCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = + unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, + ) -> Result; #[derive(Clone)] -pub struct AmdExtension317Fn {} -unsafe impl Send for AmdExtension317Fn {} -unsafe impl Sync for AmdExtension317Fn {} -impl AmdExtension317Fn { +pub struct ExtDescriptorBufferFn { + pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT, + pub get_descriptor_set_layout_binding_offset_ext: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT, + pub get_descriptor_ext: PFN_vkGetDescriptorEXT, + pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT, + pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT, + pub cmd_bind_descriptor_buffer_embedded_samplers_ext: + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, + pub get_buffer_opaque_capture_descriptor_data_ext: + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT, + pub get_image_opaque_capture_descriptor_data_ext: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT, + pub get_image_view_opaque_capture_descriptor_data_ext: + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT, + pub get_sampler_opaque_capture_descriptor_data_ext: + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT, + pub get_acceleration_structure_opaque_capture_descriptor_data_ext: + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, +} +unsafe impl Send for ExtDescriptorBufferFn {} +unsafe impl Sync for ExtDescriptorBufferFn {} +impl ExtDescriptorBufferFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_descriptor_set_layout_size_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_size_ext( + _device: Device, + _layout: DescriptorSetLayout, + _p_layout_size_in_bytes: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_size_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_layout_binding_offset_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext( + _device: Device, + _layout: DescriptorSetLayout, + _binding: u32, + _p_offset: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_binding_offset_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutBindingOffsetEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_binding_offset_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_ext: unsafe { + unsafe extern "system" fn get_descriptor_ext( + _device: Device, + _p_descriptor_info: *const DescriptorGetInfoEXT, + _data_size: usize, + _p_descriptor: *mut c_void, + ) { + panic!(concat!("Unable to load ", stringify!(get_descriptor_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0"); + let val = _f(cname); + if val.is_null() { + get_descriptor_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffers_ext( + _command_buffer: CommandBuffer, + _buffer_count: u32, + _p_binding_infos: *const DescriptorBufferBindingInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBuffersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffers_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_descriptor_buffer_offsets_ext: unsafe { + unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _first_set: u32, + _set_count: u32, + _p_buffer_indices: *const u32, + _p_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_descriptor_buffer_offsets_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDescriptorBufferOffsetsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_descriptor_buffer_offsets_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffer_embedded_samplers_ext + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const BufferCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_view_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_view_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_sampler_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const SamplerCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_sampler_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_sampler_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl AccelerationStructureCreateFlagsKHR { - pub const RESERVED_3_AMD: Self = Self(0b1000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl AccessFlags2 { - pub const RESERVED_41_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const DESCRIPTOR_BUFFER_READ_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl BufferCreateFlags { - pub const RESERVED_5_AMD: Self = Self(0b10_0000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b10_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl BufferUsageFlags { - pub const RESERVED_21_AMD: Self = Self(0b10_0000_0000_0000_0000_0000); - pub const RESERVED_22_AMD: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const SAMPLER_DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const RESOURCE_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl DescriptorSetLayoutCreateFlags { - pub const RESERVED_4_AMD: Self = Self(0b1_0000); - pub const RESERVED_5_AMD: Self = Self(0b10_0000); + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b1_0000); + pub const EMBEDDED_IMMUTABLE_SAMPLERS_EXT: Self = Self(0b10_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl ImageCreateFlags { - pub const RESERVED_16_AMD: Self = Self(0b1_0000_0000_0000_0000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl ImageViewCreateFlags { - pub const RESERVED_2_AMD: Self = Self(0b100); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b100); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl PipelineCreateFlags { - pub const RESERVED_29_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl SamplerCreateFlags { - pub const RESERVED_3_AMD: Self = Self(0b1000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self(1_000_316_000); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: Self = + Self(1_000_316_001); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: Self = Self(1_000_316_002); + pub const DESCRIPTOR_ADDRESS_INFO_EXT: Self = Self(1_000_316_003); + pub const DESCRIPTOR_GET_INFO_EXT: Self = Self(1_000_316_004); + pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_005); + pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_006); + pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_007); + pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_008); + pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: Self = Self(1_000_316_010); + pub const DESCRIPTOR_BUFFER_BINDING_INFO_EXT: Self = Self(1_000_316_011); + pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: Self = + Self(1_000_316_012); + pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_009); } impl AmdExtension318Fn { #[inline] @@ -21261,6 +21608,15 @@ impl HuaweiExtension405Fn { Self {} } } +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl PipelineStageFlags2 { + pub const RESEVED_41_HUAWEI: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl ShaderStageFlags { + pub const RESERVED_19_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000); +} impl HuaweiExtension406Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -24789,3 +25145,79 @@ impl ExtExtension500Fn { Self {} } } +impl ExtExtension501Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_501\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension501Fn {} +unsafe impl Send for ExtExtension501Fn {} +unsafe impl Sync for ExtExtension501Fn {} +impl ExtExtension501Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension502Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_502\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension502Fn {} +unsafe impl Send for ExtExtension502Fn {} +unsafe impl Sync for ExtExtension502Fn {} +impl ExtExtension502Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension503Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_503\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension503Fn {} +unsafe impl Send for ExtExtension503Fn {} +unsafe impl Sync for ExtExtension503Fn {} +impl ExtExtension503Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension504Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_504\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension504Fn {} +unsafe impl Send for NvExtension504Fn {} +unsafe impl Sync for NvExtension504Fn {} +impl NvExtension504Fn { + 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 d4c221772..b7a86d3b2 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit d4c221772cb222117446521517254c91f9211801 +Subproject commit b7a86d3b2bf8fbe73fcd40df9ec62a5966e9db89