From ca68ebd61b3d4767e392099cedce3bc8322a97d8 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Mon, 3 Apr 2023 10:18:26 +0200 Subject: [PATCH] Update Vulkan-Headers to 1.3.246 (#723) * Update Vulkan-Headers to 1.3.245 * Upgrade `bindgen` to `0.64` * Update Vulkan-Headers to 1.3.246 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/vk/aliases.rs | 2 + ash/src/vk/bitflags.rs | 14 + ash/src/vk/const_debugs.rs | 103 ++- ash/src/vk/definitions.rs | 831 ++++++++++++++++++++++- ash/src/vk/enums.rs | 41 ++ ash/src/vk/extensions.rs | 1298 +++++++++++++++++++++++++++++++++++- ash/src/vk/native.rs | 2 +- generator/Cargo.toml | 2 +- generator/Vulkan-Headers | 2 +- 11 files changed, 2251 insertions(+), 48 deletions(-) diff --git a/Changelog.md b/Changelog.md index cb4ba7a..4cd1ddc 100644 --- a/Changelog.md +++ b/Changelog.md @@ -8,7 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added -- Update Vulkan-Headers to 1.3.244 (#697) +- Update Vulkan-Headers to 1.3.246 (#697, #723) - Added `VK_KHR_performance_query` device extension (#726) ## [0.37.2] - 2022-01-11 diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 02aa73c..c4cb43f 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.2+1.3.244" +version = "0.37.2+1.3.246" authors = [ "Maik Klein ", "Benjamin Saunders ", diff --git a/ash/src/vk/aliases.rs b/ash/src/vk/aliases.rs index 1e5d20f..7eb57b7 100644 --- a/ash/src/vk/aliases.rs +++ b/ash/src/vk/aliases.rs @@ -200,6 +200,8 @@ pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties; pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; +pub type ShaderRequiredSubgroupSizeCreateInfoEXT = + PipelineShaderStageRequiredSubgroupSizeCreateInfo; pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT = diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index 2f48e7d..1189e1e 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1613,3 +1613,17 @@ vk_bitflags_wrapped!(MicromapCreateFlagsEXT, Flags); impl MicromapCreateFlagsEXT { pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); } +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ShaderCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderCreateFlagsEXT, Flags); +impl ShaderCreateFlagsEXT { + pub const LINK_STAGE: Self = Self(0b1); + pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(0b10); + pub const REQUIRE_FULL_SUBGROUPS: Self = Self(0b100); + pub const NO_TASK_SHADER: Self = Self(0b1000); + pub const DISPATCH_BASE: Self = Self(0b1_0000); + pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(0b10_0000); + pub const FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(0b100_0000); +} diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 37c8baf..e196bcd 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -318,11 +318,15 @@ impl fmt::Debug for AccessFlags2 { ), (AccessFlags2::MICROMAP_READ_EXT.0, "MICROMAP_READ_EXT"), (AccessFlags2::MICROMAP_WRITE_EXT.0, "MICROMAP_WRITE_EXT"), + (AccessFlags2::RESERVED_49_ARM.0, "RESERVED_49_ARM"), + (AccessFlags2::RESERVED_50_ARM.0, "RESERVED_50_ARM"), (AccessFlags2::OPTICAL_FLOW_READ_NV.0, "OPTICAL_FLOW_READ_NV"), ( AccessFlags2::OPTICAL_FLOW_WRITE_NV.0, "OPTICAL_FLOW_WRITE_NV", ), + (AccessFlags2::RESERVED_47_EXT.0, "RESERVED_47_EXT"), + (AccessFlags2::RESERVED_48_EXT.0, "RESERVED_48_EXT"), ]; debug_flags(f, KNOWN, self.0) } @@ -655,12 +659,8 @@ impl fmt::Debug for BuildAccelerationStructureFlagsKHR { "ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT", ), ( - BuildAccelerationStructureFlagsKHR::RESERVED_9_NV.0, - "RESERVED_9_NV", - ), - ( - BuildAccelerationStructureFlagsKHR::RESERVED_10_NV.0, - "RESERVED_10_NV", + BuildAccelerationStructureFlagsKHR::ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV.0, + "ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV", ), ]; debug_flags(f, KNOWN, self.0) @@ -1448,6 +1448,21 @@ impl fmt::Debug for DiscardRectangleModeEXT { } } } +impl fmt::Debug for DisplacementMicromapFormatNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_64_TRIANGLES_64_BYTES => Some("TYPE_64_TRIANGLES_64_BYTES"), + Self::TYPE_256_TRIANGLES_128_BYTES => Some("TYPE_256_TRIANGLES_128_BYTES"), + Self::TYPE_1024_TRIANGLES_128_BYTES => Some("TYPE_1024_TRIANGLES_128_BYTES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -2713,6 +2728,7 @@ impl fmt::Debug for ImageUsageFlags { ImageUsageFlags::SAMPLE_BLOCK_MATCH_QCOM.0, "SAMPLE_BLOCK_MATCH_QCOM", ), + (ImageUsageFlags::RESERVED_23_EXT.0, "RESERVED_23_EXT"), ]; debug_flags(f, KNOWN, self.0) } @@ -2989,6 +3005,7 @@ impl fmt::Debug for MicromapTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"), + Self::DISPLACEMENT_MICROMAP_NV => Some("DISPLACEMENT_MICROMAP_NV"), _ => None, }; if let Some(x) = name { @@ -3446,7 +3463,10 @@ impl fmt::Debug for PipelineCreateFlags { PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_EXT.0, "RAY_TRACING_OPACITY_MICROMAP_EXT", ), - (PipelineCreateFlags::RESERVED_28_NV.0, "RESERVED_28_NV"), + ( + PipelineCreateFlags::RAY_TRACING_DISPLACEMENT_MICROMAP_NV.0, + "RAY_TRACING_DISPLACEMENT_MICROMAP_NV", + ), ( PipelineCreateFlags::NO_PROTECTED_ACCESS_EXT.0, "NO_PROTECTED_ACCESS_EXT", @@ -3795,7 +3815,9 @@ impl fmt::Debug for PipelineStageFlags2 { PipelineStageFlags2::CLUSTER_CULLING_SHADER_HUAWEI.0, "CLUSTER_CULLING_SHADER_HUAWEI", ), + (PipelineStageFlags2::RESERVED_43_ARM.0, "RESERVED_43_ARM"), (PipelineStageFlags2::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), + (PipelineStageFlags2::RESERVED_42_EXT.0, "RESERVED_42_EXT"), ]; debug_flags(f, KNOWN, self.0) } @@ -4102,7 +4124,9 @@ impl fmt::Debug for QueueFlags { (QueueFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"), (QueueFlags::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"), (QueueFlags::RESERVED_7_QCOM.0, "RESERVED_7_QCOM"), + (QueueFlags::RESERVED_11_ARM.0, "RESERVED_11_ARM"), (QueueFlags::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), + (QueueFlags::RESERVED_10_EXT.0, "RESERVED_10_EXT"), (QueueFlags::PROTECTED.0, "PROTECTED"), ]; debug_flags(f, KNOWN, self.0) @@ -4374,12 +4398,52 @@ impl fmt::Debug for SemaphoreWaitFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for ShaderCodeTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BINARY => Some("BINARY"), + Self::SPIRV => Some("SPIRV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for ShaderCorePropertiesFlagsAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[]; debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for ShaderCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderCreateFlagsEXT::LINK_STAGE.0, "LINK_STAGE"), + ( + ShaderCreateFlagsEXT::ALLOW_VARYING_SUBGROUP_SIZE.0, + "ALLOW_VARYING_SUBGROUP_SIZE", + ), + ( + ShaderCreateFlagsEXT::REQUIRE_FULL_SUBGROUPS.0, + "REQUIRE_FULL_SUBGROUPS", + ), + (ShaderCreateFlagsEXT::NO_TASK_SHADER.0, "NO_TASK_SHADER"), + (ShaderCreateFlagsEXT::DISPATCH_BASE.0, "DISPATCH_BASE"), + ( + ShaderCreateFlagsEXT::FRAGMENT_SHADING_RATE_ATTACHMENT.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT", + ), + ( + ShaderCreateFlagsEXT::FRAGMENT_DENSITY_MAP_ATTACHMENT.0, + "FRAGMENT_DENSITY_MAP_ATTACHMENT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for ShaderFloatControlsIndependence { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -4465,9 +4529,6 @@ impl fmt::Debug for ShaderStageFlags { ShaderStageFlags::CLUSTER_CULLING_HUAWEI.0, "CLUSTER_CULLING_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"), ]; debug_flags(f, KNOWN, self.0) } @@ -5728,6 +5789,12 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT => { Some("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT") + } Self::MICROMAP_BUILD_INFO_EXT => Some("MICROMAP_BUILD_INFO_EXT"), Self::MICROMAP_VERSION_INFO_EXT => Some("MICROMAP_VERSION_INFO_EXT"), Self::COPY_MICROMAP_INFO_EXT => Some("COPY_MICROMAP_INFO_EXT"), @@ -5744,6 +5811,15 @@ impl fmt::Debug for StructureType { Self::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT => { Some("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT") } + Self::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV") + } + Self::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV => { + Some("ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV") + } Self::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI => { Some("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI") } @@ -5871,6 +5947,13 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT") + } + Self::SHADER_CREATE_INFO_EXT => Some("SHADER_CREATE_INFO_EXT"), Self::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM => { Some("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM") } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 52a4f2b..849ec85 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -57,7 +57,7 @@ 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); #[doc = ""] -pub const HEADER_VERSION: u32 = 244; +pub const HEADER_VERSION: u32 = 246; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -432,6 +432,12 @@ handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "" +); handle_nondispatchable!( DisplayKHR, DISPLAY_KHR, @@ -44512,6 +44518,11 @@ unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineShaderStageRequiredSubgroupSizeCreateInfo { } +unsafe impl ExtendsShaderCreateInfoEXT + for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsShaderCreateInfoEXT for PipelineShaderStageRequiredSubgroupSizeCreateInfo {} impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo; fn deref(&self) -> &Self::Target { @@ -68725,6 +68736,370 @@ impl<'a> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDisplacementMicromapFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub displacement_micromap: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDisplacementMicromapFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + displacement_micromap: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDisplacementMicromapFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV; +} +impl PhysicalDeviceDisplacementMicromapFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> { + PhysicalDeviceDisplacementMicromapFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> { + inner: PhysicalDeviceDisplacementMicromapFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDisplacementMicromapFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDisplacementMicromapFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceDisplacementMicromapFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> { + #[inline] + pub fn displacement_micromap(mut self, displacement_micromap: bool) -> Self { + self.inner.displacement_micromap = displacement_micromap.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) -> PhysicalDeviceDisplacementMicromapFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDisplacementMicromapPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_displacement_micromap_subdivision_level: u32, +} +impl ::std::default::Default for PhysicalDeviceDisplacementMicromapPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_displacement_micromap_subdivision_level: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDisplacementMicromapPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV; +} +impl PhysicalDeviceDisplacementMicromapPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> { + PhysicalDeviceDisplacementMicromapPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> { + inner: PhysicalDeviceDisplacementMicromapPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDisplacementMicromapPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceDisplacementMicromapPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> { + #[inline] + pub fn max_displacement_micromap_subdivision_level( + mut self, + max_displacement_micromap_subdivision_level: u32, + ) -> Self { + self.inner.max_displacement_micromap_subdivision_level = + max_displacement_micromap_subdivision_level; + 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) -> PhysicalDeviceDisplacementMicromapPropertiesNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureTrianglesDisplacementMicromapNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub displacement_bias_and_scale_format: Format, + pub displacement_vector_format: Format, + pub displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR, + pub displacement_bias_and_scale_stride: DeviceSize, + pub displacement_vector_buffer: DeviceOrHostAddressConstKHR, + pub displacement_vector_stride: DeviceSize, + pub displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR, + pub displaced_micromap_primitive_flags_stride: DeviceSize, + pub index_type: IndexType, + pub index_buffer: DeviceOrHostAddressConstKHR, + pub index_stride: DeviceSize, + pub base_triangle: u32, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageEXT, + pub pp_usage_counts: *const *const MicromapUsageEXT, + pub micromap: MicromapEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureTrianglesDisplacementMicromapNV { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureTrianglesDisplacementMicromapNV") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field( + "displacement_bias_and_scale_format", + &self.displacement_bias_and_scale_format, + ) + .field( + "displacement_vector_format", + &self.displacement_vector_format, + ) + .field("displacement_bias_and_scale_buffer", &"union") + .field( + "displacement_bias_and_scale_stride", + &self.displacement_bias_and_scale_stride, + ) + .field("displacement_vector_buffer", &"union") + .field( + "displacement_vector_stride", + &self.displacement_vector_stride, + ) + .field("displaced_micromap_primitive_flags", &"union") + .field( + "displaced_micromap_primitive_flags_stride", + &self.displaced_micromap_primitive_flags_stride, + ) + .field("index_type", &self.index_type) + .field("index_buffer", &"union") + .field("index_stride", &self.index_stride) + .field("base_triangle", &self.base_triangle) + .field("usage_counts_count", &self.usage_counts_count) + .field("p_usage_counts", &self.p_usage_counts) + .field("pp_usage_counts", &self.pp_usage_counts) + .field("micromap", &self.micromap) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureTrianglesDisplacementMicromapNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + displacement_bias_and_scale_format: Format::default(), + displacement_vector_format: Format::default(), + displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR::default(), + displacement_bias_and_scale_stride: DeviceSize::default(), + displacement_vector_buffer: DeviceOrHostAddressConstKHR::default(), + displacement_vector_stride: DeviceSize::default(), + displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR::default(), + displaced_micromap_primitive_flags_stride: DeviceSize::default(), + index_type: IndexType::default(), + index_buffer: DeviceOrHostAddressConstKHR::default(), + index_stride: DeviceSize::default(), + base_triangle: u32::default(), + usage_counts_count: u32::default(), + p_usage_counts: ::std::ptr::null(), + pp_usage_counts: ::std::ptr::null(), + micromap: MicromapEXT::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureTrianglesDisplacementMicromapNV { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV; +} +impl AccelerationStructureTrianglesDisplacementMicromapNV { + pub fn builder<'a>() -> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> { + AccelerationStructureTrianglesDisplacementMicromapNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> { + inner: AccelerationStructureTrianglesDisplacementMicromapNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesDisplacementMicromapNV +{ +} +impl<'a> ::std::ops::Deref for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> { + type Target = AccelerationStructureTrianglesDisplacementMicromapNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> { + #[inline] + pub fn displacement_bias_and_scale_format( + mut self, + displacement_bias_and_scale_format: Format, + ) -> Self { + self.inner.displacement_bias_and_scale_format = displacement_bias_and_scale_format; + self + } + #[inline] + pub fn displacement_vector_format(mut self, displacement_vector_format: Format) -> Self { + self.inner.displacement_vector_format = displacement_vector_format; + self + } + #[inline] + pub fn displacement_bias_and_scale_buffer( + mut self, + displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR, + ) -> Self { + self.inner.displacement_bias_and_scale_buffer = displacement_bias_and_scale_buffer; + self + } + #[inline] + pub fn displacement_bias_and_scale_stride( + mut self, + displacement_bias_and_scale_stride: DeviceSize, + ) -> Self { + self.inner.displacement_bias_and_scale_stride = displacement_bias_and_scale_stride; + self + } + #[inline] + pub fn displacement_vector_buffer( + mut self, + displacement_vector_buffer: DeviceOrHostAddressConstKHR, + ) -> Self { + self.inner.displacement_vector_buffer = displacement_vector_buffer; + self + } + #[inline] + pub fn displacement_vector_stride(mut self, displacement_vector_stride: DeviceSize) -> Self { + self.inner.displacement_vector_stride = displacement_vector_stride; + self + } + #[inline] + pub fn displaced_micromap_primitive_flags( + mut self, + displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR, + ) -> Self { + self.inner.displaced_micromap_primitive_flags = displaced_micromap_primitive_flags; + self + } + #[inline] + pub fn displaced_micromap_primitive_flags_stride( + mut self, + displaced_micromap_primitive_flags_stride: DeviceSize, + ) -> Self { + self.inner.displaced_micromap_primitive_flags_stride = + displaced_micromap_primitive_flags_stride; + self + } + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[inline] + pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self { + self.inner.index_buffer = index_buffer; + self + } + #[inline] + pub fn index_stride(mut self, index_stride: DeviceSize) -> Self { + self.inner.index_stride = index_stride; + self + } + #[inline] + pub fn base_triangle(mut self, base_triangle: u32) -> Self { + self.inner.base_triangle = base_triangle; + self + } + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts.len() as _; + self.inner.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts_ptrs.len() as _; + self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn micromap(mut self, micromap: MicromapEXT) -> Self { + self.inner.micromap = micromap; + 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) -> AccelerationStructureTrianglesDisplacementMicromapNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PipelinePropertiesIdentifierEXT { pub s_type: StructureType, @@ -73666,3 +74041,457 @@ impl<'a> MemoryUnmapInfoKHRBuilder<'a> { self.inner } } +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderObjectFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_object: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderObjectFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_object: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderObjectFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; +} +impl PhysicalDeviceShaderObjectFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderObjectFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderObjectFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderObjectFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderObjectFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderObjectFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_object(mut self, shader_object: bool) -> Self { + self.inner.shader_object = shader_object.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) -> PhysicalDeviceShaderObjectFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderObjectPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_binary_uuid: [u8; UUID_SIZE], + pub shader_binary_version: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderObjectPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_binary_uuid: unsafe { ::std::mem::zeroed() }, + shader_binary_version: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderObjectPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; +} +impl PhysicalDeviceShaderObjectPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> { + PhysicalDeviceShaderObjectPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceShaderObjectPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderObjectPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderObjectPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> { + #[inline] + pub fn shader_binary_uuid(mut self, shader_binary_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.shader_binary_uuid = shader_binary_uuid; + self + } + #[inline] + pub fn shader_binary_version(mut self, shader_binary_version: u32) -> Self { + self.inner.shader_binary_version = shader_binary_version; + 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) -> PhysicalDeviceShaderObjectPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ShaderCreateFlagsEXT, + pub stage: ShaderStageFlags, + pub next_stage: ShaderStageFlags, + pub code_type: ShaderCodeTypeEXT, + pub code_size: usize, + pub p_code: *const c_void, + pub p_name: *const c_char, + pub set_layout_count: u32, + pub p_set_layouts: *const DescriptorSetLayout, + pub push_constant_range_count: u32, + pub p_push_constant_ranges: *const PushConstantRange, + pub p_specialization_info: *const SpecializationInfo, +} +impl ::std::default::Default for ShaderCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ShaderCreateFlagsEXT::default(), + stage: ShaderStageFlags::default(), + next_stage: ShaderStageFlags::default(), + code_type: ShaderCodeTypeEXT::default(), + code_size: usize::default(), + p_code: ::std::ptr::null(), + p_name: ::std::ptr::null(), + set_layout_count: u32::default(), + p_set_layouts: ::std::ptr::null(), + push_constant_range_count: u32::default(), + p_push_constant_ranges: ::std::ptr::null(), + p_specialization_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ShaderCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SHADER_CREATE_INFO_EXT; +} +impl ShaderCreateInfoEXT { + pub fn builder<'a>() -> ShaderCreateInfoEXTBuilder<'a> { + ShaderCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderCreateInfoEXTBuilder<'a> { + inner: ShaderCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsShaderCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ShaderCreateInfoEXTBuilder<'a> { + type Target = ShaderCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ShaderCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stage(mut self, stage: ShaderStageFlags) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn next_stage(mut self, next_stage: ShaderStageFlags) -> Self { + self.inner.next_stage = next_stage; + self + } + #[inline] + pub fn code_type(mut self, code_type: ShaderCodeTypeEXT) -> Self { + self.inner.code_type = code_type; + self + } + #[inline] + pub fn code(mut self, code: &'a [u8]) -> Self { + self.inner.code_size = code.len(); + self.inner.p_code = code.as_ptr().cast(); + self + } + #[inline] + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_name = name.as_ptr(); + self + } + #[inline] + pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self { + self.inner.set_layout_count = set_layouts.len() as _; + self.inner.p_set_layouts = set_layouts.as_ptr(); + self + } + #[inline] + pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self { + self.inner.push_constant_range_count = push_constant_ranges.len() as _; + self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr(); + self + } + #[inline] + pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self { + self.inner.p_specialization_info = specialization_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 `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderTileImageFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_tile_image_color_read_access: Bool32, + pub shader_tile_image_depth_read_access: Bool32, + pub shader_tile_image_stencil_read_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderTileImageFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_tile_image_color_read_access: Bool32::default(), + shader_tile_image_depth_read_access: Bool32::default(), + shader_tile_image_stencil_read_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderTileImageFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; +} +impl PhysicalDeviceShaderTileImageFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderTileImageFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderTileImageFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTileImageFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTileImageFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderTileImageFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_tile_image_color_read_access( + mut self, + shader_tile_image_color_read_access: bool, + ) -> Self { + self.inner.shader_tile_image_color_read_access = shader_tile_image_color_read_access.into(); + self + } + #[inline] + pub fn shader_tile_image_depth_read_access( + mut self, + shader_tile_image_depth_read_access: bool, + ) -> Self { + self.inner.shader_tile_image_depth_read_access = shader_tile_image_depth_read_access.into(); + self + } + #[inline] + pub fn shader_tile_image_stencil_read_access( + mut self, + shader_tile_image_stencil_read_access: bool, + ) -> Self { + self.inner.shader_tile_image_stencil_read_access = + shader_tile_image_stencil_read_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) -> PhysicalDeviceShaderTileImageFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderTileImagePropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_tile_image_coherent_read_accelerated: Bool32, + pub shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32, + pub shader_tile_image_read_from_helper_invocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderTileImagePropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_tile_image_coherent_read_accelerated: Bool32::default(), + shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32::default(), + shader_tile_image_read_from_helper_invocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderTileImagePropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; +} +impl PhysicalDeviceShaderTileImagePropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> { + PhysicalDeviceShaderTileImagePropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> { + inner: PhysicalDeviceShaderTileImagePropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderTileImagePropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderTileImagePropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> { + #[inline] + pub fn shader_tile_image_coherent_read_accelerated( + mut self, + shader_tile_image_coherent_read_accelerated: bool, + ) -> Self { + self.inner.shader_tile_image_coherent_read_accelerated = + shader_tile_image_coherent_read_accelerated.into(); + self + } + #[inline] + pub fn shader_tile_image_read_sample_from_pixel_rate_invocation( + mut self, + shader_tile_image_read_sample_from_pixel_rate_invocation: bool, + ) -> Self { + self.inner + .shader_tile_image_read_sample_from_pixel_rate_invocation = + shader_tile_image_read_sample_from_pixel_rate_invocation.into(); + self + } + #[inline] + pub fn shader_tile_image_read_from_helper_invocation( + mut self, + shader_tile_image_read_from_helper_invocation: bool, + ) -> Self { + self.inner.shader_tile_image_read_from_helper_invocation = + shader_tile_image_read_from_helper_invocation.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) -> PhysicalDeviceShaderTileImagePropertiesEXT { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 289b621..6201209 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -2784,6 +2784,43 @@ impl DeviceFaultVendorBinaryHeaderVersionEXT { impl DeviceFaultVendorBinaryHeaderVersionEXT { pub const ONE: Self = Self(1); } +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DisplacementMicromapFormatNV(pub(crate) i32); +impl DisplacementMicromapFormatNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DisplacementMicromapFormatNV { + pub const TYPE_64_TRIANGLES_64_BYTES: Self = Self(1); + pub const TYPE_256_TRIANGLES_128_BYTES: Self = Self(2); + pub const TYPE_1024_TRIANGLES_128_BYTES: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderCodeTypeEXT(pub(crate) i32); +impl ShaderCodeTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderCodeTypeEXT { + pub const BINARY: Self = Self(0); + pub const SPIRV: Self = Self(1); +} impl fmt::Debug for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -2832,6 +2869,7 @@ impl fmt::Debug for ObjectType { Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), Self::MICROMAP_EXT => Some("MICROMAP_EXT"), Self::OPTICAL_FLOW_SESSION_NV => Some("OPTICAL_FLOW_SESSION_NV"), + Self::SHADER_EXT => Some("SHADER_EXT"), Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), Self::PRIVATE_DATA_SLOT => Some("PRIVATE_DATA_SLOT"), @@ -2906,6 +2944,9 @@ impl fmt::Debug for Result { Some("ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR") } Self::ERROR_COMPRESSION_EXHAUSTED_EXT => Some("ERROR_COMPRESSION_EXHAUSTED_EXT"), + Self::ERROR_INCOMPATIBLE_SHADER_BINARY_EXT => { + Some("ERROR_INCOMPATIBLE_SHADER_BINARY_EXT") + } Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"), Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"), Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"), diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 2b130f1..78874d5 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -21072,18 +21072,18 @@ impl KhrPortabilityEnumerationFn { impl InstanceCreateFlags { pub const ENUMERATE_PORTABILITY_KHR: Self = Self(0b1); } -impl KhrExtension396Fn { +impl ExtShaderTileImageFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_396\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_tile_image\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct KhrExtension396Fn {} -unsafe impl Send for KhrExtension396Fn {} -unsafe impl Sync for KhrExtension396Fn {} -impl KhrExtension396Fn { +pub struct ExtShaderTileImageFn {} +unsafe impl Send for ExtShaderTileImageFn {} +unsafe impl Sync for ExtShaderTileImageFn {} +impl ExtShaderTileImageFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -21091,6 +21091,11 @@ impl KhrExtension396Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_shader_tile_image'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: Self = Self(1_000_395_000); + pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: Self = Self(1_000_395_001); +} impl ExtOpacityMicromapFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -21548,18 +21553,18 @@ impl StructureType { pub const MICROMAP_BUILD_SIZES_INFO_EXT: Self = Self(1_000_396_008); pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: Self = Self(1_000_396_009); } -impl NvExtension398Fn { +impl NvDisplacementMicromapFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_398\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_displacement_micromap\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct NvExtension398Fn {} -unsafe impl Send for NvExtension398Fn {} -unsafe impl Sync for NvExtension398Fn {} -impl NvExtension398Fn { +pub struct NvDisplacementMicromapFn {} +unsafe impl Send for NvDisplacementMicromapFn {} +unsafe impl Sync for NvDisplacementMicromapFn {} +impl NvDisplacementMicromapFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -21567,14 +21572,24 @@ impl NvExtension398Fn { Self {} } } -#[doc = "Generated from 'VK_NV_extension_398'"] +#[doc = "Generated from 'VK_NV_displacement_micromap'"] impl BuildAccelerationStructureFlagsKHR { - pub const RESERVED_9_NV: Self = Self(0b10_0000_0000); - pub const RESERVED_10_NV: Self = Self(0b100_0000_0000); + pub const ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV: Self = Self(0b10_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_398'"] +#[doc = "Generated from 'VK_NV_displacement_micromap'"] +impl MicromapTypeEXT { + pub const DISPLACEMENT_MICROMAP_NV: Self = Self(1_000_397_000); +} +#[doc = "Generated from 'VK_NV_displacement_micromap'"] impl PipelineCreateFlags { - pub const RESERVED_28_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); + pub const RAY_TRACING_DISPLACEMENT_MICROMAP_NV: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_displacement_micromap'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: Self = Self(1_000_397_000); + pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: Self = Self(1_000_397_001); + pub const ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: Self = Self(1_000_397_002); } impl JuiceExtension399Fn { #[inline] @@ -23142,6 +23157,22 @@ impl ArmExtension453Fn { Self {} } } +#[doc = "Generated from 'VK_ARM_extension_453'"] +impl AccessFlags2 { + pub const RESERVED_49_ARM: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESERVED_50_ARM: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_ARM_extension_453'"] +impl PipelineStageFlags2 { + pub const RESERVED_43_ARM: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_ARM_extension_453'"] +impl QueueFlags { + pub const RESERVED_11_ARM: Self = Self(0b1000_0000_0000); +} impl GoogleExtension454Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -24156,6 +24187,10 @@ impl ExtExtension461Fn { impl FormatFeatureFlags2 { pub const RESERVED_39_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } +#[doc = "Generated from 'VK_EXT_extension_461'"] +impl ImageUsageFlags { + pub const RESERVED_23_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); +} impl ExtExtension462Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -24861,30 +24896,1195 @@ impl ExtExtension482Fn { Self {} } } -impl ExtExtension483Fn { +impl ExtShaderObjectFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_483\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_object\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCreateShadersEXT = unsafe extern "system" fn( + device: Device, + create_info_count: u32, + p_create_infos: *const ShaderCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_shaders: *mut ShaderEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyShaderEXT = unsafe extern "system" fn( + device: Device, + shader: ShaderEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn( + device: Device, + shader: ShaderEXT, + p_data_size: *mut usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindShadersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + stage_count: u32, + p_stages: *const ShaderStageFlags, + p_shaders: *const ShaderEXT, +); #[derive(Clone)] -pub struct ExtExtension483Fn {} -unsafe impl Send for ExtExtension483Fn {} -unsafe impl Sync for ExtExtension483Fn {} -impl ExtExtension483Fn { +pub struct ExtShaderObjectFn { + pub create_shaders_ext: PFN_vkCreateShadersEXT, + pub destroy_shader_ext: PFN_vkDestroyShaderEXT, + pub get_shader_binary_data_ext: PFN_vkGetShaderBinaryDataEXT, + pub cmd_bind_shaders_ext: PFN_vkCmdBindShadersEXT, + pub cmd_set_cull_mode_ext: crate::vk::PFN_vkCmdSetCullMode, + pub cmd_set_front_face_ext: crate::vk::PFN_vkCmdSetFrontFace, + pub cmd_set_primitive_topology_ext: crate::vk::PFN_vkCmdSetPrimitiveTopology, + pub cmd_set_viewport_with_count_ext: crate::vk::PFN_vkCmdSetViewportWithCount, + pub cmd_set_scissor_with_count_ext: crate::vk::PFN_vkCmdSetScissorWithCount, + pub cmd_bind_vertex_buffers2_ext: crate::vk::PFN_vkCmdBindVertexBuffers2, + pub cmd_set_depth_test_enable_ext: crate::vk::PFN_vkCmdSetDepthTestEnable, + pub cmd_set_depth_write_enable_ext: crate::vk::PFN_vkCmdSetDepthWriteEnable, + pub cmd_set_depth_compare_op_ext: crate::vk::PFN_vkCmdSetDepthCompareOp, + pub cmd_set_depth_bounds_test_enable_ext: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable, + pub cmd_set_stencil_test_enable_ext: crate::vk::PFN_vkCmdSetStencilTestEnable, + pub cmd_set_stencil_op_ext: crate::vk::PFN_vkCmdSetStencilOp, + pub cmd_set_vertex_input_ext: crate::vk::PFN_vkCmdSetVertexInputEXT, + pub cmd_set_patch_control_points_ext: crate::vk::PFN_vkCmdSetPatchControlPointsEXT, + pub cmd_set_rasterizer_discard_enable_ext: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable, + pub cmd_set_depth_bias_enable_ext: crate::vk::PFN_vkCmdSetDepthBiasEnable, + pub cmd_set_logic_op_ext: crate::vk::PFN_vkCmdSetLogicOpEXT, + pub cmd_set_primitive_restart_enable_ext: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable, + pub cmd_set_tessellation_domain_origin_ext: crate::vk::PFN_vkCmdSetTessellationDomainOriginEXT, + pub cmd_set_depth_clamp_enable_ext: crate::vk::PFN_vkCmdSetDepthClampEnableEXT, + pub cmd_set_polygon_mode_ext: crate::vk::PFN_vkCmdSetPolygonModeEXT, + pub cmd_set_rasterization_samples_ext: crate::vk::PFN_vkCmdSetRasterizationSamplesEXT, + pub cmd_set_sample_mask_ext: crate::vk::PFN_vkCmdSetSampleMaskEXT, + pub cmd_set_alpha_to_coverage_enable_ext: crate::vk::PFN_vkCmdSetAlphaToCoverageEnableEXT, + pub cmd_set_alpha_to_one_enable_ext: crate::vk::PFN_vkCmdSetAlphaToOneEnableEXT, + pub cmd_set_logic_op_enable_ext: crate::vk::PFN_vkCmdSetLogicOpEnableEXT, + pub cmd_set_color_blend_enable_ext: crate::vk::PFN_vkCmdSetColorBlendEnableEXT, + pub cmd_set_color_blend_equation_ext: crate::vk::PFN_vkCmdSetColorBlendEquationEXT, + pub cmd_set_color_write_mask_ext: crate::vk::PFN_vkCmdSetColorWriteMaskEXT, + pub cmd_set_rasterization_stream_ext: crate::vk::PFN_vkCmdSetRasterizationStreamEXT, + pub cmd_set_conservative_rasterization_mode_ext: + crate::vk::PFN_vkCmdSetConservativeRasterizationModeEXT, + pub cmd_set_extra_primitive_overestimation_size_ext: + crate::vk::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT, + pub cmd_set_depth_clip_enable_ext: crate::vk::PFN_vkCmdSetDepthClipEnableEXT, + pub cmd_set_sample_locations_enable_ext: crate::vk::PFN_vkCmdSetSampleLocationsEnableEXT, + pub cmd_set_color_blend_advanced_ext: crate::vk::PFN_vkCmdSetColorBlendAdvancedEXT, + pub cmd_set_provoking_vertex_mode_ext: crate::vk::PFN_vkCmdSetProvokingVertexModeEXT, + pub cmd_set_line_rasterization_mode_ext: crate::vk::PFN_vkCmdSetLineRasterizationModeEXT, + pub cmd_set_line_stipple_enable_ext: crate::vk::PFN_vkCmdSetLineStippleEnableEXT, + pub cmd_set_depth_clip_negative_one_to_one_ext: + crate::vk::PFN_vkCmdSetDepthClipNegativeOneToOneEXT, + pub cmd_set_viewport_w_scaling_enable_nv: crate::vk::PFN_vkCmdSetViewportWScalingEnableNV, + pub cmd_set_viewport_swizzle_nv: crate::vk::PFN_vkCmdSetViewportSwizzleNV, + pub cmd_set_coverage_to_color_enable_nv: crate::vk::PFN_vkCmdSetCoverageToColorEnableNV, + pub cmd_set_coverage_to_color_location_nv: crate::vk::PFN_vkCmdSetCoverageToColorLocationNV, + pub cmd_set_coverage_modulation_mode_nv: crate::vk::PFN_vkCmdSetCoverageModulationModeNV, + pub cmd_set_coverage_modulation_table_enable_nv: + crate::vk::PFN_vkCmdSetCoverageModulationTableEnableNV, + pub cmd_set_coverage_modulation_table_nv: crate::vk::PFN_vkCmdSetCoverageModulationTableNV, + pub cmd_set_shading_rate_image_enable_nv: crate::vk::PFN_vkCmdSetShadingRateImageEnableNV, + pub cmd_set_representative_fragment_test_enable_nv: + crate::vk::PFN_vkCmdSetRepresentativeFragmentTestEnableNV, + pub cmd_set_coverage_reduction_mode_nv: crate::vk::PFN_vkCmdSetCoverageReductionModeNV, +} +unsafe impl Send for ExtShaderObjectFn {} +unsafe impl Sync for ExtShaderObjectFn {} +impl ExtShaderObjectFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + create_shaders_ext: unsafe { + unsafe extern "system" fn create_shaders_ext( + _device: Device, + _create_info_count: u32, + _p_create_infos: *const ShaderCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_shaders: *mut ShaderEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_shaders_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShadersEXT\0"); + let val = _f(cname); + if val.is_null() { + create_shaders_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_shader_ext: unsafe { + unsafe extern "system" fn destroy_shader_ext( + _device: Device, + _shader: ShaderEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_shader_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderEXT\0"); + let val = _f(cname); + if val.is_null() { + destroy_shader_ext + } else { + ::std::mem::transmute(val) + } + }, + get_shader_binary_data_ext: unsafe { + unsafe extern "system" fn get_shader_binary_data_ext( + _device: Device, + _shader: ShaderEXT, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_shader_binary_data_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetShaderBinaryDataEXT\0"); + let val = _f(cname); + if val.is_null() { + get_shader_binary_data_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_shaders_ext: unsafe { + unsafe extern "system" fn cmd_bind_shaders_ext( + _command_buffer: CommandBuffer, + _stage_count: u32, + _p_stages: *const ShaderStageFlags, + _p_shaders: *const ShaderEXT, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_bind_shaders_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindShadersEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_shaders_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_cull_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_cull_mode_ext( + _command_buffer: CommandBuffer, + _cull_mode: CullModeFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_cull_mode_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_cull_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_front_face_ext: unsafe { + unsafe extern "system" fn cmd_set_front_face_ext( + _command_buffer: CommandBuffer, + _front_face: FrontFace, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_front_face_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_front_face_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_topology_ext: unsafe { + unsafe extern "system" fn cmd_set_primitive_topology_ext( + _command_buffer: CommandBuffer, + _primitive_topology: PrimitiveTopology, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_topology_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveTopologyEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_topology_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_with_count_ext: unsafe { + unsafe extern "system" fn cmd_set_viewport_with_count_ext( + _command_buffer: CommandBuffer, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_with_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWithCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_with_count_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_scissor_with_count_ext: unsafe { + unsafe extern "system" fn cmd_set_scissor_with_count_ext( + _command_buffer: CommandBuffer, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_scissor_with_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetScissorWithCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_scissor_with_count_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_vertex_buffers2_ext: unsafe { + unsafe extern "system" fn cmd_bind_vertex_buffers2_ext( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + _p_sizes: *const DeviceSize, + _p_strides: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindVertexBuffers2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_vertex_buffers2_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_write_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_write_enable_ext( + _command_buffer: CommandBuffer, + _depth_write_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_write_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthWriteEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_write_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_compare_op_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_compare_op_ext( + _command_buffer: CommandBuffer, + _depth_compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_compare_op_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_compare_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_bounds_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bounds_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBoundsTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bounds_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_stencil_test_enable_ext( + _command_buffer: CommandBuffer, + _stencil_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetStencilTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_op_ext: unsafe { + unsafe extern "system" fn cmd_set_stencil_op_ext( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _fail_op: StencilOp, + _pass_op: StencilOp, + _depth_fail_op: StencilOp, + _compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_op_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_vertex_input_ext: unsafe { + unsafe extern "system" fn cmd_set_vertex_input_ext( + _command_buffer: CommandBuffer, + _vertex_binding_description_count: u32, + _p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT, + _vertex_attribute_description_count: u32, + _p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_vertex_input_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_vertex_input_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_patch_control_points_ext: unsafe { + unsafe extern "system" fn cmd_set_patch_control_points_ext( + _command_buffer: CommandBuffer, + _patch_control_points: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_patch_control_points_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPatchControlPointsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_patch_control_points_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterizer_discard_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext( + _command_buffer: CommandBuffer, + _rasterizer_discard_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterizer_discard_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizerDiscardEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterizer_discard_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bias_enable_ext( + _command_buffer: CommandBuffer, + _depth_bias_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bias_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBiasEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_ext( + _command_buffer: CommandBuffer, + _logic_op: LogicOp, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_restart_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_primitive_restart_enable_ext( + _command_buffer: CommandBuffer, + _primitive_restart_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_restart_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveRestartEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_restart_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_tessellation_domain_origin_ext: unsafe { + unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext( + _command_buffer: CommandBuffer, + _domain_origin: TessellationDomainOrigin, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_tessellation_domain_origin_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetTessellationDomainOriginEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_tessellation_domain_origin_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clamp_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clamp_enable_ext( + _command_buffer: CommandBuffer, + _depth_clamp_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clamp_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClampEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clamp_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_polygon_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_polygon_mode_ext( + _command_buffer: CommandBuffer, + _polygon_mode: PolygonMode, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_polygon_mode_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_polygon_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_samples_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_samples_ext( + _command_buffer: CommandBuffer, + _rasterization_samples: SampleCountFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_samples_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationSamplesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_samples_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_mask_ext( + _command_buffer: CommandBuffer, + _samples: SampleCountFlags, + _p_sample_mask: *const SampleMask, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_coverage_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_coverage_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_coverage_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToCoverageEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_coverage_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_one_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_one_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_one_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToOneEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_one_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_enable_ext( + _command_buffer: CommandBuffer, + _logic_op_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_logic_op_enable_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_enable_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_enables: *const Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_equation_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_equation_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_equations: *const ColorBlendEquationEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_equation_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEquationEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_equation_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_write_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_color_write_mask_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_write_masks: *const ColorComponentFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_write_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_color_write_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_stream_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_stream_ext( + _command_buffer: CommandBuffer, + _rasterization_stream: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_stream_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationStreamEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_stream_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_conservative_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _conservative_rasterization_mode: ConservativeRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_conservative_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetConservativeRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_conservative_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_extra_primitive_overestimation_size_ext: unsafe { + unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext( + _command_buffer: CommandBuffer, + _extra_primitive_overestimation_size: f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_extra_primitive_overestimation_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_extra_primitive_overestimation_size_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_enable_ext( + _command_buffer: CommandBuffer, + _depth_clip_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_locations_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_locations_enable_ext( + _command_buffer: CommandBuffer, + _sample_locations_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_locations_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetSampleLocationsEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_locations_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_advanced_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_advanced_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_advanced: *const ColorBlendAdvancedEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_advanced_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendAdvancedEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_advanced_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_provoking_vertex_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext( + _command_buffer: CommandBuffer, + _provoking_vertex_mode: ProvokingVertexModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_provoking_vertex_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetProvokingVertexModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_provoking_vertex_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_line_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _line_rasterization_mode: LineRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_stipple_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_line_stipple_enable_ext( + _command_buffer: CommandBuffer, + _stippled_line_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_stipple_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineStippleEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_stipple_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_negative_one_to_one_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext( + _command_buffer: CommandBuffer, + _negative_one_to_one: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_negative_one_to_one_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipNegativeOneToOneEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_negative_one_to_one_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_w_scaling_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv( + _command_buffer: CommandBuffer, + _viewport_w_scaling_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_w_scaling_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWScalingEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_w_scaling_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_swizzle_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_swizzle_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_swizzles: *const ViewportSwizzleNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_swizzle_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_swizzle_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_location_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_location_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_location: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_location_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorLocationNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_location_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_mode: CoverageModulationModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_count: u32, + _p_coverage_modulation_table: *const f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_shading_rate_image_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv( + _command_buffer: CommandBuffer, + _shading_rate_image_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_shading_rate_image_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetShadingRateImageEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_shading_rate_image_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_representative_fragment_test_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv( + _command_buffer: CommandBuffer, + _representative_fragment_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_representative_fragment_test_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRepresentativeFragmentTestEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_representative_fragment_test_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_reduction_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv( + _command_buffer: CommandBuffer, + _coverage_reduction_mode: CoverageReductionModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_reduction_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageReductionModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_reduction_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + } } } -#[doc = "Generated from 'VK_EXT_extension_483'"] -impl ShaderStageFlags { - pub const EXT_483_RESERVE_15: Self = Self(0b1000_0000_0000_0000); - pub const EXT_483_RESERVE_16: Self = Self(0b1_0000_0000_0000_0000); - pub const EXT_483_RESERVE_17: Self = Self(0b10_0000_0000_0000_0000); +#[doc = "Generated from 'VK_EXT_shader_object'"] +impl ObjectType { + pub const SHADER_EXT: Self = Self(1_000_482_000); +} +#[doc = "Generated from 'VK_EXT_shader_object'"] +impl Result { + pub const ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: Self = Self(1_000_482_000); +} +#[doc = "Generated from 'VK_EXT_shader_object'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: Self = Self(1_000_482_000); + pub const PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: Self = Self(1_000_482_001); + pub const SHADER_CREATE_INFO_EXT: Self = Self(1_000_482_002); + pub const SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self = + Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; } impl ExtExtension484Fn { #[inline] @@ -25465,6 +26665,21 @@ impl ExtExtension508Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_extension_508'"] +impl AccessFlags2 { + pub const RESERVED_47_EXT: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESERVED_48_EXT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_extension_508'"] +impl PipelineStageFlags2 { + pub const RESERVED_42_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_extension_508'"] +impl QueueFlags { + pub const RESERVED_10_EXT: Self = Self(0b100_0000_0000); +} impl ExtExtension509Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -25746,3 +26961,22 @@ impl QcomExtension522Fn { Self {} } } +impl ExtExtension523Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_523\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension523Fn {} +unsafe impl Send for ExtExtension523Fn {} +unsafe impl Sync for ExtExtension523Fn {} +impl ExtExtension523Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} diff --git a/ash/src/vk/native.rs b/ash/src/vk/native.rs index 1a6b58d..03e0ad5 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -1,4 +1,4 @@ -/* automatically generated by rust-bindgen 0.63.0 */ +/* automatically generated by rust-bindgen 0.64.0 */ #[repr(C)] #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] diff --git a/generator/Cargo.toml b/generator/Cargo.toml index ec45261..8df2ba1 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -5,7 +5,7 @@ authors = ["Maik Klein "] edition = "2021" [dependencies] -bindgen = "0.63" +bindgen = "0.64" heck = "0.4" itertools = "0.10" nom = "7.1" diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index fa204df..63af1cf 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit fa204df59c6caea6b9be3cf0754a88cd89056a87 +Subproject commit 63af1cf1ee906ba4dcd5a324bdd0201d4f4bfd12