From a75d8e7e889bd75ac08f226539c04c7848823fcc Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Thu, 17 Jun 2021 10:48:32 +0200 Subject: [PATCH] Update Vulkan-Headers to 1.2.181 (#446) * Update Vulkan-Headers to 1.2.176 * Update Vulkan-Headers to 1.2.177 * Update Vulkan-Headers to 1.2.178 This requires `len="null-terminated"` to be added to `VkCuFunctionCreateInfoNVX::pName` in `vk.xml`. * Update Vulkan-Headers to 1.2.179 * Update Vulkan-Headers to 1.2.181 Skipping 1.2.180 due to missing VkPipelineLayoutCreateFlagBits, which is defined now. --- ash/src/vk/bitflags.rs | 6 + ash/src/vk/const_debugs.rs | 153 +++-- ash/src/vk/constants.rs | 1 + ash/src/vk/definitions.rs | 724 +++++++++++++++++++- ash/src/vk/enums.rs | 19 + ash/src/vk/extensions.rs | 1270 ++++++++++++++++++++++++++++++------ generator/Vulkan-Headers | 2 +- 7 files changed, 1932 insertions(+), 243 deletions(-) diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index cc49296..544a3ed 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1048,6 +1048,12 @@ vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); impl EventCreateFlags {} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineLayoutCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); +impl PipelineLayoutCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, 0b0, Flags); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 0e55202..5471548 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -171,14 +171,14 @@ impl fmt::Debug for AccessFlags { AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR.0, "ACCELERATION_STRUCTURE_WRITE_KHR", ), - ( - AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, - "SHADING_RATE_IMAGE_READ_NV", - ), ( AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, "FRAGMENT_DENSITY_MAP_READ_EXT", ), + ( + AccessFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR", + ), ( AccessFlags::COMMAND_PREPROCESS_READ_NV.0, "COMMAND_PREPROCESS_READ_NV", @@ -294,6 +294,7 @@ impl fmt::Debug for AccessFlags2KHR { AccessFlags2KHR::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), + (AccessFlags2KHR::RESERVED_39_HUAWEI.0, "RESERVED_39_HUAWEI"), ]; debug_flags(f, KNOWN, self.0) } @@ -481,7 +482,6 @@ impl fmt::Debug for BufferCreateFlags { (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::RESERVED_5_NV.0, "RESERVED_5_NV"), (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ( BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, @@ -517,14 +517,6 @@ impl fmt::Debug for BufferUsageFlags { BufferUsageFlags::VIDEO_DECODE_DST_KHR.0, "VIDEO_DECODE_DST_KHR", ), - ( - BufferUsageFlags::VIDEO_ENCODE_DST_KHR.0, - "VIDEO_ENCODE_DST_KHR", - ), - ( - BufferUsageFlags::VIDEO_ENCODE_SRC_KHR.0, - "VIDEO_ENCODE_SRC_KHR", - ), ( BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, "TRANSFORM_FEEDBACK_BUFFER_EXT", @@ -550,6 +542,14 @@ impl fmt::Debug for BufferUsageFlags { "SHADER_BINDING_TABLE_KHR", ), (BufferUsageFlags::RESERVED_18_QCOM.0, "RESERVED_18_QCOM"), + ( + BufferUsageFlags::VIDEO_ENCODE_DST_KHR.0, + "VIDEO_ENCODE_DST_KHR", + ), + ( + BufferUsageFlags::VIDEO_ENCODE_SRC_KHR.0, + "VIDEO_ENCODE_SRC_KHR", + ), ( BufferUsageFlags::SHADER_DEVICE_ADDRESS.0, "SHADER_DEVICE_ADDRESS", @@ -951,6 +951,8 @@ impl fmt::Debug for DebugReportObjectTypeEXT { Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"), + Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), _ => None, @@ -1058,6 +1060,10 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags { DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, "PUSH_DESCRIPTOR_KHR", ), + ( + DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0, + "RESERVED_3_AMD", + ), ( DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_VALVE.0, "HOST_ONLY_POOL_VALVE", @@ -1290,6 +1296,7 @@ impl fmt::Debug for DriverId { Self::MESA_LLVMPIPE => Some("MESA_LLVMPIPE"), Self::MOLTENVK => Some("MOLTENVK"), Self::COREAVI_PROPRIETARY => Some("COREAVI_PROPRIETARY"), + Self::JUICE_PROPRIETARY => Some("JUICE_PROPRIETARY"), _ => None, }; if let Some(x) = name { @@ -1335,6 +1342,11 @@ impl fmt::Debug for DynamicState { Self::STENCIL_TEST_ENABLE_EXT => Some("STENCIL_TEST_ENABLE_EXT"), Self::STENCIL_OP_EXT => Some("STENCIL_OP_EXT"), Self::VERTEX_INPUT_EXT => Some("VERTEX_INPUT_EXT"), + Self::PATCH_CONTROL_POINTS_EXT => Some("PATCH_CONTROL_POINTS_EXT"), + Self::RASTERIZER_DISCARD_ENABLE_EXT => Some("RASTERIZER_DISCARD_ENABLE_EXT"), + Self::DEPTH_BIAS_ENABLE_EXT => Some("DEPTH_BIAS_ENABLE_EXT"), + Self::LOGIC_OP_EXT => Some("LOGIC_OP_EXT"), + Self::PRIMITIVE_RESTART_ENABLE_EXT => Some("PRIMITIVE_RESTART_ENABLE_EXT"), Self::COLOR_WRITE_ENABLE_EXT => Some("COLOR_WRITE_ENABLE_EXT"), _ => None, }; @@ -1450,6 +1462,14 @@ impl fmt::Debug for ExternalMemoryHandleTypeFlags { ExternalMemoryHandleTypeFlags::ZIRCON_VMO_FUCHSIA.0, "ZIRCON_VMO_FUCHSIA", ), + ( + ExternalMemoryHandleTypeFlags::RESERVED_12_NV.0, + "RESERVED_12_NV", + ), + ( + ExternalMemoryHandleTypeFlags::RESERVED_13_NV.0, + "RESERVED_13_NV", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -1869,7 +1889,7 @@ impl fmt::Debug for Format { } impl fmt::Debug for FormatFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [(Flags , & str)] = & [(FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG") , (FormatFeatureFlags :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX")] ; + const KNOWN : & [(Flags , & str)] = & [(FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG") , (FormatFeatureFlags :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX")] ; debug_flags(f, KNOWN, self.0) } } @@ -2055,7 +2075,6 @@ impl fmt::Debug for ImageCreateFlags { "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", ), (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - (ImageCreateFlags::RESERVED_15_NV.0, "RESERVED_15_NV"), (ImageCreateFlags::ALIAS.0, "ALIAS"), ( ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, @@ -2092,12 +2111,14 @@ impl fmt::Debug for ImageLayout { Self::VIDEO_DECODE_DST_KHR => Some("VIDEO_DECODE_DST_KHR"), Self::VIDEO_DECODE_SRC_KHR => Some("VIDEO_DECODE_SRC_KHR"), Self::VIDEO_DECODE_DPB_KHR => Some("VIDEO_DECODE_DPB_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR => { + Some("FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR") + } Self::VIDEO_ENCODE_DST_KHR => Some("VIDEO_ENCODE_DST_KHR"), Self::VIDEO_ENCODE_SRC_KHR => Some("VIDEO_ENCODE_SRC_KHR"), Self::VIDEO_ENCODE_DPB_KHR => Some("VIDEO_ENCODE_DPB_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), - Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), Self::READ_ONLY_OPTIMAL_KHR => Some("READ_ONLY_OPTIMAL_KHR"), Self::ATTACHMENT_OPTIMAL_KHR => Some("ATTACHMENT_OPTIMAL_KHR"), Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { @@ -2184,6 +2205,16 @@ impl fmt::Debug for ImageUsageFlags { ImageUsageFlags::VIDEO_DECODE_DPB_KHR.0, "VIDEO_DECODE_DPB_KHR", ), + (ImageUsageFlags::RESERVED_16_QCOM.0, "RESERVED_16_QCOM"), + (ImageUsageFlags::RESERVED_17_QCOM.0, "RESERVED_17_QCOM"), + ( + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", + ), + ( + ImageUsageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), ( ImageUsageFlags::VIDEO_ENCODE_DST_KHR.0, "VIDEO_ENCODE_DST_KHR", @@ -2196,16 +2227,7 @@ impl fmt::Debug for ImageUsageFlags { ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0, "VIDEO_ENCODE_DPB_KHR", ), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - (ImageUsageFlags::RESERVED_16_QCOM.0, "RESERVED_16_QCOM"), - (ImageUsageFlags::RESERVED_17_QCOM.0, "RESERVED_17_QCOM"), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", - ), + (ImageUsageFlags::RESERVED_18_HUAWEI.0, "RESERVED_18_HUAWEI"), ]; debug_flags(f, KNOWN, self.0) } @@ -2435,6 +2457,7 @@ impl fmt::Debug for MemoryPropertyFlags { MemoryPropertyFlags::DEVICE_UNCACHED_AMD.0, "DEVICE_UNCACHED_AMD", ), + (MemoryPropertyFlags::RESERVED_8_NV.0, "RESERVED_8_NV"), (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), ]; debug_flags(f, KNOWN, self.0) @@ -2482,6 +2505,8 @@ impl fmt::Debug for ObjectType { Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), Self::VIDEO_SESSION_KHR => Some("VIDEO_SESSION_KHR"), Self::VIDEO_SESSION_PARAMETERS_KHR => Some("VIDEO_SESSION_PARAMETERS_KHR"), + Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"), + Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), @@ -2683,7 +2708,7 @@ impl fmt::Debug for PipelineCacheCreateFlags { PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED_EXT.0, "EXTERNALLY_SYNCHRONIZED_EXT", ), - (PipelineCacheCreateFlags::RESERVED_2_EXT.0, "RESERVED_2_EXT"), + (PipelineCacheCreateFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"), ]; debug_flags(f, KNOWN, self.0) } @@ -2743,6 +2768,8 @@ impl fmt::Debug for PipelineCreateFlags { "ALLOW_DERIVATIVES", ), (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags::RESERVED_21_AMD.0, "RESERVED_21_AMD"), + (PipelineCreateFlags::RESERVED_22_AMD.0, "RESERVED_22_AMD"), ( PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0, "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR", @@ -2793,6 +2820,8 @@ impl fmt::Debug for PipelineCreateFlags { PipelineCreateFlags::EARLY_RETURN_ON_FAILURE_EXT.0, "EARLY_RETURN_ON_FAILURE_EXT", ), + (PipelineCreateFlags::RESERVED_23_AMD.0, "RESERVED_23_AMD"), + (PipelineCreateFlags::RESERVED_10_AMD.0, "RESERVED_10_AMD"), (PipelineCreateFlags::RESERVED_20_NV.0, "RESERVED_20_NV"), ( PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, @@ -2861,7 +2890,10 @@ impl fmt::Debug for PipelineInputAssemblyStateCreateFlags { } impl fmt::Debug for PipelineLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[]; + const KNOWN: &[(Flags, &str)] = &[( + PipelineLayoutCreateFlags::RESERVED_0_AMD.0, + "RESERVED_0_AMD", + )]; debug_flags(f, KNOWN, self.0) } } @@ -2969,16 +3001,16 @@ impl fmt::Debug for PipelineStageFlags { PipelineStageFlags::RAY_TRACING_SHADER_KHR.0, "RAY_TRACING_SHADER_KHR", ), - ( - PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), ( PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, "FRAGMENT_DENSITY_PROCESS_EXT", ), + ( + PipelineStageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), ( PipelineStageFlags::COMMAND_PREPROCESS_NV.0, "COMMAND_PREPROCESS_NV", @@ -3069,6 +3101,10 @@ impl fmt::Debug for PipelineStageFlags2KHR { ), (PipelineStageFlags2KHR::TASK_SHADER_NV.0, "TASK_SHADER_NV"), (PipelineStageFlags2KHR::MESH_SHADER_NV.0, "MESH_SHADER_NV"), + ( + PipelineStageFlags2KHR::RESERVED_40_HUAWEI.0, + "RESERVED_40_HUAWEI", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -3174,6 +3210,20 @@ impl fmt::Debug for PrivateDataSlotCreateFlagsEXT { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for ProvokingVertexModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_VERTEX => Some("FIRST_VERTEX"), + Self::LAST_VERTEX => Some("LAST_VERTEX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; @@ -3284,9 +3334,6 @@ impl fmt::Debug for QueryType { Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), Self::TIMESTAMP => Some("TIMESTAMP"), Self::RESULT_STATUS_ONLY_KHR => Some("RESULT_STATUS_ONLY_KHR"), - Self::VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR => { - Some("VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR") - } Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), Self::PERFORMANCE_QUERY_KHR => Some("PERFORMANCE_QUERY_KHR"), Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR => { @@ -3299,6 +3346,9 @@ impl fmt::Debug for QueryType { Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") } Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"), + Self::VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR => { + Some("VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR") + } _ => None, }; if let Some(x) = name { @@ -3916,8 +3966,6 @@ impl fmt::Debug for StructureType { } Self::VIDEO_FORMAT_PROPERTIES_KHR => Some("VIDEO_FORMAT_PROPERTIES_KHR"), Self::VIDEO_DECODE_INFO_KHR => Some("VIDEO_DECODE_INFO_KHR"), - Self::VIDEO_ENCODE_INFO_KHR => Some("VIDEO_ENCODE_INFO_KHR"), - Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => Some("VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"), Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") } @@ -3936,6 +3984,9 @@ impl fmt::Debug for StructureType { Self::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT => { Some("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT") } + Self::CU_MODULE_CREATE_INFO_NVX => Some("CU_MODULE_CREATE_INFO_NVX"), + Self::CU_FUNCTION_CREATE_INFO_NVX => Some("CU_FUNCTION_CREATE_INFO_NVX"), + Self::CU_LAUNCH_INFO_NVX => Some("CU_LAUNCH_INFO_NVX"), Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"), Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"), Self::VIDEO_ENCODE_H264_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H264_CAPABILITIES_EXT"), @@ -4508,6 +4559,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT") + } + Self::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT") + } Self::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT => { Some("SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT") } @@ -4622,6 +4682,8 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT") } + Self::VIDEO_ENCODE_INFO_KHR => Some("VIDEO_ENCODE_INFO_KHR"), + Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => Some("VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"), Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => { Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV") } @@ -4643,6 +4705,9 @@ impl fmt::Debug for StructureType { Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV") } Self::CHECKPOINT_DATA_2_NV => Some("CHECKPOINT_DATA_2_NV"), + Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR") + } Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR => { Some("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR") } @@ -4716,6 +4781,9 @@ impl fmt::Debug for StructureType { Self::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA => { Some("SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA") } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT") + } Self::SCREEN_SURFACE_CREATE_INFO_QNX => Some("SCREEN_SURFACE_CREATE_INFO_QNX"), Self::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT => { Some("PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT") @@ -4723,6 +4791,12 @@ impl fmt::Debug for StructureType { Self::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT => { Some("PIPELINE_COLOR_WRITE_CREATE_INFO_EXT") } + Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT") + } + Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT => { + Some("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT") + } Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -5189,6 +5263,7 @@ impl fmt::Debug for ValidationFeatureDisableEXT { Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), Self::CORE_CHECKS => Some("CORE_CHECKS"), Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + Self::SHADER_VALIDATION_CACHE => Some("SHADER_VALIDATION_CACHE"), _ => None, }; if let Some(x) = name { diff --git a/ash/src/vk/constants.rs b/ash/src/vk/constants.rs index 125fb85..95a976e 100644 --- a/ash/src/vk/constants.rs +++ b/ash/src/vk/constants.rs @@ -21,4 +21,5 @@ pub const MAX_DEVICE_GROUP_SIZE: usize = 32; pub const MAX_DRIVER_NAME_SIZE: usize = 256; pub const MAX_DRIVER_INFO_SIZE: usize = 256; pub const SHADER_UNUSED_KHR: u32 = !0; +pub const MAX_GLOBAL_PRIORITY_SIZE_EXT: usize = 16; pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR; diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 5bb7927..9c19d7a 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -53,7 +53,7 @@ pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0); pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); #[doc = ""] pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); -pub const HEADER_VERSION: u32 = 175u32; +pub const HEADER_VERSION: u32 = 181u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION); #[doc = ""] @@ -75,11 +75,6 @@ pub struct QueryPoolCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct PipelineLayoutCreateFlags(pub(crate) Flags); -vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags); -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags); @@ -426,6 +421,8 @@ handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "") ; handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "") ; handle_nondispatchable ! (PrivateDataSlotEXT , PRIVATE_DATA_SLOT_EXT , doc = "") ; +handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "") ; +handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "") ; handle_nondispatchable!( DisplayKHR, DISPLAY_KHR, @@ -24208,6 +24205,128 @@ impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub global_priority_query: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesEXT { + fn default() -> PhysicalDeviceGlobalPriorityQueryFeaturesEXT { + PhysicalDeviceGlobalPriorityQueryFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + global_priority_query: Bool32::default(), + } + } +} +impl PhysicalDeviceGlobalPriorityQueryFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> { + PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder { + inner: PhysicalDeviceGlobalPriorityQueryFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceGlobalPriorityQueryFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceGlobalPriorityQueryFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> { + pub fn global_priority_query(mut self, global_priority_query: bool) -> Self { + self.inner.global_priority_query = global_priority_query.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct QueueFamilyGlobalPriorityPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub priority_count: u32, + pub priorities: [QueueGlobalPriorityEXT; MAX_GLOBAL_PRIORITY_SIZE_EXT], +} +impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesEXT { + fn default() -> QueueFamilyGlobalPriorityPropertiesEXT { + QueueFamilyGlobalPriorityPropertiesEXT { + s_type: StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + priority_count: u32::default(), + priorities: unsafe { ::std::mem::zeroed() }, + } + } +} +impl QueueFamilyGlobalPriorityPropertiesEXT { + pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> { + QueueFamilyGlobalPriorityPropertiesEXTBuilder { + inner: QueueFamilyGlobalPriorityPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> { + inner: QueueFamilyGlobalPriorityPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesEXT {} +impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> { + type Target = QueueFamilyGlobalPriorityPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> { + pub fn priority_count(mut self, priority_count: u32) -> Self { + self.inner.priority_count = priority_count; + self + } + pub fn priorities( + mut self, + priorities: [QueueGlobalPriorityEXT; MAX_GLOBAL_PRIORITY_SIZE_EXT], + ) -> Self { + self.inner.priorities = priorities; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct DebugUtilsObjectNameInfoEXT { pub s_type: StructureType, @@ -41098,6 +41217,85 @@ impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state2: Bool32, + pub extended_dynamic_state2_logic_op: Bool32, + pub extended_dynamic_state2_patch_control_points: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT { + fn default() -> PhysicalDeviceExtendedDynamicState2FeaturesEXT { + PhysicalDeviceExtendedDynamicState2FeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state2: Bool32::default(), + extended_dynamic_state2_logic_op: Bool32::default(), + extended_dynamic_state2_patch_control_points: Bool32::default(), + } + } +} +impl PhysicalDeviceExtendedDynamicState2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder { + inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self { + self.inner.extended_dynamic_state2 = extended_dynamic_state2.into(); + self + } + pub fn extended_dynamic_state2_logic_op( + mut self, + extended_dynamic_state2_logic_op: bool, + ) -> Self { + self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into(); + self + } + pub fn extended_dynamic_state2_patch_control_points( + mut self, + extended_dynamic_state2_patch_control_points: bool, + ) -> Self { + self.inner.extended_dynamic_state2_patch_control_points = + extended_dynamic_state2_patch_control_points.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct RenderPassTransformBeginInfoQCOM { pub s_type: StructureType, @@ -41464,6 +41662,81 @@ impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_subgroup_uniform_control_flow: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + fn default() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + s_type: + StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + shader_subgroup_uniform_control_flow: Bool32::default(), + } + } +} +impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder { + inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> +{ + type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + pub fn shader_subgroup_uniform_control_flow( + mut self, + shader_subgroup_uniform_control_flow: bool, + ) -> Self { + self.inner.shader_subgroup_uniform_control_flow = + shader_subgroup_uniform_control_flow.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceRobustness2FeaturesEXT { pub s_type: StructureType, @@ -48540,3 +48813,442 @@ impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceProvokingVertexFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub provoking_vertex_last: Bool32, + pub transform_feedback_preserves_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT { + fn default() -> PhysicalDeviceProvokingVertexFeaturesEXT { + PhysicalDeviceProvokingVertexFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + provoking_vertex_last: Bool32::default(), + transform_feedback_preserves_provoking_vertex: Bool32::default(), + } + } +} +impl PhysicalDeviceProvokingVertexFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + PhysicalDeviceProvokingVertexFeaturesEXTBuilder { + inner: PhysicalDeviceProvokingVertexFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceProvokingVertexFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceProvokingVertexFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self { + self.inner.provoking_vertex_last = provoking_vertex_last.into(); + self + } + pub fn transform_feedback_preserves_provoking_vertex( + mut self, + transform_feedback_preserves_provoking_vertex: bool, + ) -> Self { + self.inner.transform_feedback_preserves_provoking_vertex = + transform_feedback_preserves_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceProvokingVertexPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub provoking_vertex_mode_per_pipeline: Bool32, + pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT { + fn default() -> PhysicalDeviceProvokingVertexPropertiesEXT { + PhysicalDeviceProvokingVertexPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + provoking_vertex_mode_per_pipeline: Bool32::default(), + transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(), + } + } +} +impl PhysicalDeviceProvokingVertexPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + PhysicalDeviceProvokingVertexPropertiesEXTBuilder { + inner: PhysicalDeviceProvokingVertexPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceProvokingVertexPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceProvokingVertexPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + pub fn provoking_vertex_mode_per_pipeline( + mut self, + provoking_vertex_mode_per_pipeline: bool, + ) -> Self { + self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into(); + self + } + pub fn transform_feedback_preserves_triangle_fan_provoking_vertex( + mut self, + transform_feedback_preserves_triangle_fan_provoking_vertex: bool, + ) -> Self { + self.inner + .transform_feedback_preserves_triangle_fan_provoking_vertex = + transform_feedback_preserves_triangle_fan_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub provoking_vertex_mode: ProvokingVertexModeEXT, +} +impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT { + fn default() -> PipelineRasterizationProvokingVertexStateCreateInfoEXT { + PipelineRasterizationProvokingVertexStateCreateInfoEXT { + s_type: StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + provoking_vertex_mode: ProvokingVertexModeEXT::default(), + } + } +} +impl PipelineRasterizationProvokingVertexStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder { + inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationProvokingVertexStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self { + self.inner.provoking_vertex_mode = provoking_vertex_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CuModuleCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data_size: usize, + pub p_data: *const c_void, +} +impl ::std::default::Default for CuModuleCreateInfoNVX { + fn default() -> CuModuleCreateInfoNVX { + CuModuleCreateInfoNVX { + s_type: StructureType::CU_MODULE_CREATE_INFO_NVX, + p_next: ::std::ptr::null(), + data_size: usize::default(), + p_data: ::std::ptr::null(), + } + } +} +impl CuModuleCreateInfoNVX { + pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> { + CuModuleCreateInfoNVXBuilder { + inner: CuModuleCreateInfoNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuModuleCreateInfoNVXBuilder<'a> { + inner: CuModuleCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> { + type Target = CuModuleCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuModuleCreateInfoNVXBuilder<'a> { + pub fn data_size(mut self, data_size: usize) -> Self { + self.inner.data_size = data_size; + self + } + pub fn data(mut self, data: *const c_void) -> Self { + self.inner.p_data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuModuleCreateInfoNVX { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CuFunctionCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub module: CuModuleNVX, + pub p_name: *const c_char, +} +impl ::std::default::Default for CuFunctionCreateInfoNVX { + fn default() -> CuFunctionCreateInfoNVX { + CuFunctionCreateInfoNVX { + s_type: StructureType::CU_FUNCTION_CREATE_INFO_NVX, + p_next: ::std::ptr::null(), + module: CuModuleNVX::default(), + p_name: ::std::ptr::null(), + } + } +} +impl CuFunctionCreateInfoNVX { + pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> { + CuFunctionCreateInfoNVXBuilder { + inner: CuFunctionCreateInfoNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuFunctionCreateInfoNVXBuilder<'a> { + inner: CuFunctionCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> { + type Target = CuFunctionCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuFunctionCreateInfoNVXBuilder<'a> { + pub fn module(mut self, module: CuModuleNVX) -> Self { + self.inner.module = module; + self + } + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_name = name.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuFunctionCreateInfoNVX { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CuLaunchInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub function: CuFunctionNVX, + pub grid_dim_x: u32, + pub grid_dim_y: u32, + pub grid_dim_z: u32, + pub block_dim_x: u32, + pub block_dim_y: u32, + pub block_dim_z: u32, + pub shared_mem_bytes: u32, + pub param_count: usize, + pub p_params: *const *const c_void, + pub extra_count: usize, + pub p_extras: *const *const c_void, +} +impl ::std::default::Default for CuLaunchInfoNVX { + fn default() -> CuLaunchInfoNVX { + CuLaunchInfoNVX { + s_type: StructureType::CU_LAUNCH_INFO_NVX, + p_next: ::std::ptr::null(), + function: CuFunctionNVX::default(), + grid_dim_x: u32::default(), + grid_dim_y: u32::default(), + grid_dim_z: u32::default(), + block_dim_x: u32::default(), + block_dim_y: u32::default(), + block_dim_z: u32::default(), + shared_mem_bytes: u32::default(), + param_count: usize::default(), + p_params: ::std::ptr::null(), + extra_count: usize::default(), + p_extras: ::std::ptr::null(), + } + } +} +impl CuLaunchInfoNVX { + pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> { + CuLaunchInfoNVXBuilder { + inner: CuLaunchInfoNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuLaunchInfoNVXBuilder<'a> { + inner: CuLaunchInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuLaunchInfoNVXBuilder<'a> { + type Target = CuLaunchInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuLaunchInfoNVXBuilder<'a> { + pub fn function(mut self, function: CuFunctionNVX) -> Self { + self.inner.function = function; + self + } + pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self { + self.inner.grid_dim_x = grid_dim_x; + self + } + pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self { + self.inner.grid_dim_y = grid_dim_y; + self + } + pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self { + self.inner.grid_dim_z = grid_dim_z; + self + } + pub fn block_dim_x(mut self, block_dim_x: u32) -> Self { + self.inner.block_dim_x = block_dim_x; + self + } + pub fn block_dim_y(mut self, block_dim_y: u32) -> Self { + self.inner.block_dim_y = block_dim_y; + self + } + pub fn block_dim_z(mut self, block_dim_z: u32) -> Self { + self.inner.block_dim_z = block_dim_z; + self + } + pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self { + self.inner.shared_mem_bytes = shared_mem_bytes; + self + } + pub fn param_count(mut self, param_count: usize) -> Self { + self.inner.param_count = param_count; + self + } + pub fn params(mut self, params: *const *const c_void) -> Self { + self.inner.p_params = params; + self + } + pub fn extra_count(mut self, extra_count: usize) -> Self { + self.inner.extra_count = extra_count; + self + } + pub fn extras(mut self, extras: *const *const c_void) -> Self { + self.inner.p_extras = extras; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuLaunchInfoNVX { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 0a466b0..a6f308b 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1251,6 +1251,7 @@ impl ValidationFeatureDisableEXT { pub const OBJECT_LIFETIMES: Self = Self(4); pub const CORE_CHECKS: Self = Self(5); pub const UNIQUE_HANDLES: Self = Self(6); + pub const SHADER_VALIDATION_CACHE: Self = Self(7); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -1652,6 +1653,8 @@ impl DriverId { pub const MOLTENVK: Self = Self(14); #[doc = "Core Avionics & Industrial Inc."] pub const COREAVI_PROPRIETARY: Self = Self(15); + #[doc = "Juice Technologies, Inc."] + pub const JUICE_PROPRIETARY: Self = Self(16); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -2190,6 +2193,22 @@ impl FragmentShadingRateTypeNV { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct ProvokingVertexModeEXT(pub(crate) i32); +impl ProvokingVertexModeEXT { + pub const fn from_raw(x: i32) -> Self { + ProvokingVertexModeEXT(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ProvokingVertexModeEXT { + pub const FIRST_VERTEX: Self = Self(0); + pub const LAST_VERTEX: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct QueryResultStatusKHR(pub(crate) i32); impl QueryResultStatusKHR { diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 75643f7..3320ea9 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -1812,7 +1812,7 @@ impl ExtDebugReportFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_debug_report\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 9u32; + pub const SPEC_VERSION: u32 = 10u32; } #[allow(non_camel_case_types)] pub type PFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn( @@ -3076,125 +3076,6 @@ impl ImageLayout { impl ImageLayout { pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002); } -impl KhrVideoEncodeQueueFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_video_encode_queue\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn( - command_buffer: CommandBuffer, - p_encode_info: *const VideoEncodeInfoKHR, -); -#[derive(Clone)] -pub struct KhrVideoEncodeQueueFn { - pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR, -} -unsafe impl Send for KhrVideoEncodeQueueFn {} -unsafe impl Sync for KhrVideoEncodeQueueFn {} -impl KhrVideoEncodeQueueFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - KhrVideoEncodeQueueFn { - cmd_encode_video_khr: unsafe { - unsafe extern "system" fn cmd_encode_video_khr( - _command_buffer: CommandBuffer, - _p_encode_info: *const VideoEncodeInfoKHR, - ) { - panic!(concat!("Unable to load ", stringify!(cmd_encode_video_khr))) - } - let cname = - ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEncodeVideoKHR\0"); - let val = _f(cname); - if val.is_null() { - cmd_encode_video_khr - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn cmd_encode_video_khr( - &self, - command_buffer: CommandBuffer, - p_encode_info: *const VideoEncodeInfoKHR, - ) { - (self.cmd_encode_video_khr)(command_buffer, p_encode_info) - } -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl PipelineStageFlags2KHR { - pub const VIDEO_ENCODE: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl AccessFlags2KHR { - pub const VIDEO_ENCODE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl AccessFlags2KHR { - pub const VIDEO_ENCODE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl StructureType { - pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl StructureType { - pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl QueueFlags { - pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl BufferUsageFlags { - pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b1000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl BufferUsageFlags { - pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl ImageUsageFlags { - pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl ImageUsageFlags { - pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl ImageUsageFlags { - pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl FormatFeatureFlags { - pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl FormatFeatureFlags { - pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl ImageLayout { - pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl ImageLayout { - pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl ImageLayout { - pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002); -} -#[doc = "Generated from 'VK_KHR_video_encode_queue'"] -impl QueryType { - pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000); -} impl AmdGcnShaderFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_gcn_shader\0") @@ -3615,24 +3496,232 @@ impl AccessFlags { impl PipelineStageFlags { pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); } -impl NvxExtension30Fn { +impl NvxBinaryImportFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_extension_30\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_binary_import\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCuModuleNVX = unsafe extern "system" fn( + device: Device, + p_create_info: *const CuModuleCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_module: *mut CuModuleNVX, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCuFunctionNVX = unsafe extern "system" fn( + device: Device, + p_create_info: *const CuFunctionCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_function: *mut CuFunctionNVX, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCuModuleNVX = unsafe extern "system" fn( + device: Device, + module: CuModuleNVX, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn( + device: Device, + function: CuFunctionNVX, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCuLaunchKernelNVX = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_launch_info: *const CuLaunchInfoNVX); #[derive(Clone)] -pub struct NvxExtension30Fn {} -unsafe impl Send for NvxExtension30Fn {} -unsafe impl Sync for NvxExtension30Fn {} -impl NvxExtension30Fn { +pub struct NvxBinaryImportFn { + pub create_cu_module_nvx: PFN_vkCreateCuModuleNVX, + pub create_cu_function_nvx: PFN_vkCreateCuFunctionNVX, + pub destroy_cu_module_nvx: PFN_vkDestroyCuModuleNVX, + pub destroy_cu_function_nvx: PFN_vkDestroyCuFunctionNVX, + pub cmd_cu_launch_kernel_nvx: PFN_vkCmdCuLaunchKernelNVX, +} +unsafe impl Send for NvxBinaryImportFn {} +unsafe impl Sync for NvxBinaryImportFn {} +impl NvxBinaryImportFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvxExtension30Fn {} + NvxBinaryImportFn { + create_cu_module_nvx: unsafe { + unsafe extern "system" fn create_cu_module_nvx( + _device: Device, + _p_create_info: *const CuModuleCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_module: *mut CuModuleNVX, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_cu_module_nvx))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuModuleNVX\0"); + let val = _f(cname); + if val.is_null() { + create_cu_module_nvx + } else { + ::std::mem::transmute(val) + } + }, + create_cu_function_nvx: unsafe { + unsafe extern "system" fn create_cu_function_nvx( + _device: Device, + _p_create_info: *const CuFunctionCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_function: *mut CuFunctionNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_cu_function_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuFunctionNVX\0"); + let val = _f(cname); + if val.is_null() { + create_cu_function_nvx + } else { + ::std::mem::transmute(val) + } + }, + destroy_cu_module_nvx: unsafe { + unsafe extern "system" fn destroy_cu_module_nvx( + _device: Device, + _module: CuModuleNVX, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cu_module_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuModuleNVX\0"); + let val = _f(cname); + if val.is_null() { + destroy_cu_module_nvx + } else { + ::std::mem::transmute(val) + } + }, + destroy_cu_function_nvx: unsafe { + unsafe extern "system" fn destroy_cu_function_nvx( + _device: Device, + _function: CuFunctionNVX, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cu_function_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuFunctionNVX\0"); + let val = _f(cname); + if val.is_null() { + destroy_cu_function_nvx + } else { + ::std::mem::transmute(val) + } + }, + cmd_cu_launch_kernel_nvx: unsafe { + unsafe extern "system" fn cmd_cu_launch_kernel_nvx( + _command_buffer: CommandBuffer, + _p_launch_info: *const CuLaunchInfoNVX, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_cu_launch_kernel_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCuLaunchKernelNVX\0"); + let val = _f(cname); + if val.is_null() { + cmd_cu_launch_kernel_nvx + } else { + ::std::mem::transmute(val) + } + }, + } } + #[doc = ""] + pub unsafe fn create_cu_module_nvx( + &self, + device: Device, + p_create_info: *const CuModuleCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_module: *mut CuModuleNVX, + ) -> Result { + (self.create_cu_module_nvx)(device, p_create_info, p_allocator, p_module) + } + #[doc = ""] + pub unsafe fn create_cu_function_nvx( + &self, + device: Device, + p_create_info: *const CuFunctionCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_function: *mut CuFunctionNVX, + ) -> Result { + (self.create_cu_function_nvx)(device, p_create_info, p_allocator, p_function) + } + #[doc = ""] + pub unsafe fn destroy_cu_module_nvx( + &self, + device: Device, + module: CuModuleNVX, + p_allocator: *const AllocationCallbacks, + ) { + (self.destroy_cu_module_nvx)(device, module, p_allocator) + } + #[doc = ""] + pub unsafe fn destroy_cu_function_nvx( + &self, + device: Device, + function: CuFunctionNVX, + p_allocator: *const AllocationCallbacks, + ) { + (self.destroy_cu_function_nvx)(device, function, p_allocator) + } + #[doc = ""] + pub unsafe fn cmd_cu_launch_kernel_nvx( + &self, + command_buffer: CommandBuffer, + p_launch_info: *const CuLaunchInfoNVX, + ) { + (self.cmd_cu_launch_kernel_nvx)(command_buffer, p_launch_info) + } +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl StructureType { + pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1_000_029_000); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl StructureType { + pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1_000_029_001); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl StructureType { + pub const CU_LAUNCH_INFO_NVX: Self = Self(1_000_029_002); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl ObjectType { + pub const CU_MODULE_NVX: Self = Self(1_000_029_000); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl ObjectType { + pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl DebugReportObjectTypeEXT { + pub const CU_MODULE_NVX: Self = Self(1_000_029_000); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl DebugReportObjectTypeEXT { + pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001); } impl NvxImageViewHandleFn { pub fn name() -> &'static ::std::ffi::CStr { @@ -4037,6 +4126,25 @@ impl StructureType { impl VideoCodecOperationFlagsKHR { pub const ENCODE_H264_EXT: Self = Self(0b1_0000_0000_0000_0000); } +impl ExtVideoEncodeH265Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_encode_h265\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtVideoEncodeH265Fn {} +unsafe impl Send for ExtVideoEncodeH265Fn {} +unsafe impl Sync for ExtVideoEncodeH265Fn {} +impl ExtVideoEncodeH265Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtVideoEncodeH265Fn {} + } +} impl ExtVideoDecodeH264Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_decode_h264\0") @@ -4223,6 +4331,14 @@ impl AmdExtension45Fn { AmdExtension45Fn {} } } +#[doc = "Generated from 'VK_AMD_extension_45'"] +impl PipelineCreateFlags { + pub const RESERVED_21_AMD: Self = Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_AMD_extension_45'"] +impl PipelineCreateFlags { + pub const RESERVED_22_AMD: Self = Self(0b100_0000_0000_0000_0000_0000); +} impl AmdExtension46Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_46\0") @@ -13552,7 +13668,7 @@ impl StructureType { } #[doc = "Generated from 'VK_NV_shading_rate_image'"] impl ImageLayout { - pub const SHADING_RATE_OPTIMAL_NV: Self = Self(1_000_164_003); + pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR; } #[doc = "Generated from 'VK_NV_shading_rate_image'"] impl DynamicState { @@ -13560,15 +13676,15 @@ impl DynamicState { } #[doc = "Generated from 'VK_NV_shading_rate_image'"] impl AccessFlags { - pub const SHADING_RATE_IMAGE_READ_NV: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR; } #[doc = "Generated from 'VK_NV_shading_rate_image'"] impl ImageUsageFlags { - pub const SHADING_RATE_IMAGE_NV: Self = Self(0b1_0000_0000); + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; } #[doc = "Generated from 'VK_NV_shading_rate_image'"] impl PipelineStageFlags { - pub const SHADING_RATE_IMAGE_NV: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; } #[doc = "Generated from 'VK_NV_shading_rate_image'"] impl StructureType { @@ -15056,7 +15172,7 @@ impl ExtCalibratedTimestampsFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_calibrated_timestamps\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn( @@ -17237,7 +17353,7 @@ impl KhrFragmentShadingRateFn { } #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] impl ImageLayout { - pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self::SHADING_RATE_OPTIMAL_NV; + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_164_003); } #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] impl DynamicState { @@ -17265,15 +17381,16 @@ impl StructureType { } #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] impl AccessFlags { - pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self = Self::SHADING_RATE_IMAGE_READ_NV; + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self = + Self(0b1000_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] impl ImageUsageFlags { - pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self::SHADING_RATE_IMAGE_NV; + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b1_0000_0000); } #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] impl PipelineStageFlags { - pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self::SHADING_RATE_IMAGE_NV; + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] impl FormatFeatureFlags { @@ -17861,7 +17978,7 @@ impl ExtValidationFeaturesFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_features\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 4u32; + pub const SPEC_VERSION: u32 = 5u32; } #[derive(Clone)] pub struct ExtValidationFeaturesFn {} @@ -18122,25 +18239,38 @@ impl StructureType { pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self = Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; } -impl ExtExtension255Fn { +impl ExtProvokingVertexFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_255\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_provoking_vertex\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension255Fn {} -unsafe impl Send for ExtExtension255Fn {} -unsafe impl Sync for ExtExtension255Fn {} -impl ExtExtension255Fn { +pub struct ExtProvokingVertexFn {} +unsafe impl Send for ExtProvokingVertexFn {} +unsafe impl Sync for ExtProvokingVertexFn {} +impl ExtProvokingVertexFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension255Fn {} + ExtProvokingVertexFn {} } } +#[doc = "Generated from 'VK_EXT_provoking_vertex'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1_000_254_000); +} +#[doc = "Generated from 'VK_EXT_provoking_vertex'"] +impl StructureType { + pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: Self = + Self(1_000_254_001); +} +#[doc = "Generated from 'VK_EXT_provoking_vertex'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: Self = Self(1_000_254_002); +} impl ExtFullScreenExclusiveFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_full_screen_exclusive\0") @@ -20997,24 +21127,136 @@ impl KhrExtension299Fn { KhrExtension299Fn {} } } -impl KhrExtension300Fn { +#[doc = "Generated from 'VK_KHR_extension_299'"] +impl MemoryHeapFlags { + pub const RESERVED_2_KHR: Self = Self(0b100); +} +#[doc = "Generated from 'VK_KHR_extension_299'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_1_KHR: Self = Self::RESERVED_1_EXT; +} +#[doc = "Generated from 'VK_KHR_extension_299'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_2_KHR: Self = Self(0b100); +} +impl KhrVideoEncodeQueueFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_300\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_video_encode_queue\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_encode_info: *const VideoEncodeInfoKHR, +); #[derive(Clone)] -pub struct KhrExtension300Fn {} -unsafe impl Send for KhrExtension300Fn {} -unsafe impl Sync for KhrExtension300Fn {} -impl KhrExtension300Fn { +pub struct KhrVideoEncodeQueueFn { + pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR, +} +unsafe impl Send for KhrVideoEncodeQueueFn {} +unsafe impl Sync for KhrVideoEncodeQueueFn {} +impl KhrVideoEncodeQueueFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension300Fn {} + KhrVideoEncodeQueueFn { + cmd_encode_video_khr: unsafe { + unsafe extern "system" fn cmd_encode_video_khr( + _command_buffer: CommandBuffer, + _p_encode_info: *const VideoEncodeInfoKHR, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_encode_video_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEncodeVideoKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_encode_video_khr + } else { + ::std::mem::transmute(val) + } + }, + } } + #[doc = ""] + pub unsafe fn cmd_encode_video_khr( + &self, + command_buffer: CommandBuffer, + p_encode_info: *const VideoEncodeInfoKHR, + ) { + (self.cmd_encode_video_khr)(command_buffer, p_encode_info) + } +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl PipelineStageFlags2KHR { + pub const VIDEO_ENCODE: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl AccessFlags2KHR { + pub const VIDEO_ENCODE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl AccessFlags2KHR { + pub const VIDEO_ENCODE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl StructureType { + pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl StructureType { + pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl QueueFlags { + pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl BufferUsageFlags { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b1000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl BufferUsageFlags { + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageUsageFlags { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageUsageFlags { + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageUsageFlags { + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags { + pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags { + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageLayout { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageLayout { + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageLayout { + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl QueryType { + pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000); } impl NvDeviceDiagnosticsConfigFn { pub fn name() -> &'static ::std::ffi::CStr { @@ -21199,10 +21441,6 @@ impl KhrExtension309Fn { KhrExtension309Fn {} } } -#[doc = "Generated from 'VK_KHR_extension_309'"] -impl MemoryHeapFlags { - pub const RESERVED_2_KHR: Self = Self(0b100); -} impl QcomExtension310Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_310\0") @@ -21852,6 +22090,14 @@ impl AmdExtension319Fn { AmdExtension319Fn {} } } +#[doc = "Generated from 'VK_AMD_extension_319'"] +impl DescriptorSetLayoutCreateFlags { + pub const RESERVED_3_AMD: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_AMD_extension_319'"] +impl PipelineLayoutCreateFlags { + pub const RESERVED_0_AMD: Self = Self(0b1); +} impl AmdExtension320Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_320\0") @@ -21890,6 +22136,14 @@ impl AmdExtension321Fn { AmdExtension321Fn {} } } +#[doc = "Generated from 'VK_AMD_extension_321'"] +impl PipelineCreateFlags { + pub const RESERVED_23_AMD: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_AMD_extension_321'"] +impl PipelineCreateFlags { + pub const RESERVED_10_AMD: Self = Self(0b100_0000_0000); +} impl AmdExtension322Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_322\0") @@ -21928,25 +22182,30 @@ impl AmdExtension323Fn { AmdExtension323Fn {} } } -impl KhrExtension324Fn { +impl KhrShaderSubgroupUniformControlFlowFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_324\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_subgroup_uniform_control_flow\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct KhrExtension324Fn {} -unsafe impl Send for KhrExtension324Fn {} -unsafe impl Sync for KhrExtension324Fn {} -impl KhrExtension324Fn { +pub struct KhrShaderSubgroupUniformControlFlowFn {} +unsafe impl Send for KhrShaderSubgroupUniformControlFlowFn {} +unsafe impl Sync for KhrShaderSubgroupUniformControlFlowFn {} +impl KhrShaderSubgroupUniformControlFlowFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension324Fn {} + KhrShaderSubgroupUniformControlFlowFn {} } } +#[doc = "Generated from 'VK_KHR_shader_subgroup_uniform_control_flow'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: Self = + Self(1_000_323_000); +} impl KhrExtension325Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_325\0") @@ -22223,7 +22482,7 @@ impl QcomRotatedCopyCommandsFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_rotated_copy_commands\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] pub struct QcomRotatedCopyCommandsFn {} @@ -22920,10 +23179,6 @@ impl KhrExtension350Fn { KhrExtension350Fn {} } } -#[doc = "Generated from 'VK_KHR_extension_350'"] -impl PipelineCacheCreateFlags { - pub const RESERVED_2_EXT: Self = Self(0b100); -} impl NvExtension351Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_351\0") @@ -23598,6 +23853,19 @@ impl HuaweiExtension371Fn { HuaweiExtension371Fn {} } } +#[doc = "Generated from 'VK_HUAWEI_extension_371'"] +impl AccessFlags2KHR { + pub const RESERVED_39_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_extension_371'"] +impl ImageUsageFlags { + pub const RESERVED_18_HUAWEI: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_extension_371'"] +impl PipelineStageFlags2KHR { + pub const RESERVED_40_HUAWEI: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} impl NvExtension372Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_372\0") @@ -23618,12 +23886,12 @@ impl NvExtension372Fn { } } #[doc = "Generated from 'VK_NV_extension_372'"] -impl BufferCreateFlags { - pub const RESERVED_5_NV: Self = Self(0b10_0000); +impl MemoryPropertyFlags { + pub const RESERVED_8_NV: Self = Self(0b1_0000_0000); } #[doc = "Generated from 'VK_NV_extension_372'"] -impl ImageCreateFlags { - pub const RESERVED_15_NV: Self = Self(0b1000_0000_0000_0000); +impl ExternalMemoryHandleTypeFlags { + pub const RESERVED_12_NV: Self = Self(0b1_0000_0000_0000); } impl NvExtension373Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -23671,6 +23939,14 @@ impl ExternalFenceHandleTypeFlags { impl ExternalFenceHandleTypeFlags { pub const RESERVED_5_NV: Self = Self(0b10_0000); } +#[doc = "Generated from 'VK_NV_extension_374'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const RESERVED_5_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_NV_extension_374'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const RESERVED_6_NV: Self = Self(0b100_0000); +} impl NvExtension375Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_375\0") @@ -23691,12 +23967,8 @@ impl NvExtension375Fn { } } #[doc = "Generated from 'VK_NV_extension_375'"] -impl ExternalSemaphoreHandleTypeFlags { - pub const RESERVED_5_NV: Self = Self(0b10_0000); -} -#[doc = "Generated from 'VK_NV_extension_375'"] -impl ExternalSemaphoreHandleTypeFlags { - pub const RESERVED_6_NV: Self = Self(0b100_0000); +impl ExternalMemoryHandleTypeFlags { + pub const RESERVED_13_NV: Self = Self(0b10_0000_0000_0000); } impl ExtExtension376Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -23736,24 +24008,202 @@ impl ExtExtension377Fn { ExtExtension377Fn {} } } -impl NvExtension378Fn { +impl ExtExtendedDynamicState2Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_378\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extended_dynamic_state2\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPatchControlPointsEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, patch_control_points: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizerDiscardEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, rasterizer_discard_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBiasEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bias_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLogicOpEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op: LogicOp); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPrimitiveRestartEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_restart_enable: Bool32); #[derive(Clone)] -pub struct NvExtension378Fn {} -unsafe impl Send for NvExtension378Fn {} -unsafe impl Sync for NvExtension378Fn {} -impl NvExtension378Fn { +pub struct ExtExtendedDynamicState2Fn { + pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT, + pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnableEXT, + pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnableEXT, + pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT, + pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnableEXT, +} +unsafe impl Send for ExtExtendedDynamicState2Fn {} +unsafe impl Sync for ExtExtendedDynamicState2Fn {} +impl ExtExtendedDynamicState2Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension378Fn {} + ExtExtendedDynamicState2Fn { + cmd_set_patch_control_points_ext: unsafe { + unsafe extern "system" fn cmd_set_patch_control_points_ext( + _command_buffer: CommandBuffer, + _patch_control_points: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_patch_control_points_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPatchControlPointsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_patch_control_points_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterizer_discard_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext( + _command_buffer: CommandBuffer, + _rasterizer_discard_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterizer_discard_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizerDiscardEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterizer_discard_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bias_enable_ext( + _command_buffer: CommandBuffer, + _depth_bias_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bias_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBiasEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_ext( + _command_buffer: CommandBuffer, + _logic_op: LogicOp, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_restart_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_primitive_restart_enable_ext( + _command_buffer: CommandBuffer, + _primitive_restart_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_restart_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveRestartEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_restart_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + } } + #[doc = ""] + pub unsafe fn cmd_set_patch_control_points_ext( + &self, + command_buffer: CommandBuffer, + patch_control_points: u32, + ) { + (self.cmd_set_patch_control_points_ext)(command_buffer, patch_control_points) + } + #[doc = ""] + pub unsafe fn cmd_set_rasterizer_discard_enable_ext( + &self, + command_buffer: CommandBuffer, + rasterizer_discard_enable: Bool32, + ) { + (self.cmd_set_rasterizer_discard_enable_ext)(command_buffer, rasterizer_discard_enable) + } + #[doc = ""] + pub unsafe fn cmd_set_depth_bias_enable_ext( + &self, + command_buffer: CommandBuffer, + depth_bias_enable: Bool32, + ) { + (self.cmd_set_depth_bias_enable_ext)(command_buffer, depth_bias_enable) + } + #[doc = ""] + pub unsafe fn cmd_set_logic_op_ext(&self, command_buffer: CommandBuffer, logic_op: LogicOp) { + (self.cmd_set_logic_op_ext)(command_buffer, logic_op) + } + #[doc = ""] + pub unsafe fn cmd_set_primitive_restart_enable_ext( + &self, + command_buffer: CommandBuffer, + primitive_restart_enable: Bool32, + ) { + (self.cmd_set_primitive_restart_enable_ext)(command_buffer, primitive_restart_enable) + } +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1_000_377_000); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl DynamicState { + pub const PATCH_CONTROL_POINTS_EXT: Self = Self(1_000_377_000); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl DynamicState { + pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self(1_000_377_001); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl DynamicState { + pub const DEPTH_BIAS_ENABLE_EXT: Self = Self(1_000_377_002); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl DynamicState { + pub const LOGIC_OP_EXT: Self = Self(1_000_377_003); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl DynamicState { + pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self(1_000_377_004); } impl QnxScreenSurfaceFn { pub fn name() -> &'static ::std::ffi::CStr { @@ -24087,25 +24537,33 @@ impl ExtExtension388Fn { ExtExtension388Fn {} } } -impl ExtExtension389Fn { +impl ExtGlobalPriorityQueryFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_389\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_global_priority_query\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension389Fn {} -unsafe impl Send for ExtExtension389Fn {} -unsafe impl Sync for ExtExtension389Fn {} -impl ExtExtension389Fn { +pub struct ExtGlobalPriorityQueryFn {} +unsafe impl Send for ExtGlobalPriorityQueryFn {} +unsafe impl Sync for ExtGlobalPriorityQueryFn {} +impl ExtGlobalPriorityQueryFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension389Fn {} + ExtGlobalPriorityQueryFn {} } } +#[doc = "Generated from 'VK_EXT_global_priority_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self = Self(1_000_388_000); +} +#[doc = "Generated from 'VK_EXT_global_priority_query'"] +impl StructureType { + pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self = Self(1_000_388_001); +} impl ExtExtension390Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_390\0") @@ -24201,3 +24659,421 @@ impl ExtExtension394Fn { ExtExtension394Fn {} } } +impl KhrExtension395Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_395\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension395Fn {} +unsafe impl Send for KhrExtension395Fn {} +unsafe impl Sync for KhrExtension395Fn {} +impl KhrExtension395Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension395Fn {} + } +} +impl KhrExtension396Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_396\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension396Fn {} +unsafe impl Send for KhrExtension396Fn {} +unsafe impl Sync for KhrExtension396Fn {} +impl KhrExtension396Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension396Fn {} + } +} +impl NvExtension397Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_397\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension397Fn {} +unsafe impl Send for NvExtension397Fn {} +unsafe impl Sync for NvExtension397Fn {} +impl NvExtension397Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension397Fn {} + } +} +impl NvExtension398Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_398\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension398Fn {} +unsafe impl Send for NvExtension398Fn {} +unsafe impl Sync for NvExtension398Fn {} +impl NvExtension398Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension398Fn {} + } +} +impl JuiceExtension399Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_JUICE_extension_399\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct JuiceExtension399Fn {} +unsafe impl Send for JuiceExtension399Fn {} +unsafe impl Sync for JuiceExtension399Fn {} +impl JuiceExtension399Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + JuiceExtension399Fn {} + } +} +impl JuiceExtension400Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_JUICE_extension_400\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct JuiceExtension400Fn {} +unsafe impl Send for JuiceExtension400Fn {} +unsafe impl Sync for JuiceExtension400Fn {} +impl JuiceExtension400Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + JuiceExtension400Fn {} + } +} +impl KhrExtension401Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_401\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension401Fn {} +unsafe impl Send for KhrExtension401Fn {} +unsafe impl Sync for KhrExtension401Fn {} +impl KhrExtension401Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension401Fn {} + } +} +impl FbExtension402Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FB_extension_402\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension402Fn {} +unsafe impl Send for FbExtension402Fn {} +unsafe impl Sync for FbExtension402Fn {} +impl FbExtension402Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + FbExtension402Fn {} + } +} +impl FbExtension403Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FB_extension_403\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension403Fn {} +unsafe impl Send for FbExtension403Fn {} +unsafe impl Sync for FbExtension403Fn {} +impl FbExtension403Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + FbExtension403Fn {} + } +} +impl FbExtension404Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FB_extension_404\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension404Fn {} +unsafe impl Send for FbExtension404Fn {} +unsafe impl Sync for FbExtension404Fn {} +impl FbExtension404Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + FbExtension404Fn {} + } +} +impl HuaweiExtension405Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_405\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension405Fn {} +unsafe impl Send for HuaweiExtension405Fn {} +unsafe impl Sync for HuaweiExtension405Fn {} +impl HuaweiExtension405Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + HuaweiExtension405Fn {} + } +} +impl HuaweiExtension406Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_406\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension406Fn {} +unsafe impl Send for HuaweiExtension406Fn {} +unsafe impl Sync for HuaweiExtension406Fn {} +impl HuaweiExtension406Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + HuaweiExtension406Fn {} + } +} +impl GgpExtension407Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_407\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension407Fn {} +unsafe impl Send for GgpExtension407Fn {} +unsafe impl Sync for GgpExtension407Fn {} +impl GgpExtension407Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GgpExtension407Fn {} + } +} +impl GgpExtension408Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_408\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension408Fn {} +unsafe impl Send for GgpExtension408Fn {} +unsafe impl Sync for GgpExtension408Fn {} +impl GgpExtension408Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GgpExtension408Fn {} + } +} +impl GgpExtension409Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_409\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension409Fn {} +unsafe impl Send for GgpExtension409Fn {} +unsafe impl Sync for GgpExtension409Fn {} +impl GgpExtension409Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GgpExtension409Fn {} + } +} +impl GgpExtension410Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_410\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension410Fn {} +unsafe impl Send for GgpExtension410Fn {} +unsafe impl Sync for GgpExtension410Fn {} +impl GgpExtension410Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GgpExtension410Fn {} + } +} +impl GgpExtension411Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_411\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension411Fn {} +unsafe impl Send for GgpExtension411Fn {} +unsafe impl Sync for GgpExtension411Fn {} +impl GgpExtension411Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GgpExtension411Fn {} + } +} +impl NvExtension412Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_412\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension412Fn {} +unsafe impl Send for NvExtension412Fn {} +unsafe impl Sync for NvExtension412Fn {} +impl NvExtension412Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension412Fn {} + } +} +impl NvExtension413Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_413\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension413Fn {} +unsafe impl Send for NvExtension413Fn {} +unsafe impl Sync for NvExtension413Fn {} +impl NvExtension413Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension413Fn {} + } +} +impl NvExtension414Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_414\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension414Fn {} +unsafe impl Send for NvExtension414Fn {} +unsafe impl Sync for NvExtension414Fn {} +impl NvExtension414Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension414Fn {} + } +} +impl HuaweiExtension415Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_415\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension415Fn {} +unsafe impl Send for HuaweiExtension415Fn {} +unsafe impl Sync for HuaweiExtension415Fn {} +impl HuaweiExtension415Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + HuaweiExtension415Fn {} + } +} +impl ArmExtension416Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_416\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension416Fn {} +unsafe impl Send for ArmExtension416Fn {} +unsafe impl Sync for ArmExtension416Fn {} +impl ArmExtension416Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ArmExtension416Fn {} + } +} diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index f5ac258..9d10a96 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit f5ac258209dc535973aa527bf3c11ba7063ba1b0 +Subproject commit 9d10a96f2d57c3c37e167f2e73c9a31ac2e51fa5