From 010df1b1b356af1b512a40505c58ba9b756a2de1 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Sat, 29 Jul 2023 10:44:49 +0200 Subject: [PATCH] Update Vulkan-Headers to 1.3.260 (#763) * Update Vulkan-Headers to 1.3.255 * Update Vulkan-Headers to 1.3.257 * Update Vulkan-Headers to 1.3.258 * Update Vulkan-Headers to 1.3.259 * Update Vulkan-Headers to 1.3.260 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/vk/aliases.rs | 4 + ash/src/vk/bitflags.rs | 34 + ash/src/vk/const_debugs.rs | 288 ++++++- ash/src/vk/constants.rs | 1 + ash/src/vk/definitions.rs | 1559 +++++++++++++++++++++++++++++++++++- ash/src/vk/enums.rs | 94 +-- ash/src/vk/extensions.rs | 837 ++++++++++++++++++- generator/Vulkan-Headers | 2 +- 10 files changed, 2733 insertions(+), 90 deletions(-) diff --git a/Changelog.md b/Changelog.md index f7185f3d5..47e27a23e 100644 --- a/Changelog.md +++ b/Changelog.md @@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added `Handle::is_null()` to allow checking if a handle is a `NULL` value (#694) - Allow building `Entry`/`Instance`/`Device` from handle+fns (see their `from_parts_1_x()` associated functions) (#748) -- Update Vulkan-Headers to 1.3.254 (#760) +- Update Vulkan-Headers to 1.3.260 (#760, #763) - Added `VK_NV_memory_decompression` device extension (#761) - Added `VK_GOOGLE_display_timing` device extension (#765) - Added `VK_ANDROID_external_memory_android_hardware_buffer` device extension (#769) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 9fe28c69f..db8516987 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.254" +version = "0.37.0+1.3.260" authors = [ "Maik Klein ", "Benjamin Saunders ", diff --git a/ash/src/vk/aliases.rs b/ash/src/vk/aliases.rs index f3a6a17b9..b50eff6ca 100644 --- a/ash/src/vk/aliases.rs +++ b/ash/src/vk/aliases.rs @@ -38,6 +38,8 @@ pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR; pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR; pub type GeometryTypeNV = GeometryTypeKHR; pub type RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR; +pub type ScopeNV = ScopeKHR; +pub type ComponentTypeNV = ComponentTypeKHR; pub type TessellationDomainOriginKHR = TessellationDomainOrigin; pub type SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion; pub type SamplerYcbcrRangeKHR = SamplerYcbcrRange; @@ -269,3 +271,5 @@ pub type CommandBufferInheritanceRenderingInfoKHR<'a> = CommandBufferInheritance pub type AttachmentSampleCountInfoNV<'a> = AttachmentSampleCountInfoAMD<'a>; pub type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'a> = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a>; +pub type ImageSubresource2EXT<'a> = ImageSubresource2KHR<'a>; +pub type SubresourceLayout2EXT<'a> = SubresourceLayout2KHR<'a>; diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index f99830ec8..dec02d90d 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -137,6 +137,22 @@ impl BufferUsageFlags { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BufferUsageFlags2KHR(pub(crate) Flags64); +vk_bitflags_wrapped!(BufferUsageFlags2KHR, Flags64); +impl BufferUsageFlags2KHR { + pub const TRANSFER_SRC: Self = Self(0b1); + pub const TRANSFER_DST: Self = Self(0b10); + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b100); + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1000); + pub const UNIFORM_BUFFER: Self = Self(0b1_0000); + pub const STORAGE_BUFFER: Self = Self(0b10_0000); + pub const INDEX_BUFFER: Self = Self(0b100_0000); + pub const VERTEX_BUFFER: Self = Self(0b1000_0000); + pub const INDIRECT_BUFFER: Self = Self(0b1_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct BufferCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(BufferCreateFlags, Flags); @@ -227,6 +243,16 @@ impl PipelineCreateFlags { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCreateFlags2KHR(pub(crate) Flags64); +vk_bitflags_wrapped!(PipelineCreateFlags2KHR, Flags64); +impl PipelineCreateFlags2KHR { + pub const DISABLE_OPTIMIZATION: Self = Self(0b1); + pub const ALLOW_DERIVATIVES: Self = Self(0b10); + pub const DERIVATIVE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct PipelineShaderStageCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, Flags); @@ -1354,6 +1380,14 @@ impl VideoEncodeH264RateControlFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct HostImageCopyFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(HostImageCopyFlagsEXT, Flags); +impl HostImageCopyFlagsEXT { + pub const MEMCPY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags); vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 4bbc5bd42..4923a8a53 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -561,6 +561,10 @@ impl fmt::Debug for BufferUsageFlags { BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, "CONDITIONAL_RENDERING_EXT", ), + ( + BufferUsageFlags::EXECUTION_GRAPH_SCRATCH_AMDX.0, + "EXECUTION_GRAPH_SCRATCH_AMDX", + ), ( BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0, "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR", @@ -609,6 +613,81 @@ impl fmt::Debug for BufferUsageFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for BufferUsageFlags2KHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[ + (BufferUsageFlags2KHR::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags2KHR::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags2KHR::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags2KHR::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags2KHR::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags2KHR::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags2KHR::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags2KHR::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags2KHR::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ( + BufferUsageFlags2KHR::EXECUTION_GRAPH_SCRATCH_AMDX.0, + "EXECUTION_GRAPH_SCRATCH_AMDX", + ), + ( + BufferUsageFlags2KHR::CONDITIONAL_RENDERING.0, + "CONDITIONAL_RENDERING", + ), + ( + BufferUsageFlags2KHR::SHADER_BINDING_TABLE.0, + "SHADER_BINDING_TABLE", + ), + ( + BufferUsageFlags2KHR::TRANSFORM_FEEDBACK_BUFFER.0, + "TRANSFORM_FEEDBACK_BUFFER", + ), + ( + BufferUsageFlags2KHR::TRANSFORM_FEEDBACK_COUNTER_BUFFER.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER", + ), + (BufferUsageFlags2KHR::VIDEO_DECODE_SRC.0, "VIDEO_DECODE_SRC"), + (BufferUsageFlags2KHR::VIDEO_DECODE_DST.0, "VIDEO_DECODE_DST"), + (BufferUsageFlags2KHR::VIDEO_ENCODE_DST.0, "VIDEO_ENCODE_DST"), + (BufferUsageFlags2KHR::VIDEO_ENCODE_SRC.0, "VIDEO_ENCODE_SRC"), + ( + BufferUsageFlags2KHR::SHADER_DEVICE_ADDRESS.0, + "SHADER_DEVICE_ADDRESS", + ), + ( + BufferUsageFlags2KHR::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY.0, + "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY", + ), + ( + BufferUsageFlags2KHR::ACCELERATION_STRUCTURE_STORAGE.0, + "ACCELERATION_STRUCTURE_STORAGE", + ), + ( + BufferUsageFlags2KHR::SAMPLER_DESCRIPTOR_BUFFER.0, + "SAMPLER_DESCRIPTOR_BUFFER", + ), + ( + BufferUsageFlags2KHR::RESOURCE_DESCRIPTOR_BUFFER.0, + "RESOURCE_DESCRIPTOR_BUFFER", + ), + ( + BufferUsageFlags2KHR::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0, + "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER", + ), + ( + BufferUsageFlags2KHR::MICROMAP_BUILD_INPUT_READ_ONLY.0, + "MICROMAP_BUILD_INPUT_READ_ONLY", + ), + (BufferUsageFlags2KHR::MICROMAP_STORAGE.0, "MICROMAP_STORAGE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for BufferViewCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[]; @@ -887,7 +966,7 @@ impl fmt::Debug for ComponentSwizzle { } } } -impl fmt::Debug for ComponentTypeNV { +impl fmt::Debug for ComponentTypeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::FLOAT16 => Some("FLOAT16"), @@ -1203,6 +1282,10 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags { DescriptorSetLayoutCreateFlags::EMBEDDED_IMMUTABLE_SAMPLERS_EXT.0, "EMBEDDED_IMMUTABLE_SAMPLERS_EXT", ), + ( + DescriptorSetLayoutCreateFlags::INDIRECT_BINDABLE_NV.0, + "INDIRECT_BINDABLE_NV", + ), ( DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_EXT.0, "HOST_ONLY_POOL_EXT", @@ -2067,6 +2150,8 @@ impl fmt::Debug for Format { Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), Self::R16G16_S10_5_NV => Some("R16G16_S10_5_NV"), + Self::A1B5G5R5_UNORM_PACK16_KHR => Some("A1B5G5R5_UNORM_PACK16_KHR"), + Self::A8_UNORM_KHR => Some("A8_UNORM_KHR"), Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), @@ -2170,7 +2255,7 @@ impl fmt::Debug for FormatFeatureFlags { } impl fmt::Debug for FormatFeatureFlags2 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV")] ; + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: HOST_IMAGE_TRANSFER_EXT . 0 , "HOST_IMAGE_TRANSFER_EXT") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV")] ; debug_flags(f, KNOWN, self.0) } } @@ -2349,6 +2434,12 @@ impl fmt::Debug for HeadlessSurfaceCreateFlagsEXT { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for HostImageCopyFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(HostImageCopyFlagsEXT::MEMCPY.0, "MEMCPY")]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for IOSSurfaceCreateFlagsMVK { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[]; @@ -2672,6 +2763,7 @@ impl fmt::Debug for ImageUsageFlags { ImageUsageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", ), + (ImageUsageFlags::HOST_TRANSFER_EXT.0, "HOST_TRANSFER_EXT"), ( ImageUsageFlags::VIDEO_ENCODE_DST_KHR.0, "VIDEO_ENCODE_DST_KHR", @@ -2786,6 +2878,8 @@ impl fmt::Debug for IndirectCommandsTokenTypeNV { Self::DRAW => Some("DRAW"), Self::DRAW_TASKS => Some("DRAW_TASKS"), Self::DRAW_MESH_TASKS => Some("DRAW_MESH_TASKS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DISPATCH => Some("DISPATCH"), _ => None, }; if let Some(x) = name { @@ -3275,6 +3369,7 @@ impl fmt::Debug for PipelineBindPoint { let name = match *self { Self::GRAPHICS => Some("GRAPHICS"), Self::COMPUTE => Some("COMPUTE"), + Self::EXECUTION_GRAPH_AMDX => Some("EXECUTION_GRAPH_AMDX"), Self::RAY_TRACING_KHR => Some("RAY_TRACING_KHR"), Self::SUBPASS_SHADING_HUAWEI => Some("SUBPASS_SHADING_HUAWEI"), _ => None, @@ -3460,6 +3555,122 @@ impl fmt::Debug for PipelineCreateFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for PipelineCreateFlags2KHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[ + ( + PipelineCreateFlags2KHR::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags2KHR::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags2KHR::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags2KHR::RESERVED_28_NV.0, "RESERVED_28_NV"), + ( + PipelineCreateFlags2KHR::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags2KHR::DISPATCH_BASE.0, "DISPATCH_BASE"), + (PipelineCreateFlags2KHR::DEFER_COMPILE.0, "DEFER_COMPILE"), + ( + PipelineCreateFlags2KHR::CAPTURE_STATISTICS.0, + "CAPTURE_STATISTICS", + ), + ( + PipelineCreateFlags2KHR::CAPTURE_INTERNAL_REPRESENTATIONS.0, + "CAPTURE_INTERNAL_REPRESENTATIONS", + ), + ( + PipelineCreateFlags2KHR::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0, + "FAIL_ON_PIPELINE_COMPILE_REQUIRED", + ), + ( + PipelineCreateFlags2KHR::EARLY_RETURN_ON_FAILURE.0, + "EARLY_RETURN_ON_FAILURE", + ), + ( + PipelineCreateFlags2KHR::LINK_TIME_OPTIMIZATION.0, + "LINK_TIME_OPTIMIZATION", + ), + ( + PipelineCreateFlags2KHR::RETAIN_LINK_TIME_OPTIMIZATION_INFO.0, + "RETAIN_LINK_TIME_OPTIMIZATION_INFO", + ), + (PipelineCreateFlags2KHR::LIBRARY.0, "LIBRARY"), + ( + PipelineCreateFlags2KHR::RAY_TRACING_SKIP_TRIANGLES.0, + "RAY_TRACING_SKIP_TRIANGLES", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_SKIP_AABBS.0, + "RAY_TRACING_SKIP_AABBS", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS.0, + "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS.0, + "RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_NO_NULL_MISS_SHADERS.0, + "RAY_TRACING_NO_NULL_MISS_SHADERS", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS.0, + "RAY_TRACING_NO_NULL_INTERSECTION_SHADERS", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY.0, + "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY", + ), + ( + PipelineCreateFlags2KHR::INDIRECT_BINDABLE.0, + "INDIRECT_BINDABLE", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_ALLOW_MOTION.0, + "RAY_TRACING_ALLOW_MOTION", + ), + ( + PipelineCreateFlags2KHR::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0, + "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT", + ), + ( + PipelineCreateFlags2KHR::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0, + "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT", + ), + ( + PipelineCreateFlags2KHR::RAY_TRACING_OPACITY_MICROMAP.0, + "RAY_TRACING_OPACITY_MICROMAP", + ), + ( + PipelineCreateFlags2KHR::COLOR_ATTACHMENT_FEEDBACK_LOOP.0, + "COLOR_ATTACHMENT_FEEDBACK_LOOP", + ), + ( + PipelineCreateFlags2KHR::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0, + "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP", + ), + ( + PipelineCreateFlags2KHR::NO_PROTECTED_ACCESS.0, + "NO_PROTECTED_ACCESS", + ), + ( + PipelineCreateFlags2KHR::PROTECTED_ACCESS_ONLY.0, + "PROTECTED_ACCESS_ONLY", + ), + ( + PipelineCreateFlags2KHR::DESCRIPTOR_BUFFER.0, + "DESCRIPTOR_BUFFER", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for PipelineCreationFeedbackFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -3754,8 +3965,8 @@ impl fmt::Debug for PipelineStageFlags2 { (PipelineStageFlags2::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"), (PipelineStageFlags2::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"), ( - PipelineStageFlags2::SUBPASS_SHADING_HUAWEI.0, - "SUBPASS_SHADING_HUAWEI", + PipelineStageFlags2::SUBPASS_SHADER_HUAWEI.0, + "SUBPASS_SHADER_HUAWEI", ), ( PipelineStageFlags2::INVOCATION_MASK_HUAWEI.0, @@ -4293,7 +4504,7 @@ impl fmt::Debug for SamplerYcbcrRange { } } } -impl fmt::Debug for ScopeNV { +impl fmt::Debug for ScopeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::DEVICE => Some("DEVICE"), @@ -4998,6 +5209,21 @@ impl fmt::Debug for StructureType { Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => { Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID") } + Self::PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX => { + Some("PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX") + } + Self::PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX => { + Some("PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX") + } + Self::EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX => { + Some("EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX") + } + Self::EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX => { + Some("EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX") + } + Self::PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX => { + Some("PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX") + } Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"), Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => { Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT") @@ -5396,6 +5622,24 @@ impl fmt::Debug for StructureType { Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => { Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR") } + Self::PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT") + } + Self::MEMORY_TO_IMAGE_COPY_EXT => Some("MEMORY_TO_IMAGE_COPY_EXT"), + Self::IMAGE_TO_MEMORY_COPY_EXT => Some("IMAGE_TO_MEMORY_COPY_EXT"), + Self::COPY_IMAGE_TO_MEMORY_INFO_EXT => Some("COPY_IMAGE_TO_MEMORY_INFO_EXT"), + Self::COPY_MEMORY_TO_IMAGE_INFO_EXT => Some("COPY_MEMORY_TO_IMAGE_INFO_EXT"), + Self::HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT => { + Some("HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT") + } + Self::COPY_IMAGE_TO_IMAGE_INFO_EXT => Some("COPY_IMAGE_TO_IMAGE_INFO_EXT"), + Self::SUBRESOURCE_HOST_MEMCPY_SIZE_EXT => Some("SUBRESOURCE_HOST_MEMCPY_SIZE_EXT"), + Self::HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT => { + Some("HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT") + } Self::MEMORY_MAP_INFO_KHR => Some("MEMORY_MAP_INFO_KHR"), Self::MEMORY_UNMAP_INFO_KHR => Some("MEMORY_UNMAP_INFO_KHR"), Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => { @@ -5645,8 +5889,6 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT") } Self::IMAGE_COMPRESSION_CONTROL_EXT => Some("IMAGE_COMPRESSION_CONTROL_EXT"), - Self::SUBRESOURCE_LAYOUT_2_EXT => Some("SUBRESOURCE_LAYOUT_2_EXT"), - Self::IMAGE_SUBRESOURCE_2_EXT => Some("IMAGE_SUBRESOURCE_2_EXT"), Self::IMAGE_COMPRESSION_PROPERTIES_EXT => Some("IMAGE_COMPRESSION_PROPERTIES_EXT"), Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT => { Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT") @@ -5872,6 +6114,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV => { Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV") } + Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV") + } + Self::COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV => { + Some("COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV") + } + Self::PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV => { + Some("PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV") + } Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => { Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV") } @@ -5944,6 +6195,22 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR") + } + Self::RENDERING_AREA_INFO_KHR => Some("RENDERING_AREA_INFO_KHR"), + Self::DEVICE_IMAGE_SUBRESOURCE_INFO_KHR => Some("DEVICE_IMAGE_SUBRESOURCE_INFO_KHR"), + Self::SUBRESOURCE_LAYOUT_2_KHR => Some("SUBRESOURCE_LAYOUT_2_KHR"), + Self::IMAGE_SUBRESOURCE_2_KHR => Some("IMAGE_SUBRESOURCE_2_KHR"), + Self::PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR => { + Some("PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR") + } + Self::BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR => { + Some("BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR") + } Self::PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR => { Some("PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR") } @@ -5989,6 +6256,13 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR") + } + Self::COOPERATIVE_MATRIX_PROPERTIES_KHR => Some("COOPERATIVE_MATRIX_PROPERTIES_KHR"), + Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR") + } Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM => { Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM") } diff --git a/ash/src/vk/constants.rs b/ash/src/vk/constants.rs index 384e28a20..01b9cdefb 100644 --- a/ash/src/vk/constants.rs +++ b/ash/src/vk/constants.rs @@ -25,4 +25,5 @@ pub const MAX_DRIVER_INFO_SIZE: usize = 256; pub const SHADER_UNUSED_KHR: u32 = !0; pub const MAX_GLOBAL_PRIORITY_SIZE_KHR: usize = 16; pub const MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: usize = 32; +pub const SHADER_INDEX_UNUSED_AMDX: u32 = !0; pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR; diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 3c70a9f21..c5ab81ebd 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -58,7 +58,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 = 254; +pub const HEADER_VERSION: u32 = 260; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -1945,6 +1945,41 @@ impl<'a> CopyDescriptorSet<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferUsageFlags2CreateInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: BufferUsageFlags2KHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferUsageFlags2CreateInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: BufferUsageFlags2KHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferUsageFlags2CreateInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; +} +unsafe impl ExtendsBufferViewCreateInfo for BufferUsageFlags2CreateInfoKHR<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferUsageFlags2CreateInfoKHR<'_> {} +unsafe impl ExtendsPhysicalDeviceExternalBufferInfo for BufferUsageFlags2CreateInfoKHR<'_> {} +unsafe impl ExtendsDescriptorBufferBindingInfoEXT for BufferUsageFlags2CreateInfoKHR<'_> {} +impl<'a> BufferUsageFlags2CreateInfoKHR<'a> { + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags2KHR) -> Self { + self.usage = usage; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct BufferCreateInfo<'a> { pub s_type: StructureType, @@ -3708,6 +3743,89 @@ impl<'a> ComputePipelineCreateInfo<'a> { } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ComputePipelineIndirectBufferInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_address: DeviceAddress, + pub size: DeviceSize, + pub pipeline_device_address_capture_replay: DeviceAddress, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ComputePipelineIndirectBufferInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_address: DeviceAddress::default(), + size: DeviceSize::default(), + pipeline_device_address_capture_replay: DeviceAddress::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ComputePipelineIndirectBufferInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; +} +impl<'a> ComputePipelineIndirectBufferInfoNV<'a> { + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.device_address = device_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; + self + } + #[inline] + pub fn pipeline_device_address_capture_replay( + mut self, + pipeline_device_address_capture_replay: DeviceAddress, + ) -> Self { + self.pipeline_device_address_capture_replay = pipeline_device_address_capture_replay; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCreateFlags2CreateInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags2KHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PipelineCreateFlags2CreateInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags2KHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PipelineCreateFlags2CreateInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; +} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreateFlags2CreateInfoKHR<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreateFlags2CreateInfoKHR<'_> {} +unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreateFlags2CreateInfoKHR<'_> {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreateFlags2CreateInfoKHR<'_> {} +impl<'a> PipelineCreateFlags2CreateInfoKHR<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags2KHR) -> Self { + self.flags = flags; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] #[doc = ""] pub struct VertexInputBindingDescription { @@ -9354,6 +9472,64 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_generated_compute: Bool32, + pub device_generated_compute_pipelines: Bool32, + pub device_generated_compute_capture_replay: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_generated_compute: Bool32::default(), + device_generated_compute_pipelines: Bool32::default(), + device_generated_compute_capture_replay: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> {} +impl<'a> PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> { + #[inline] + pub fn device_generated_compute(mut self, device_generated_compute: bool) -> Self { + self.device_generated_compute = device_generated_compute.into(); + self + } + #[inline] + pub fn device_generated_compute_pipelines( + mut self, + device_generated_compute_pipelines: bool, + ) -> Self { + self.device_generated_compute_pipelines = device_generated_compute_pipelines.into(); + self + } + #[inline] + pub fn device_generated_compute_capture_replay( + mut self, + device_generated_compute_capture_replay: bool, + ) -> Self { + self.device_generated_compute_capture_replay = + device_generated_compute_capture_replay.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct DevicePrivateDataCreateInfo<'a> { pub s_type: StructureType, @@ -10144,6 +10320,58 @@ impl<'a> GeneratedCommandsMemoryRequirementsInfoNV<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineIndirectDeviceAddressInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline: Pipeline, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PipelineIndirectDeviceAddressInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline: Pipeline::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PipelineIndirectDeviceAddressInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; +} +impl<'a> PipelineIndirectDeviceAddressInfoNV<'a> { + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.pipeline = pipeline; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BindPipelineIndirectCommandNV { + pub pipeline_address: DeviceAddress, +} +impl BindPipelineIndirectCommandNV { + #[inline] + pub fn pipeline_address(mut self, pipeline_address: DeviceAddress) -> Self { + self.pipeline_address = pipeline_address; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceFeatures2<'a> { pub s_type: StructureType, @@ -10983,6 +11211,7 @@ impl ::std::default::Default for PhysicalDeviceExternalBufferInfo<'_> { unsafe impl<'a> TaggedStructure for PhysicalDeviceExternalBufferInfo<'a> { const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; } +pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo {} impl<'a> PhysicalDeviceExternalBufferInfo<'a> { #[inline] pub fn flags(mut self, flags: BufferCreateFlags) -> Self { @@ -10999,6 +11228,23 @@ impl<'a> PhysicalDeviceExternalBufferInfo<'a> { self.handle_type = handle_type; 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))] @@ -17142,6 +17388,181 @@ impl<'a> PhysicalDeviceMaintenance4Properties<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance5FeaturesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub maintenance5: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceMaintenance5FeaturesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + maintenance5: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceMaintenance5FeaturesKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance5FeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance5FeaturesKHR<'_> {} +impl<'a> PhysicalDeviceMaintenance5FeaturesKHR<'a> { + #[inline] + pub fn maintenance5(mut self, maintenance5: bool) -> Self { + self.maintenance5 = maintenance5.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance5PropertiesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub early_fragment_multisample_coverage_after_sample_counting: Bool32, + pub early_fragment_sample_mask_test_before_sample_counting: Bool32, + pub depth_stencil_swizzle_one_support: Bool32, + pub polygon_mode_point_size: Bool32, + pub non_strict_single_pixel_wide_lines_use_parallelogram: Bool32, + pub non_strict_wide_lines_use_parallelogram: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceMaintenance5PropertiesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + early_fragment_multisample_coverage_after_sample_counting: Bool32::default(), + early_fragment_sample_mask_test_before_sample_counting: Bool32::default(), + depth_stencil_swizzle_one_support: Bool32::default(), + polygon_mode_point_size: Bool32::default(), + non_strict_single_pixel_wide_lines_use_parallelogram: Bool32::default(), + non_strict_wide_lines_use_parallelogram: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceMaintenance5PropertiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance5PropertiesKHR<'_> {} +impl<'a> PhysicalDeviceMaintenance5PropertiesKHR<'a> { + #[inline] + pub fn early_fragment_multisample_coverage_after_sample_counting( + mut self, + early_fragment_multisample_coverage_after_sample_counting: bool, + ) -> Self { + self.early_fragment_multisample_coverage_after_sample_counting = + early_fragment_multisample_coverage_after_sample_counting.into(); + self + } + #[inline] + pub fn early_fragment_sample_mask_test_before_sample_counting( + mut self, + early_fragment_sample_mask_test_before_sample_counting: bool, + ) -> Self { + self.early_fragment_sample_mask_test_before_sample_counting = + early_fragment_sample_mask_test_before_sample_counting.into(); + self + } + #[inline] + pub fn depth_stencil_swizzle_one_support( + mut self, + depth_stencil_swizzle_one_support: bool, + ) -> Self { + self.depth_stencil_swizzle_one_support = depth_stencil_swizzle_one_support.into(); + self + } + #[inline] + pub fn polygon_mode_point_size(mut self, polygon_mode_point_size: bool) -> Self { + self.polygon_mode_point_size = polygon_mode_point_size.into(); + self + } + #[inline] + pub fn non_strict_single_pixel_wide_lines_use_parallelogram( + mut self, + non_strict_single_pixel_wide_lines_use_parallelogram: bool, + ) -> Self { + self.non_strict_single_pixel_wide_lines_use_parallelogram = + non_strict_single_pixel_wide_lines_use_parallelogram.into(); + self + } + #[inline] + pub fn non_strict_wide_lines_use_parallelogram( + mut self, + non_strict_wide_lines_use_parallelogram: bool, + ) -> Self { + self.non_strict_wide_lines_use_parallelogram = + non_strict_wide_lines_use_parallelogram.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingAreaInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for RenderingAreaInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for RenderingAreaInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_AREA_INFO_KHR; +} +impl<'a> RenderingAreaInfoKHR<'a> { + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.color_attachment_count = color_attachment_formats.len() as _; + self.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + #[inline] + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.depth_attachment_format = depth_attachment_format; + self + } + #[inline] + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.stencil_attachment_format = stencil_attachment_format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct DescriptorSetLayoutSupport<'a> { pub s_type: StructureType, @@ -26253,6 +26674,7 @@ unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreate unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo<'_> {} unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo<'_> {} unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo<'_> {} +unsafe impl ExtendsExecutionGraphPipelineCreateInfoAMDX for PipelineCreationFeedbackCreateInfo<'_> {} impl<'a> PipelineCreationFeedbackCreateInfo<'a> { #[inline] pub fn pipeline_creation_feedback( @@ -30701,6 +31123,10 @@ unsafe impl<'a> TaggedStructure for PipelineCompilerControlCreateInfoAMD<'a> { } unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD<'_> {} unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD<'_> {} +unsafe impl ExtendsExecutionGraphPipelineCreateInfoAMDX + for PipelineCompilerControlCreateInfoAMD<'_> +{ +} impl<'a> PipelineCompilerControlCreateInfoAMD<'a> { #[inline] pub fn compiler_control_flags( @@ -31067,6 +31493,19 @@ impl ::std::default::Default for DeviceOrHostAddressConstKHR { } #[repr(C)] #[derive(Copy, Clone)] +#[doc = ""] +pub union DeviceOrHostAddressConstAMDX { + pub device_address: DeviceAddress, + pub host_address: *const c_void, +} +impl ::std::default::Default for DeviceOrHostAddressConstAMDX { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] #[doc = ""] pub struct AccelerationStructureGeometryTrianglesDataKHR<'a> { pub s_type: StructureType, @@ -35741,6 +36180,541 @@ impl<'a> PhysicalDeviceSynchronization2Features<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceHostImageCopyFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub host_image_copy: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceHostImageCopyFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + host_image_copy: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceHostImageCopyFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostImageCopyFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostImageCopyFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceHostImageCopyFeaturesEXT<'a> { + #[inline] + pub fn host_image_copy(mut self, host_image_copy: bool) -> Self { + self.host_image_copy = host_image_copy.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceHostImageCopyPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub copy_src_layout_count: u32, + pub p_copy_src_layouts: *mut ImageLayout, + pub copy_dst_layout_count: u32, + pub p_copy_dst_layouts: *mut ImageLayout, + pub optimal_tiling_layout_uuid: [u8; UUID_SIZE], + pub identical_memory_type_requirements: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceHostImageCopyPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + copy_src_layout_count: u32::default(), + p_copy_src_layouts: ::std::ptr::null_mut(), + copy_dst_layout_count: u32::default(), + p_copy_dst_layouts: ::std::ptr::null_mut(), + optimal_tiling_layout_uuid: unsafe { ::std::mem::zeroed() }, + identical_memory_type_requirements: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceHostImageCopyPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceHostImageCopyPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceHostImageCopyPropertiesEXT<'a> { + #[inline] + pub fn copy_src_layouts(mut self, copy_src_layouts: &'a mut [ImageLayout]) -> Self { + self.copy_src_layout_count = copy_src_layouts.len() as _; + self.p_copy_src_layouts = copy_src_layouts.as_mut_ptr(); + self + } + #[inline] + pub fn copy_dst_layouts(mut self, copy_dst_layouts: &'a mut [ImageLayout]) -> Self { + self.copy_dst_layout_count = copy_dst_layouts.len() as _; + self.p_copy_dst_layouts = copy_dst_layouts.as_mut_ptr(); + self + } + #[inline] + pub fn optimal_tiling_layout_uuid( + mut self, + optimal_tiling_layout_uuid: [u8; UUID_SIZE], + ) -> Self { + self.optimal_tiling_layout_uuid = optimal_tiling_layout_uuid; + self + } + #[inline] + pub fn identical_memory_type_requirements( + mut self, + identical_memory_type_requirements: bool, + ) -> Self { + self.identical_memory_type_requirements = identical_memory_type_requirements.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryToImageCopyEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_host_pointer: *const c_void, + pub memory_row_length: u32, + pub memory_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for MemoryToImageCopyEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_host_pointer: ::std::ptr::null(), + memory_row_length: u32::default(), + memory_image_height: u32::default(), + image_subresource: ImageSubresourceLayers::default(), + image_offset: Offset3D::default(), + image_extent: Extent3D::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for MemoryToImageCopyEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_TO_IMAGE_COPY_EXT; +} +impl<'a> MemoryToImageCopyEXT<'a> { + #[inline] + pub fn host_pointer(mut self, host_pointer: *const c_void) -> Self { + self.p_host_pointer = host_pointer; + self + } + #[inline] + pub fn memory_row_length(mut self, memory_row_length: u32) -> Self { + self.memory_row_length = memory_row_length; + self + } + #[inline] + pub fn memory_image_height(mut self, memory_image_height: u32) -> Self { + self.memory_image_height = memory_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.image_extent = image_extent; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageToMemoryCopyEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_host_pointer: *mut c_void, + pub memory_row_length: u32, + pub memory_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageToMemoryCopyEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_host_pointer: ::std::ptr::null_mut(), + memory_row_length: u32::default(), + memory_image_height: u32::default(), + image_subresource: ImageSubresourceLayers::default(), + image_offset: Offset3D::default(), + image_extent: Extent3D::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageToMemoryCopyEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_TO_MEMORY_COPY_EXT; +} +impl<'a> ImageToMemoryCopyEXT<'a> { + #[inline] + pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self { + self.p_host_pointer = host_pointer; + self + } + #[inline] + pub fn memory_row_length(mut self, memory_row_length: u32) -> Self { + self.memory_row_length = memory_row_length; + self + } + #[inline] + pub fn memory_image_height(mut self, memory_image_height: u32) -> Self { + self.memory_image_height = memory_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.image_extent = image_extent; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMemoryToImageInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: HostImageCopyFlagsEXT, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const MemoryToImageCopyEXT<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CopyMemoryToImageInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: HostImageCopyFlagsEXT::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CopyMemoryToImageInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MEMORY_TO_IMAGE_INFO_EXT; +} +impl<'a> CopyMemoryToImageInfoEXT<'a> { + #[inline] + pub fn flags(mut self, flags: HostImageCopyFlagsEXT) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [MemoryToImageCopyEXT]) -> Self { + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyImageToMemoryInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: HostImageCopyFlagsEXT, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageToMemoryCopyEXT<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CopyImageToMemoryInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: HostImageCopyFlagsEXT::default(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CopyImageToMemoryInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_TO_MEMORY_INFO_EXT; +} +impl<'a> CopyImageToMemoryInfoEXT<'a> { + #[inline] + pub fn flags(mut self, flags: HostImageCopyFlagsEXT) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageToMemoryCopyEXT]) -> Self { + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyImageToImageInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: HostImageCopyFlagsEXT, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageCopy2<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CopyImageToImageInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: HostImageCopyFlagsEXT::default(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CopyImageToImageInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_TO_IMAGE_INFO_EXT; +} +impl<'a> CopyImageToImageInfoEXT<'a> { + #[inline] + pub fn flags(mut self, flags: HostImageCopyFlagsEXT) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self { + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct HostImageLayoutTransitionInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub old_layout: ImageLayout, + pub new_layout: ImageLayout, + pub subresource_range: ImageSubresourceRange, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for HostImageLayoutTransitionInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + old_layout: ImageLayout::default(), + new_layout: ImageLayout::default(), + subresource_range: ImageSubresourceRange::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for HostImageLayoutTransitionInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT; +} +impl<'a> HostImageLayoutTransitionInfoEXT<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.image = image; + self + } + #[inline] + pub fn old_layout(mut self, old_layout: ImageLayout) -> Self { + self.old_layout = old_layout; + self + } + #[inline] + pub fn new_layout(mut self, new_layout: ImageLayout) -> Self { + self.new_layout = new_layout; + self + } + #[inline] + pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { + self.subresource_range = subresource_range; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubresourceHostMemcpySizeEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub size: DeviceSize, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SubresourceHostMemcpySizeEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + size: DeviceSize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SubresourceHostMemcpySizeEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; +} +unsafe impl ExtendsSubresourceLayout2KHR for SubresourceHostMemcpySizeEXT<'_> {} +impl<'a> SubresourceHostMemcpySizeEXT<'a> { + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct HostImageCopyDevicePerformanceQueryEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub optimal_device_access: Bool32, + pub identical_memory_layout: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for HostImageCopyDevicePerformanceQueryEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + optimal_device_access: Bool32::default(), + identical_memory_layout: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for HostImageCopyDevicePerformanceQueryEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; +} +unsafe impl ExtendsImageFormatProperties2 for HostImageCopyDevicePerformanceQueryEXT<'_> {} +impl<'a> HostImageCopyDevicePerformanceQueryEXT<'a> { + #[inline] + pub fn optimal_device_access(mut self, optimal_device_access: bool) -> Self { + self.optimal_device_access = optimal_device_access.into(); + self + } + #[inline] + pub fn identical_memory_layout(mut self, identical_memory_layout: bool) -> Self { + self.identical_memory_layout = identical_memory_layout.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> { pub s_type: StructureType, @@ -43772,7 +44746,7 @@ impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { #[doc = ""] pub struct GraphicsPipelineLibraryCreateInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, + pub p_next: *const c_void, pub flags: GraphicsPipelineLibraryFlagsEXT, pub _marker: PhantomData<&'a ()>, } @@ -43781,7 +44755,7 @@ impl ::std::default::Default for GraphicsPipelineLibraryCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), + p_next: ::std::ptr::null(), flags: GraphicsPipelineLibraryFlagsEXT::default(), _marker: PhantomData, } @@ -44174,7 +45148,7 @@ unsafe impl<'a> TaggedStructure for ImageCompressionPropertiesEXT<'a> { } unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT<'_> {} unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT<'_> {} -unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT<'_> {} +unsafe impl ExtendsSubresourceLayout2KHR for ImageCompressionPropertiesEXT<'_> {} impl<'a> ImageCompressionPropertiesEXT<'a> { #[inline] pub fn image_compression_flags( @@ -44239,14 +45213,14 @@ impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImageSubresource2EXT<'a> { +#[doc = ""] +pub struct ImageSubresource2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub image_subresource: ImageSubresource, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageSubresource2EXT<'_> { +impl ::std::default::Default for ImageSubresource2KHR<'_> { #[inline] fn default() -> Self { Self { @@ -44257,10 +45231,10 @@ impl ::std::default::Default for ImageSubresource2EXT<'_> { } } } -unsafe impl<'a> TaggedStructure for ImageSubresource2EXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_EXT; +unsafe impl<'a> TaggedStructure for ImageSubresource2KHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_KHR; } -impl<'a> ImageSubresource2EXT<'a> { +impl<'a> ImageSubresource2KHR<'a> { #[inline] pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self { self.image_subresource = image_subresource; @@ -44270,14 +45244,14 @@ impl<'a> ImageSubresource2EXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct SubresourceLayout2EXT<'a> { +#[doc = ""] +pub struct SubresourceLayout2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub subresource_layout: SubresourceLayout, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubresourceLayout2EXT<'_> { +impl ::std::default::Default for SubresourceLayout2KHR<'_> { #[inline] fn default() -> Self { Self { @@ -44288,11 +45262,11 @@ impl ::std::default::Default for SubresourceLayout2EXT<'_> { } } } -unsafe impl<'a> TaggedStructure for SubresourceLayout2EXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_EXT; +unsafe impl<'a> TaggedStructure for SubresourceLayout2KHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_KHR; } -pub unsafe trait ExtendsSubresourceLayout2EXT {} -impl<'a> SubresourceLayout2EXT<'a> { +pub unsafe trait ExtendsSubresourceLayout2KHR {} +impl<'a> SubresourceLayout2KHR<'a> { #[inline] pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self { self.subresource_layout = subresource_layout; @@ -44303,7 +45277,7 @@ impl<'a> SubresourceLayout2EXT<'a> { #[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 { + 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(); @@ -48398,6 +49372,44 @@ impl<'a> PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceImageSubresourceInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_create_info: *const ImageCreateInfo<'a>, + pub p_subresource: *const ImageSubresource2KHR<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DeviceImageSubresourceInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_create_info: ::std::ptr::null(), + p_subresource: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DeviceImageSubresourceInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_IMAGE_SUBRESOURCE_INFO_KHR; +} +impl<'a> DeviceImageSubresourceInfoKHR<'a> { + #[inline] + pub fn create_info(mut self, create_info: &'a ImageCreateInfo<'a>) -> Self { + self.p_create_info = create_info; + self + } + #[inline] + pub fn subresource(mut self, subresource: &'a ImageSubresource2KHR<'a>) -> Self { + self.p_subresource = subresource; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceShaderCorePropertiesARM<'a> { pub s_type: StructureType, @@ -49189,3 +50201,514 @@ impl<'a> PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { self } } +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cooperative_matrix: Bool32, + pub cooperative_matrix_robust_buffer_access: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cooperative_matrix: Bool32::default(), + cooperative_matrix_robust_buffer_access: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> { + #[inline] + pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self { + self.cooperative_matrix = cooperative_matrix.into(); + self + } + #[inline] + pub fn cooperative_matrix_robust_buffer_access( + mut self, + cooperative_matrix_robust_buffer_access: bool, + ) -> Self { + self.cooperative_matrix_robust_buffer_access = + cooperative_matrix_robust_buffer_access.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CooperativeMatrixPropertiesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub m_size: u32, + pub n_size: u32, + pub k_size: u32, + pub a_type: ComponentTypeKHR, + pub b_type: ComponentTypeKHR, + pub c_type: ComponentTypeKHR, + pub result_type: ComponentTypeKHR, + pub saturating_accumulation: Bool32, + pub scope: ScopeKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CooperativeMatrixPropertiesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + m_size: u32::default(), + n_size: u32::default(), + k_size: u32::default(), + a_type: ComponentTypeKHR::default(), + b_type: ComponentTypeKHR::default(), + c_type: ComponentTypeKHR::default(), + result_type: ComponentTypeKHR::default(), + saturating_accumulation: Bool32::default(), + scope: ScopeKHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CooperativeMatrixPropertiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COOPERATIVE_MATRIX_PROPERTIES_KHR; +} +impl<'a> CooperativeMatrixPropertiesKHR<'a> { + #[inline] + pub fn m_size(mut self, m_size: u32) -> Self { + self.m_size = m_size; + self + } + #[inline] + pub fn n_size(mut self, n_size: u32) -> Self { + self.n_size = n_size; + self + } + #[inline] + pub fn k_size(mut self, k_size: u32) -> Self { + self.k_size = k_size; + self + } + #[inline] + pub fn a_type(mut self, a_type: ComponentTypeKHR) -> Self { + self.a_type = a_type; + self + } + #[inline] + pub fn b_type(mut self, b_type: ComponentTypeKHR) -> Self { + self.b_type = b_type; + self + } + #[inline] + pub fn c_type(mut self, c_type: ComponentTypeKHR) -> Self { + self.c_type = c_type; + self + } + #[inline] + pub fn result_type(mut self, result_type: ComponentTypeKHR) -> Self { + self.result_type = result_type; + self + } + #[inline] + pub fn saturating_accumulation(mut self, saturating_accumulation: bool) -> Self { + self.saturating_accumulation = saturating_accumulation.into(); + self + } + #[inline] + pub fn scope(mut self, scope: ScopeKHR) -> Self { + self.scope = scope; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cooperative_matrix_supported_stages: ShaderStageFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cooperative_matrix_supported_stages: ShaderStageFlags::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesKHR<'_> {} +impl<'a> PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> { + #[inline] + pub fn cooperative_matrix_supported_stages( + mut self, + cooperative_matrix_supported_stages: ShaderStageFlags, + ) -> Self { + self.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_execution_graph_depth: u32, + pub max_execution_graph_shader_output_nodes: u32, + pub max_execution_graph_shader_payload_size: u32, + pub max_execution_graph_shader_payload_count: u32, + pub execution_graph_dispatch_address_alignment: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceShaderEnqueuePropertiesAMDX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_execution_graph_depth: u32::default(), + max_execution_graph_shader_output_nodes: u32::default(), + max_execution_graph_shader_payload_size: u32::default(), + max_execution_graph_shader_payload_count: u32::default(), + execution_graph_dispatch_address_alignment: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderEnqueuePropertiesAMDX<'_> {} +impl<'a> PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> { + #[inline] + pub fn max_execution_graph_depth(mut self, max_execution_graph_depth: u32) -> Self { + self.max_execution_graph_depth = max_execution_graph_depth; + self + } + #[inline] + pub fn max_execution_graph_shader_output_nodes( + mut self, + max_execution_graph_shader_output_nodes: u32, + ) -> Self { + self.max_execution_graph_shader_output_nodes = max_execution_graph_shader_output_nodes; + self + } + #[inline] + pub fn max_execution_graph_shader_payload_size( + mut self, + max_execution_graph_shader_payload_size: u32, + ) -> Self { + self.max_execution_graph_shader_payload_size = max_execution_graph_shader_payload_size; + self + } + #[inline] + pub fn max_execution_graph_shader_payload_count( + mut self, + max_execution_graph_shader_payload_count: u32, + ) -> Self { + self.max_execution_graph_shader_payload_count = max_execution_graph_shader_payload_count; + self + } + #[inline] + pub fn execution_graph_dispatch_address_alignment( + mut self, + execution_graph_dispatch_address_alignment: u32, + ) -> Self { + self.execution_graph_dispatch_address_alignment = + execution_graph_dispatch_address_alignment; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_enqueue: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceShaderEnqueueFeaturesAMDX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_enqueue: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderEnqueueFeaturesAMDX<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEnqueueFeaturesAMDX<'_> {} +impl<'a> PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> { + #[inline] + pub fn shader_enqueue(mut self, shader_enqueue: bool) -> Self { + self.shader_enqueue = shader_enqueue.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExecutionGraphPipelineCreateInfoAMDX<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo<'a>, + pub p_library_info: *const PipelineLibraryCreateInfoKHR<'a>, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ExecutionGraphPipelineCreateInfoAMDX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + p_library_info: ::std::ptr::null(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ExecutionGraphPipelineCreateInfoAMDX<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; +} +pub unsafe trait ExtendsExecutionGraphPipelineCreateInfoAMDX {} +impl<'a> ExecutionGraphPipelineCreateInfoAMDX<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.stage_count = stages.len() as _; + self.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR<'a>) -> Self { + self.p_library_info = library_info; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.layout = layout; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.base_pipeline_index = base_pipeline_index; + 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))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageNodeCreateInfoAMDX<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_name: *const c_char, + pub index: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PipelineShaderStageNodeCreateInfoAMDX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_name: ::std::ptr::null(), + index: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PipelineShaderStageNodeCreateInfoAMDX<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; +} +unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineShaderStageNodeCreateInfoAMDX<'_> {} +impl<'a> PipelineShaderStageNodeCreateInfoAMDX<'a> { + #[inline] + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.p_name = name.as_ptr(); + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExecutionGraphPipelineScratchSizeAMDX<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub size: DeviceSize, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ExecutionGraphPipelineScratchSizeAMDX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + size: DeviceSize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ExecutionGraphPipelineScratchSizeAMDX<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX; +} +impl<'a> ExecutionGraphPipelineScratchSizeAMDX<'a> { + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; + self + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DispatchGraphInfoAMDX { + pub node_index: u32, + pub payload_count: u32, + pub payloads: DeviceOrHostAddressConstAMDX, + pub payload_stride: u64, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DispatchGraphInfoAMDX { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DispatchGraphInfoAMDX") + .field("node_index", &self.node_index) + .field("payload_count", &self.payload_count) + .field("payloads", &"union") + .field("payload_stride", &self.payload_stride) + .finish() + } +} +impl DispatchGraphInfoAMDX { + #[inline] + pub fn node_index(mut self, node_index: u32) -> Self { + self.node_index = node_index; + self + } + #[inline] + pub fn payload_count(mut self, payload_count: u32) -> Self { + self.payload_count = payload_count; + self + } + #[inline] + pub fn payloads(mut self, payloads: DeviceOrHostAddressConstAMDX) -> Self { + self.payloads = payloads; + self + } + #[inline] + pub fn payload_stride(mut self, payload_stride: u64) -> Self { + self.payload_stride = payload_stride; + self + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DispatchGraphCountInfoAMDX { + pub count: u32, + pub infos: DeviceOrHostAddressConstAMDX, + pub stride: u64, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DispatchGraphCountInfoAMDX { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DispatchGraphCountInfoAMDX") + .field("count", &self.count) + .field("infos", &"union") + .field("stride", &self.stride) + .finish() + } +} +impl DispatchGraphCountInfoAMDX { + #[inline] + pub fn count(mut self, count: u32) -> Self { + self.count = count; + self + } + #[inline] + pub fn infos(mut self, infos: DeviceOrHostAddressConstAMDX) -> Self { + self.infos = infos; + self + } + #[inline] + pub fn stride(mut self, stride: u64) -> Self { + self.stride = stride; + self + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index f49b223ef..55f999448 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -2053,53 +2053,6 @@ impl MemoryOverallocationBehaviorAMD { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] -#[doc = ""] -pub struct ScopeNV(pub(crate) i32); -impl ScopeNV { - #[inline] - pub const fn from_raw(x: i32) -> Self { - Self(x) - } - #[inline] - pub const fn as_raw(self) -> i32 { - self.0 - } -} -impl ScopeNV { - pub const DEVICE: Self = Self(1); - pub const WORKGROUP: Self = Self(2); - pub const SUBGROUP: Self = Self(3); - pub const QUEUE_FAMILY: Self = Self(5); -} -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(transparent)] -#[doc = ""] -pub struct ComponentTypeNV(pub(crate) i32); -impl ComponentTypeNV { - #[inline] - pub const fn from_raw(x: i32) -> Self { - Self(x) - } - #[inline] - pub const fn as_raw(self) -> i32 { - self.0 - } -} -impl ComponentTypeNV { - pub const FLOAT16: Self = Self(0); - pub const FLOAT32: Self = Self(1); - pub const FLOAT64: Self = Self(2); - pub const SINT8: Self = Self(3); - pub const SINT16: Self = Self(4); - pub const SINT32: Self = Self(5); - pub const SINT64: Self = Self(6); - pub const UINT8: Self = Self(7); - pub const UINT16: Self = Self(8); - pub const UINT32: Self = Self(9); - pub const UINT64: Self = Self(10); -} -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(transparent)] #[doc = ""] pub struct FullScreenExclusiveEXT(pub(crate) i32); impl FullScreenExclusiveEXT { @@ -2802,6 +2755,53 @@ impl ShaderCodeTypeEXT { pub const BINARY: Self = Self(0); pub const SPIRV: Self = Self(1); } +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ScopeKHR(pub(crate) i32); +impl ScopeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ScopeKHR { + pub const DEVICE: Self = Self(1); + pub const WORKGROUP: Self = Self(2); + pub const SUBGROUP: Self = Self(3); + pub const QUEUE_FAMILY: Self = Self(5); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ComponentTypeKHR(pub(crate) i32); +impl ComponentTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ComponentTypeKHR { + pub const FLOAT16: Self = Self(0); + pub const FLOAT32: Self = Self(1); + pub const FLOAT64: Self = Self(2); + pub const SINT8: Self = Self(3); + pub const SINT16: Self = Self(4); + pub const SINT32: Self = Self(5); + pub const SINT64: Self = Self(6); + pub const UINT8: Self = Self(7); + pub const UINT16: Self = Self(8); + pub const UINT32: Self = Self(9); + pub const UINT64: Self = Self(10); +} impl fmt::Debug for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index a5734bed3..53571df99 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -6985,6 +6985,245 @@ impl AmdGpuShaderInt16Fn { } #[derive(Clone)] pub struct AmdGpuShaderInt16Fn; +impl AmdxShaderEnqueueFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMDX_shader_enqueue\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateExecutionGraphPipelinesAMDX = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const ExecutionGraphPipelineCreateInfoAMDX, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetExecutionGraphPipelineScratchSizeAMDX = unsafe extern "system" fn( + device: Device, + execution_graph: Pipeline, + p_size_info: *mut ExecutionGraphPipelineScratchSizeAMDX, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetExecutionGraphPipelineNodeIndexAMDX = unsafe extern "system" fn( + device: Device, + execution_graph: Pipeline, + p_node_info: *const PipelineShaderStageNodeCreateInfoAMDX, + p_node_index: *mut u32, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdInitializeGraphScratchMemoryAMDX = + unsafe extern "system" fn(command_buffer: CommandBuffer, scratch: DeviceAddress); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatchGraphAMDX = unsafe extern "system" fn( + command_buffer: CommandBuffer, + scratch: DeviceAddress, + p_count_info: *const DispatchGraphCountInfoAMDX, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatchGraphIndirectAMDX = unsafe extern "system" fn( + command_buffer: CommandBuffer, + scratch: DeviceAddress, + p_count_info: *const DispatchGraphCountInfoAMDX, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatchGraphIndirectCountAMDX = unsafe extern "system" fn( + command_buffer: CommandBuffer, + scratch: DeviceAddress, + count_info: DeviceAddress, +); +#[derive(Clone)] +pub struct AmdxShaderEnqueueFn { + pub create_execution_graph_pipelines_amdx: PFN_vkCreateExecutionGraphPipelinesAMDX, + pub get_execution_graph_pipeline_scratch_size_amdx: + PFN_vkGetExecutionGraphPipelineScratchSizeAMDX, + pub get_execution_graph_pipeline_node_index_amdx: PFN_vkGetExecutionGraphPipelineNodeIndexAMDX, + pub cmd_initialize_graph_scratch_memory_amdx: PFN_vkCmdInitializeGraphScratchMemoryAMDX, + pub cmd_dispatch_graph_amdx: PFN_vkCmdDispatchGraphAMDX, + pub cmd_dispatch_graph_indirect_amdx: PFN_vkCmdDispatchGraphIndirectAMDX, + pub cmd_dispatch_graph_indirect_count_amdx: PFN_vkCmdDispatchGraphIndirectCountAMDX, +} +unsafe impl Send for AmdxShaderEnqueueFn {} +unsafe impl Sync for AmdxShaderEnqueueFn {} +impl AmdxShaderEnqueueFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_execution_graph_pipelines_amdx: unsafe { + unsafe extern "system" fn create_execution_graph_pipelines_amdx( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const ExecutionGraphPipelineCreateInfoAMDX, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_execution_graph_pipelines_amdx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateExecutionGraphPipelinesAMDX\0", + ); + let val = _f(cname); + if val.is_null() { + create_execution_graph_pipelines_amdx + } else { + ::std::mem::transmute(val) + } + }, + get_execution_graph_pipeline_scratch_size_amdx: unsafe { + unsafe extern "system" fn get_execution_graph_pipeline_scratch_size_amdx( + _device: Device, + _execution_graph: Pipeline, + _p_size_info: *mut ExecutionGraphPipelineScratchSizeAMDX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_execution_graph_pipeline_scratch_size_amdx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetExecutionGraphPipelineScratchSizeAMDX\0", + ); + let val = _f(cname); + if val.is_null() { + get_execution_graph_pipeline_scratch_size_amdx + } else { + ::std::mem::transmute(val) + } + }, + get_execution_graph_pipeline_node_index_amdx: unsafe { + unsafe extern "system" fn get_execution_graph_pipeline_node_index_amdx( + _device: Device, + _execution_graph: Pipeline, + _p_node_info: *const PipelineShaderStageNodeCreateInfoAMDX, + _p_node_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_execution_graph_pipeline_node_index_amdx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetExecutionGraphPipelineNodeIndexAMDX\0", + ); + let val = _f(cname); + if val.is_null() { + get_execution_graph_pipeline_node_index_amdx + } else { + ::std::mem::transmute(val) + } + }, + cmd_initialize_graph_scratch_memory_amdx: unsafe { + unsafe extern "system" fn cmd_initialize_graph_scratch_memory_amdx( + _command_buffer: CommandBuffer, + _scratch: DeviceAddress, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_initialize_graph_scratch_memory_amdx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdInitializeGraphScratchMemoryAMDX\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_initialize_graph_scratch_memory_amdx + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_graph_amdx: unsafe { + unsafe extern "system" fn cmd_dispatch_graph_amdx( + _command_buffer: CommandBuffer, + _scratch: DeviceAddress, + _p_count_info: *const DispatchGraphCountInfoAMDX, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_graph_amdx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchGraphAMDX\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_graph_amdx + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_graph_indirect_amdx: unsafe { + unsafe extern "system" fn cmd_dispatch_graph_indirect_amdx( + _command_buffer: CommandBuffer, + _scratch: DeviceAddress, + _p_count_info: *const DispatchGraphCountInfoAMDX, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_graph_indirect_amdx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDispatchGraphIndirectAMDX\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_graph_indirect_amdx + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_graph_indirect_count_amdx: unsafe { + unsafe extern "system" fn cmd_dispatch_graph_indirect_count_amdx( + _command_buffer: CommandBuffer, + _scratch: DeviceAddress, + _count_info: DeviceAddress, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_graph_indirect_count_amdx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDispatchGraphIndirectCountAMDX\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_graph_indirect_count_amdx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_AMDX_shader_enqueue'"] +impl BufferUsageFlags { + pub const EXECUTION_GRAPH_SCRATCH_AMDX: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_AMDX_shader_enqueue'"] +impl BufferUsageFlags2KHR { + pub const EXECUTION_GRAPH_SCRATCH_AMDX: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_AMDX_shader_enqueue'"] +impl PipelineBindPoint { + pub const EXECUTION_GRAPH_AMDX: Self = Self(1_000_134_000); +} +#[doc = "Generated from 'VK_AMDX_shader_enqueue'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: Self = Self(1_000_134_000); + pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: Self = Self(1_000_134_001); + pub const EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: Self = Self(1_000_134_002); + pub const EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: Self = Self(1_000_134_003); + pub const PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: Self = Self(1_000_134_004); +} impl AmdMixedAttachmentSamplesFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_mixed_attachment_samples\0") @@ -11561,6 +11800,27 @@ impl NvCooperativeMatrixFn { } } #[doc = "Generated from 'VK_NV_cooperative_matrix'"] +impl ComponentTypeKHR { + pub const FLOAT16_NV: Self = Self::FLOAT16; + pub const FLOAT32_NV: Self = Self::FLOAT32; + pub const FLOAT64_NV: Self = Self::FLOAT64; + pub const SINT8_NV: Self = Self::SINT8; + pub const SINT16_NV: Self = Self::SINT16; + pub const SINT32_NV: Self = Self::SINT32; + pub const SINT64_NV: Self = Self::SINT64; + pub const UINT8_NV: Self = Self::UINT8; + pub const UINT16_NV: Self = Self::UINT16; + pub const UINT32_NV: Self = Self::UINT32; + pub const UINT64_NV: Self = Self::UINT64; +} +#[doc = "Generated from 'VK_NV_cooperative_matrix'"] +impl ScopeKHR { + pub const DEVICE_NV: Self = Self::DEVICE; + pub const WORKGROUP_NV: Self = Self::WORKGROUP; + pub const SUBGROUP_NV: Self = Self::SUBGROUP; + pub const QUEUE_FAMILY_NV: Self = Self::QUEUE_FAMILY; +} +#[doc = "Generated from 'VK_NV_cooperative_matrix'"] impl StructureType { pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000); pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001); @@ -12757,6 +13017,182 @@ impl StructureType { pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004); pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005); } +impl ExtHostImageCopyFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_host_image_copy\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMemoryToImageEXT = unsafe extern "system" fn( + device: Device, + p_copy_memory_to_image_info: *const CopyMemoryToImageInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyImageToMemoryEXT = unsafe extern "system" fn( + device: Device, + p_copy_image_to_memory_info: *const CopyImageToMemoryInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyImageToImageEXT = unsafe extern "system" fn( + device: Device, + p_copy_image_to_image_info: *const CopyImageToImageInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkTransitionImageLayoutEXT = unsafe extern "system" fn( + device: Device, + transition_count: u32, + p_transitions: *const HostImageLayoutTransitionInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSubresourceLayout2KHR = unsafe extern "system" fn( + device: Device, + image: Image, + p_subresource: *const ImageSubresource2KHR, + p_layout: *mut SubresourceLayout2KHR, +); +#[derive(Clone)] +pub struct ExtHostImageCopyFn { + pub copy_memory_to_image_ext: PFN_vkCopyMemoryToImageEXT, + pub copy_image_to_memory_ext: PFN_vkCopyImageToMemoryEXT, + pub copy_image_to_image_ext: PFN_vkCopyImageToImageEXT, + pub transition_image_layout_ext: PFN_vkTransitionImageLayoutEXT, + pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2KHR, +} +unsafe impl Send for ExtHostImageCopyFn {} +unsafe impl Sync for ExtHostImageCopyFn {} +impl ExtHostImageCopyFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + copy_memory_to_image_ext: unsafe { + unsafe extern "system" fn copy_memory_to_image_ext( + _device: Device, + _p_copy_memory_to_image_info: *const CopyMemoryToImageInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_memory_to_image_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToImageEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_memory_to_image_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_image_to_memory_ext: unsafe { + unsafe extern "system" fn copy_image_to_memory_ext( + _device: Device, + _p_copy_image_to_memory_info: *const CopyImageToMemoryInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_image_to_memory_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToMemoryEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_image_to_memory_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_image_to_image_ext: unsafe { + unsafe extern "system" fn copy_image_to_image_ext( + _device: Device, + _p_copy_image_to_image_info: *const CopyImageToImageInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_image_to_image_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToImageEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_image_to_image_ext + } else { + ::std::mem::transmute(val) + } + }, + transition_image_layout_ext: unsafe { + unsafe extern "system" fn transition_image_layout_ext( + _device: Device, + _transition_count: u32, + _p_transitions: *const HostImageLayoutTransitionInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(transition_image_layout_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkTransitionImageLayoutEXT\0", + ); + let val = _f(cname); + if val.is_null() { + transition_image_layout_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_subresource_layout2_ext: unsafe { + unsafe extern "system" fn get_image_subresource_layout2_ext( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource2KHR, + _p_layout: *mut SubresourceLayout2KHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_subresource_layout2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSubresourceLayout2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_subresource_layout2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_host_image_copy'"] +impl FormatFeatureFlags2 { + #[doc = "Host image copies are supported"] + pub const HOST_IMAGE_TRANSFER_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_host_image_copy'"] +impl ImageUsageFlags { + #[doc = "Can be used with host image copies"] + pub const HOST_TRANSFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_host_image_copy'"] +impl StructureType { + pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: Self = Self(1_000_270_000); + pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: Self = Self(1_000_270_001); + pub const MEMORY_TO_IMAGE_COPY_EXT: Self = Self(1_000_270_002); + pub const IMAGE_TO_MEMORY_COPY_EXT: Self = Self(1_000_270_003); + pub const COPY_IMAGE_TO_MEMORY_INFO_EXT: Self = Self(1_000_270_004); + pub const COPY_MEMORY_TO_IMAGE_INFO_EXT: Self = Self(1_000_270_005); + pub const HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT: Self = Self(1_000_270_006); + pub const COPY_IMAGE_TO_IMAGE_INFO_EXT: Self = Self(1_000_270_007); + pub const SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: Self = Self(1_000_270_008); + pub const HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: Self = Self(1_000_270_009); +} impl KhrMapMemory2Fn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_map_memory2\0") }; @@ -15132,16 +15568,9 @@ impl ExtImageCompressionControlFn { }; pub const SPEC_VERSION: u32 = 1u32; } -#[allow(non_camel_case_types)] -pub type PFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn( - device: Device, - image: Image, - p_subresource: *const ImageSubresource2EXT, - p_layout: *mut SubresourceLayout2EXT, -); #[derive(Clone)] pub struct ExtImageCompressionControlFn { - pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2EXT, + pub get_image_subresource_layout2_ext: crate::vk::PFN_vkGetImageSubresourceLayout2KHR, } unsafe impl Send for ExtImageCompressionControlFn {} unsafe impl Sync for ExtImageCompressionControlFn {} @@ -15155,8 +15584,8 @@ impl ExtImageCompressionControlFn { unsafe extern "system" fn get_image_subresource_layout2_ext( _device: Device, _image: Image, - _p_subresource: *const ImageSubresource2EXT, - _p_layout: *mut SubresourceLayout2EXT, + _p_subresource: *const ImageSubresource2KHR, + _p_layout: *mut SubresourceLayout2KHR, ) { panic!(concat!( "Unable to load ", @@ -15184,8 +15613,8 @@ impl Result { impl StructureType { pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(1_000_338_000); pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1_000_338_001); - pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1_000_338_002); - pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1_000_338_003); + pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self::SUBRESOURCE_LAYOUT_2_KHR; + pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self::IMAGE_SUBRESOURCE_2_KHR; pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1_000_338_004); } impl ExtAttachmentFeedbackLoopLayoutFn { @@ -15997,7 +16426,7 @@ impl StructureType { impl HuaweiSubpassShadingFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_subpass_shading\0") }; - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn( @@ -16069,7 +16498,7 @@ impl PipelineBindPoint { } #[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] impl PipelineStageFlags2 { - pub const SUBPASS_SHADING_HUAWEI: Self = + pub const SUBPASS_SHADER_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] @@ -17271,7 +17700,7 @@ impl NvDisplacementMicromapFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_displacement_micromap\0") }; - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[derive(Clone)] pub struct NvDisplacementMicromapFn; @@ -17289,6 +17718,10 @@ impl PipelineCreateFlags { Self(0b1_0000_0000_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_NV_displacement_micromap'"] +impl PipelineCreateFlags2KHR { + pub const RESERVED_28_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); @@ -17908,6 +18341,126 @@ impl StructureType { pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: Self = Self(1_000_427_000); pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: Self = Self(1_000_427_001); } +impl NvDeviceGeneratedCommandsComputeFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_device_generated_commands_compute\0", + ) + }; + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineIndirectMemoryRequirementsNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const ComputePipelineCreateInfo, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdUpdatePipelineIndirectBufferNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineIndirectDeviceAddressNV = unsafe extern "system" fn( + device: Device, + p_info: *const PipelineIndirectDeviceAddressInfoNV, +) -> DeviceAddress; +#[derive(Clone)] +pub struct NvDeviceGeneratedCommandsComputeFn { + pub get_pipeline_indirect_memory_requirements_nv: PFN_vkGetPipelineIndirectMemoryRequirementsNV, + pub cmd_update_pipeline_indirect_buffer_nv: PFN_vkCmdUpdatePipelineIndirectBufferNV, + pub get_pipeline_indirect_device_address_nv: PFN_vkGetPipelineIndirectDeviceAddressNV, +} +unsafe impl Send for NvDeviceGeneratedCommandsComputeFn {} +unsafe impl Sync for NvDeviceGeneratedCommandsComputeFn {} +impl NvDeviceGeneratedCommandsComputeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_pipeline_indirect_memory_requirements_nv: unsafe { + unsafe extern "system" fn get_pipeline_indirect_memory_requirements_nv( + _device: Device, + _p_create_info: *const ComputePipelineCreateInfo, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_indirect_memory_requirements_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineIndirectMemoryRequirementsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_indirect_memory_requirements_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_update_pipeline_indirect_buffer_nv: unsafe { + unsafe extern "system" fn cmd_update_pipeline_indirect_buffer_nv( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _pipeline: Pipeline, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_update_pipeline_indirect_buffer_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdUpdatePipelineIndirectBufferNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_update_pipeline_indirect_buffer_nv + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_indirect_device_address_nv: unsafe { + unsafe extern "system" fn get_pipeline_indirect_device_address_nv( + _device: Device, + _p_info: *const PipelineIndirectDeviceAddressInfoNV, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_indirect_device_address_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineIndirectDeviceAddressNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_indirect_device_address_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_device_generated_commands_compute'"] +impl DescriptorSetLayoutCreateFlags { + pub const INDIRECT_BINDABLE_NV: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands_compute'"] +impl IndirectCommandsTokenTypeNV { + pub const PIPELINE: Self = Self(1_000_428_003); + pub const DISPATCH: Self = Self(1_000_428_004); +} +#[doc = "Generated from 'VK_NV_device_generated_commands_compute'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: Self = + Self(1_000_428_000); + pub const COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: Self = Self(1_000_428_001); + pub const PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: Self = Self(1_000_428_002); +} impl NvLinearColorAttachmentFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_linear_color_attachment\0") @@ -19243,6 +19796,205 @@ impl PipelineCreateFlags { impl StructureType { pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1_000_466_000); } +impl KhrMaintenance5Fn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance5\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindIndexBuffer2KHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + size: DeviceSize, + index_type: IndexType, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetRenderingAreaGranularityKHR = unsafe extern "system" fn( + device: Device, + p_rendering_area_info: *const RenderingAreaInfoKHR, + p_granularity: *mut Extent2D, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceImageSubresourceLayoutKHR = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceImageSubresourceInfoKHR, + p_layout: *mut SubresourceLayout2KHR, +); +#[derive(Clone)] +pub struct KhrMaintenance5Fn { + pub cmd_bind_index_buffer2_khr: PFN_vkCmdBindIndexBuffer2KHR, + pub get_rendering_area_granularity_khr: PFN_vkGetRenderingAreaGranularityKHR, + pub get_device_image_subresource_layout_khr: PFN_vkGetDeviceImageSubresourceLayoutKHR, + pub get_image_subresource_layout2_khr: crate::vk::PFN_vkGetImageSubresourceLayout2KHR, +} +unsafe impl Send for KhrMaintenance5Fn {} +unsafe impl Sync for KhrMaintenance5Fn {} +impl KhrMaintenance5Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_bind_index_buffer2_khr: unsafe { + unsafe extern "system" fn cmd_bind_index_buffer2_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _size: DeviceSize, + _index_type: IndexType, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_index_buffer2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_index_buffer2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_rendering_area_granularity_khr: unsafe { + unsafe extern "system" fn get_rendering_area_granularity_khr( + _device: Device, + _p_rendering_area_info: *const RenderingAreaInfoKHR, + _p_granularity: *mut Extent2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_rendering_area_granularity_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRenderingAreaGranularityKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_rendering_area_granularity_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_subresource_layout_khr: unsafe { + unsafe extern "system" fn get_device_image_subresource_layout_khr( + _device: Device, + _p_info: *const DeviceImageSubresourceInfoKHR, + _p_layout: *mut SubresourceLayout2KHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_subresource_layout_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageSubresourceLayoutKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_subresource_layout_khr + } else { + ::std::mem::transmute(val) + } + }, + get_image_subresource_layout2_khr: unsafe { + unsafe extern "system" fn get_image_subresource_layout2_khr( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource2KHR, + _p_layout: *mut SubresourceLayout2KHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_subresource_layout2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSubresourceLayout2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_subresource_layout2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_maintenance5'"] +impl BufferUsageFlags2KHR { + pub const CONDITIONAL_RENDERING: Self = Self(0b10_0000_0000); + pub const SHADER_BINDING_TABLE: Self = Self(0b100_0000_0000); + pub const RAY_TRACING: Self = Self::SHADER_BINDING_TABLE; + pub const TRANSFORM_FEEDBACK_BUFFER: Self = Self(0b1000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER: Self = Self(0b1_0000_0000_0000); + pub const VIDEO_DECODE_SRC: Self = Self(0b10_0000_0000_0000); + pub const VIDEO_DECODE_DST: Self = Self(0b100_0000_0000_0000); + pub const VIDEO_ENCODE_DST: Self = Self(0b1000_0000_0000_0000); + pub const VIDEO_ENCODE_SRC: Self = Self(0b1_0000_0000_0000_0000); + pub const SHADER_DEVICE_ADDRESS: Self = Self(0b10_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY: Self = Self(0b1000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_STORAGE: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLER_DESCRIPTOR_BUFFER: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const RESOURCE_DESCRIPTOR_BUFFER: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER: Self = Self(0b100_0000_0000_0000_0000_0000_0000); + pub const MICROMAP_BUILD_INPUT_READ_ONLY: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const MICROMAP_STORAGE: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_maintenance5'"] +impl Format { + pub const A1B5G5R5_UNORM_PACK16_KHR: Self = Self(1_000_470_000); + pub const A8_UNORM_KHR: Self = Self(1_000_470_001); +} +#[doc = "Generated from 'VK_KHR_maintenance5'"] +impl PipelineCreateFlags2KHR { + pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(0b1000); + pub const DISPATCH_BASE: Self = Self(0b1_0000); + pub const DEFER_COMPILE: Self = Self(0b10_0000); + pub const CAPTURE_STATISTICS: Self = Self(0b100_0000); + pub const CAPTURE_INTERNAL_REPRESENTATIONS: Self = Self(0b1000_0000); + pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(0b1_0000_0000); + pub const EARLY_RETURN_ON_FAILURE: Self = Self(0b10_0000_0000); + pub const LINK_TIME_OPTIMIZATION: Self = Self(0b100_0000_0000); + pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const LIBRARY: Self = Self(0b1000_0000_0000); + pub const RAY_TRACING_SKIP_TRIANGLES: Self = Self(0b1_0000_0000_0000); + pub const RAY_TRACING_SKIP_AABBS: Self = Self(0b10_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS: Self = Self(0b100_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS: Self = Self(0b1000_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_MISS_SHADERS: Self = Self(0b1_0000_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS: Self = Self(0b10_0000_0000_0000_0000); + pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY: Self = + Self(0b1000_0000_0000_0000_0000); + pub const INDIRECT_BINDABLE: Self = Self(0b100_0000_0000_0000_0000); + pub const RAY_TRACING_ALLOW_MOTION: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = + Self(0b10_0000_0000_0000_0000_0000); + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = + Self(0b100_0000_0000_0000_0000_0000); + pub const RAY_TRACING_OPACITY_MICROMAP: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const COLOR_ATTACHMENT_FEEDBACK_LOOP: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP: Self = + Self(0b100_0000_0000_0000_0000_0000_0000); + pub const NO_PROTECTED_ACCESS: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const PROTECTED_ACCESS_ONLY: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); + pub const DESCRIPTOR_BUFFER: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_maintenance5'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: Self = Self(1_000_470_000); + pub const PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: Self = Self(1_000_470_001); + pub const RENDERING_AREA_INFO_KHR: Self = Self(1_000_470_003); + pub const DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: Self = Self(1_000_470_004); + pub const SUBRESOURCE_LAYOUT_2_KHR: Self = Self(1_000_338_002); + pub const IMAGE_SUBRESOURCE_2_KHR: Self = Self(1_000_338_003); + pub const PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: Self = Self(1_000_470_005); + pub const BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: Self = Self(1_000_470_006); +} impl KhrRayTracingPositionFetchFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_position_fetch\0") @@ -20644,6 +21396,61 @@ impl StructureType { pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: Self = Self(1_000_499_000); } +impl KhrCooperativeMatrixFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_cooperative_matrix\0") }; + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut CooperativeMatrixPropertiesKHR, + ) -> Result; +#[derive(Clone)] +pub struct KhrCooperativeMatrixFn { + pub get_physical_device_cooperative_matrix_properties_khr: + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, +} +unsafe impl Send for KhrCooperativeMatrixFn {} +unsafe impl Sync for KhrCooperativeMatrixFn {} +impl KhrCooperativeMatrixFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_cooperative_matrix_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut CooperativeMatrixPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_cooperative_matrix_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_cooperative_matrix_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_cooperative_matrix'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: Self = Self(1_000_506_000); + pub const COOPERATIVE_MATRIX_PROPERTIES_KHR: Self = Self(1_000_506_001); + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: Self = Self(1_000_506_002); +} impl QcomMultiviewPerViewRenderAreasFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked( diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index c1a8560c5..94bb3c998 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit c1a8560c5cf5e7bd6dbc71fe69b1a317411c36b8 +Subproject commit 94bb3c998b9156b9101421f7614617dfcf7f4256