From 5008a178afedc20b6d4c492281d2bd18f1a88b2f Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Fri, 8 May 2026 10:12:11 +0200 Subject: [PATCH 1/2] Update Vulkan-Headers to 1.4.351 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/extensions_generated.rs | 327 ++++++++++ ash/src/vk/aliases.rs | 3 + ash/src/vk/bitflags.rs | 14 + ash/src/vk/const_debugs.rs | 257 +++++++- ash/src/vk/definitions.rs | 1064 ++++++++++++++++++++++++++++++- ash/src/vk/enums.rs | 138 +++- ash/src/vk/extensions.rs | 195 +++++- generator/Vulkan-Headers | 2 +- 10 files changed, 1951 insertions(+), 53 deletions(-) diff --git a/Changelog.md b/Changelog.md index e681ccc98..9bf5cc095 100644 --- a/Changelog.md +++ b/Changelog.md @@ -10,7 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Added `push()` method to all root structs to insert a single extension-struct in the pointer chain. (#909) -- Update Vulkan-Headers to 1.4.350 (#910, #951) +- Update Vulkan-Headers to 1.4.351 (#910, #951, #1040) - Added `VK_KHR_get_display_properties2` instance extension (#932) - Added `VK_EXT_display_surface_counter` instance extension (#933) - Added `VK_EXT_display_control` display extension (#934) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 82729e9ce..4a398a77f 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.38.0+1.4.350" +version = "0.38.0+1.4.351" authors = [ "Maik Klein ", "Benjamin Saunders ", diff --git a/ash/src/extensions_generated.rs b/ash/src/extensions_generated.rs index b072ed225..aa98b56cc 100644 --- a/ash/src/extensions_generated.rs +++ b/ash/src/extensions_generated.rs @@ -237,6 +237,298 @@ pub mod amd { crate::vk::AMD_GPU_SHADER_INT16_SPEC_VERSION as SPEC_VERSION, }; } + #[doc = "VK_AMD_gpa_interface"] + pub mod gpa_interface { + use crate::vk::*; + use core::ffi::*; + pub use { + crate::vk::AMD_GPA_INTERFACE_NAME as NAME, + crate::vk::AMD_GPA_INTERFACE_SPEC_VERSION as SPEC_VERSION, + }; + #[doc = "VK_AMD_gpa_interface device-level functions"] + #[derive(Clone)] + pub struct Device { + pub(crate) fp: DeviceFn, + pub(crate) handle: crate::vk::Device, + } + impl Device { + pub fn load(instance: &crate::Instance, device: &crate::Device) -> Self { + let handle = device.handle; + let fp = DeviceFn::load(|name| unsafe { + core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + #[inline] + pub fn fp(&self) -> &DeviceFn { + &self.fp + } + #[inline] + pub fn device(&self) -> crate::vk::Device { + self.handle + } + } + #[derive(Clone)] + #[doc = "Raw VK_AMD_gpa_interface device-level function pointers"] + pub struct DeviceFn { + pub create_gpa_session_amd: PFN_vkCreateGpaSessionAMD, + pub destroy_gpa_session_amd: PFN_vkDestroyGpaSessionAMD, + pub set_gpa_device_clock_mode_amd: PFN_vkSetGpaDeviceClockModeAMD, + pub get_gpa_device_clock_info_amd: PFN_vkGetGpaDeviceClockInfoAMD, + pub cmd_begin_gpa_session_amd: PFN_vkCmdBeginGpaSessionAMD, + pub cmd_end_gpa_session_amd: PFN_vkCmdEndGpaSessionAMD, + pub cmd_begin_gpa_sample_amd: PFN_vkCmdBeginGpaSampleAMD, + pub cmd_end_gpa_sample_amd: PFN_vkCmdEndGpaSampleAMD, + pub get_gpa_session_status_amd: PFN_vkGetGpaSessionStatusAMD, + pub get_gpa_session_results_amd: PFN_vkGetGpaSessionResultsAMD, + pub reset_gpa_session_amd: PFN_vkResetGpaSessionAMD, + pub cmd_copy_gpa_session_results_amd: PFN_vkCmdCopyGpaSessionResultsAMD, + } + unsafe impl Send for DeviceFn {} + unsafe impl Sync for DeviceFn {} + impl DeviceFn { + pub fn load *const c_void>(mut f: F) -> Self { + Self::load_erased(&mut f) + } + fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self { + Self { + create_gpa_session_amd: unsafe { + unsafe extern "system" fn create_gpa_session_amd( + _device: crate::vk::Device, + _p_create_info: *const GpaSessionCreateInfoAMD<'_>, + _p_allocator: *const AllocationCallbacks, + _p_gpa_session: *mut GpaSessionAMD, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_gpa_session_amd) + )) + } + let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + create_gpa_session_amd + } else { + ::core::mem::transmute(val) + } + }, + destroy_gpa_session_amd: unsafe { + unsafe extern "system" fn destroy_gpa_session_amd( + _device: crate::vk::Device, + _gpa_session: GpaSessionAMD, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_gpa_session_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkDestroyGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + destroy_gpa_session_amd + } else { + ::core::mem::transmute(val) + } + }, + set_gpa_device_clock_mode_amd: unsafe { + unsafe extern "system" fn set_gpa_device_clock_mode_amd( + _device: crate::vk::Device, + _p_info: *mut GpaDeviceClockModeInfoAMD<'_>, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_gpa_device_clock_mode_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkSetGpaDeviceClockModeAMD\0"); + let val = _f(cname); + if val.is_null() { + set_gpa_device_clock_mode_amd + } else { + ::core::mem::transmute(val) + } + }, + get_gpa_device_clock_info_amd: unsafe { + unsafe extern "system" fn get_gpa_device_clock_info_amd( + _device: crate::vk::Device, + _p_info: *mut GpaDeviceGetClockInfoAMD<'_>, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_gpa_device_clock_info_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkGetGpaDeviceClockInfoAMD\0"); + let val = _f(cname); + if val.is_null() { + get_gpa_device_clock_info_amd + } else { + ::core::mem::transmute(val) + } + }, + cmd_begin_gpa_session_amd: unsafe { + unsafe extern "system" fn cmd_begin_gpa_session_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAMD, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_gpa_session_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_gpa_session_amd + } else { + ::core::mem::transmute(val) + } + }, + cmd_end_gpa_session_amd: unsafe { + unsafe extern "system" fn cmd_end_gpa_session_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAMD, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_gpa_session_amd) + )) + } + let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_gpa_session_amd + } else { + ::core::mem::transmute(val) + } + }, + cmd_begin_gpa_sample_amd: unsafe { + unsafe extern "system" fn cmd_begin_gpa_sample_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAMD, + _p_gpa_sample_begin_info: *const GpaSampleBeginInfoAMD<'_>, + _p_sample_id: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_gpa_sample_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_gpa_sample_amd + } else { + ::core::mem::transmute(val) + } + }, + cmd_end_gpa_sample_amd: unsafe { + unsafe extern "system" fn cmd_end_gpa_sample_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAMD, + _sample_id: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_gpa_sample_amd) + )) + } + let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_gpa_sample_amd + } else { + ::core::mem::transmute(val) + } + }, + get_gpa_session_status_amd: unsafe { + unsafe extern "system" fn get_gpa_session_status_amd( + _device: crate::vk::Device, + _gpa_session: GpaSessionAMD, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_gpa_session_status_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionStatusAMD\0"); + let val = _f(cname); + if val.is_null() { + get_gpa_session_status_amd + } else { + ::core::mem::transmute(val) + } + }, + get_gpa_session_results_amd: unsafe { + unsafe extern "system" fn get_gpa_session_results_amd( + _device: crate::vk::Device, + _gpa_session: GpaSessionAMD, + _sample_id: u32, + _p_size_in_bytes: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_gpa_session_results_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionResultsAMD\0"); + let val = _f(cname); + if val.is_null() { + get_gpa_session_results_amd + } else { + ::core::mem::transmute(val) + } + }, + reset_gpa_session_amd: unsafe { + unsafe extern "system" fn reset_gpa_session_amd( + _device: crate::vk::Device, + _gpa_session: GpaSessionAMD, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(reset_gpa_session_amd) + )) + } + let cname = CStr::from_bytes_with_nul_unchecked(b"vkResetGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + reset_gpa_session_amd + } else { + ::core::mem::transmute(val) + } + }, + cmd_copy_gpa_session_results_amd: unsafe { + unsafe extern "system" fn cmd_copy_gpa_session_results_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAMD, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_gpa_session_results_amd) + )) + } + let cname = + CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyGpaSessionResultsAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_gpa_session_results_amd + } else { + ::core::mem::transmute(val) + } + }, + } + } + } + } #[doc = "VK_AMD_mixed_attachment_samples"] pub mod mixed_attachment_samples { pub use { @@ -6290,6 +6582,13 @@ pub mod ext { crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION as SPEC_VERSION, }; } + #[doc = "VK_EXT_shader_split_barrier"] + pub mod shader_split_barrier { + pub use { + crate::vk::EXT_SHADER_SPLIT_BARRIER_NAME as NAME, + crate::vk::EXT_SHADER_SPLIT_BARRIER_SPEC_VERSION as SPEC_VERSION, + }; + } #[doc = "VK_EXT_metal_objects"] pub mod metal_objects { use crate::vk::*; @@ -20594,6 +20893,13 @@ pub mod khr { crate::vk::KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION as SPEC_VERSION, }; } + #[doc = "VK_KHR_opacity_micromap"] + pub mod opacity_micromap { + pub use { + crate::vk::KHR_OPACITY_MICROMAP_NAME as NAME, + crate::vk::KHR_OPACITY_MICROMAP_SPEC_VERSION as SPEC_VERSION, + }; + } #[doc = "VK_KHR_maintenance10"] pub mod maintenance10 { use crate::vk::*; @@ -24592,6 +24898,13 @@ pub mod qcom { crate::vk::QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION as SPEC_VERSION, }; } + #[doc = "VK_QCOM_elapsed_timer_query"] + pub mod elapsed_timer_query { + pub use { + crate::vk::QCOM_ELAPSED_TIMER_QUERY_NAME as NAME, + crate::vk::QCOM_ELAPSED_TIMER_QUERY_SPEC_VERSION as SPEC_VERSION, + }; + } #[doc = "VK_QCOM_render_pass_transform"] pub mod render_pass_transform { pub use { @@ -24673,6 +24986,20 @@ pub mod qcom { } } } + #[doc = "VK_QCOM_image_processing3"] + pub mod image_processing3 { + pub use { + crate::vk::QCOM_IMAGE_PROCESSING3_NAME as NAME, + crate::vk::QCOM_IMAGE_PROCESSING3_SPEC_VERSION as SPEC_VERSION, + }; + } + #[doc = "VK_QCOM_shader_multiple_wait_queues"] + pub mod shader_multiple_wait_queues { + pub use { + crate::vk::QCOM_SHADER_MULTIPLE_WAIT_QUEUES_NAME as NAME, + crate::vk::QCOM_SHADER_MULTIPLE_WAIT_QUEUES_SPEC_VERSION as SPEC_VERSION, + }; + } #[doc = "VK_QCOM_tile_shading"] pub mod tile_shading { use crate::vk::*; diff --git a/ash/src/vk/aliases.rs b/ash/src/vk/aliases.rs index 9ccc4489d..88c99bd24 100644 --- a/ash/src/vk/aliases.rs +++ b/ash/src/vk/aliases.rs @@ -52,6 +52,8 @@ pub type LineRasterizationModeKHR = LineRasterizationMode; pub type LineRasterizationModeEXT = LineRasterizationMode; pub type PipelineRobustnessBufferBehaviorEXT = PipelineRobustnessBufferBehavior; pub type PipelineRobustnessImageBehaviorEXT = PipelineRobustnessImageBehavior; +pub type OpacityMicromapFormatEXT = OpacityMicromapFormatKHR; +pub type OpacityMicromapSpecialIndexEXT = OpacityMicromapSpecialIndexKHR; pub type DeviceFaultVendorBinaryHeaderVersionEXT = DeviceFaultVendorBinaryHeaderVersionKHR; pub type ScopeNV = ScopeKHR; pub type ComponentTypeNV = ComponentTypeKHR; @@ -361,6 +363,7 @@ pub type ImageSubresource2KHR<'a> = ImageSubresource2<'a>; pub type ImageSubresource2EXT<'a> = ImageSubresource2<'a>; pub type SubresourceLayout2KHR<'a> = SubresourceLayout2<'a>; pub type SubresourceLayout2EXT<'a> = SubresourceLayout2<'a>; +pub type MicromapTriangleEXT = MicromapTriangleKHR; pub type PhysicalDevicePipelineRobustnessFeaturesEXT<'a> = PhysicalDevicePipelineRobustnessFeatures<'a>; pub type PipelineRobustnessCreateInfoEXT<'a> = PipelineRobustnessCreateInfo<'a>; diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index e83e9d46f..5d836180d 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1976,6 +1976,20 @@ impl SpirvResourceTypeFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GpaSqShaderStageFlagsAMD(pub(crate) Flags); +vk_bitflags_wrapped!(GpaSqShaderStageFlagsAMD, Flags); +impl GpaSqShaderStageFlagsAMD { + pub const PS: Self = Self(0b1); + pub const VS: Self = Self(0b10); + pub const GS: Self = Self(0b100); + pub const ES: Self = Self(0b1000); + pub const HS: Self = Self(0b1_0000); + pub const LS: Self = Self(0b10_0000); + pub const CS: Self = Self(0b100_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct AddressCommandFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(AddressCommandFlagsKHR, Flags); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 7d39ec102..ab9cb7731 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -93,12 +93,26 @@ impl fmt::Debug for AccelerationStructureMotionInstanceTypeNV { } } } +impl fmt::Debug for AccelerationStructureSerializedBlockTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let name = match *self { + Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for AccelerationStructureTypeKHR { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let name = match *self { Self::TOP_LEVEL => Some("TOP_LEVEL"), Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), Self::GENERIC => Some("GENERIC"), + Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"), _ => None, }; if let Some(x) = name { @@ -770,6 +784,14 @@ impl fmt::Debug for BufferUsageFlags2 { BufferUsageFlags2::DESCRIPTOR_HEAP_EXT.0, "DESCRIPTOR_HEAP_EXT", ), + ( + BufferUsageFlags2::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0, + "MICROMAP_BUILD_INPUT_READ_ONLY_EXT", + ), + ( + BufferUsageFlags2::MICROMAP_STORAGE_EXT.0, + "MICROMAP_STORAGE_EXT", + ), ( BufferUsageFlags2::CONDITIONAL_RENDERING_EXT.0, "CONDITIONAL_RENDERING_EXT", @@ -822,14 +844,6 @@ impl fmt::Debug for BufferUsageFlags2 { BufferUsageFlags2::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0, "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT", ), - ( - BufferUsageFlags2::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0, - "MICROMAP_BUILD_INPUT_READ_ONLY_EXT", - ), - ( - BufferUsageFlags2::MICROMAP_STORAGE_EXT.0, - "MICROMAP_STORAGE_EXT", - ), #[cfg(feature = "provisional")] ( BufferUsageFlags2::COMPRESSED_DATA_DGF1_AMDX.0, @@ -886,14 +900,6 @@ impl fmt::Debug for BuildAccelerationStructureFlagsKHR { "LOW_MEMORY", ), (BuildAccelerationStructureFlagsKHR::MOTION_NV.0, "MOTION_NV"), - ( - BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_UPDATE_EXT.0, - "ALLOW_OPACITY_MICROMAP_UPDATE_EXT", - ), - ( - BuildAccelerationStructureFlagsKHR::ALLOW_DISABLE_OPACITY_MICROMAPS_EXT.0, - "ALLOW_DISABLE_OPACITY_MICROMAPS_EXT", - ), ( BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT.0, "ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT", @@ -911,6 +917,18 @@ impl fmt::Debug for BuildAccelerationStructureFlagsKHR { BuildAccelerationStructureFlagsKHR::ALLOW_CLUSTER_OPACITY_MICROMAPS_NV.0, "ALLOW_CLUSTER_OPACITY_MICROMAPS_NV", ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_UPDATE.0, + "ALLOW_OPACITY_MICROMAP_UPDATE", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_DISABLE_OPACITY_MICROMAPS.0, + "ALLOW_DISABLE_OPACITY_MICROMAPS", + ), + ( + BuildAccelerationStructureFlagsKHR::MICROMAP_LOSSY.0, + "MICROMAP_LOSSY", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -3036,7 +3054,7 @@ impl fmt::Debug for FormatFeatureFlags { } impl fmt::Debug for FormatFeatureFlags2 { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_RADIUS_BUFFER_NV . 0 , "ACCELERATION_STRUCTURE_RADIUS_BUFFER_NV") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: TENSOR_SHADER_ARM . 0 , "TENSOR_SHADER_ARM") , (FormatFeatureFlags2 :: TENSOR_IMAGE_ALIASING_ARM . 0 , "TENSOR_IMAGE_ALIASING_ARM") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV") , (FormatFeatureFlags2 :: TENSOR_DATA_GRAPH_ARM . 0 , "TENSOR_DATA_GRAPH_ARM") , (FormatFeatureFlags2 :: COPY_IMAGE_INDIRECT_DST_KHR . 0 , "COPY_IMAGE_INDIRECT_DST_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_KHR . 0 , "VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_EMPHASIS_MAP_KHR . 0 , "VIDEO_ENCODE_EMPHASIS_MAP_KHR") , (FormatFeatureFlags2 :: DEPTH_COPY_ON_COMPUTE_QUEUE_KHR . 0 , "DEPTH_COPY_ON_COMPUTE_QUEUE_KHR") , (FormatFeatureFlags2 :: DEPTH_COPY_ON_TRANSFER_QUEUE_KHR . 0 , "DEPTH_COPY_ON_TRANSFER_QUEUE_KHR") , (FormatFeatureFlags2 :: STENCIL_COPY_ON_COMPUTE_QUEUE_KHR . 0 , "STENCIL_COPY_ON_COMPUTE_QUEUE_KHR") , (FormatFeatureFlags2 :: STENCIL_COPY_ON_TRANSFER_QUEUE_KHR . 0 , "STENCIL_COPY_ON_TRANSFER_QUEUE_KHR") , (FormatFeatureFlags2 :: DATA_GRAPH_OPTICAL_FLOW_IMAGE_ARM . 0 , "DATA_GRAPH_OPTICAL_FLOW_IMAGE_ARM") , (FormatFeatureFlags2 :: DATA_GRAPH_OPTICAL_FLOW_VECTOR_ARM . 0 , "DATA_GRAPH_OPTICAL_FLOW_VECTOR_ARM") , (FormatFeatureFlags2 :: DATA_GRAPH_OPTICAL_FLOW_COST_ARM . 0 , "DATA_GRAPH_OPTICAL_FLOW_COST_ARM") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: HOST_IMAGE_TRANSFER . 0 , "HOST_IMAGE_TRANSFER")] ; + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: BLOCK_MATCHING_SXD_QCOM . 0 , "BLOCK_MATCHING_SXD_QCOM") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_RADIUS_BUFFER_NV . 0 , "ACCELERATION_STRUCTURE_RADIUS_BUFFER_NV") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: TENSOR_SHADER_ARM . 0 , "TENSOR_SHADER_ARM") , (FormatFeatureFlags2 :: TENSOR_IMAGE_ALIASING_ARM . 0 , "TENSOR_IMAGE_ALIASING_ARM") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV") , (FormatFeatureFlags2 :: TENSOR_DATA_GRAPH_ARM . 0 , "TENSOR_DATA_GRAPH_ARM") , (FormatFeatureFlags2 :: COPY_IMAGE_INDIRECT_DST_KHR . 0 , "COPY_IMAGE_INDIRECT_DST_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_KHR . 0 , "VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_EMPHASIS_MAP_KHR . 0 , "VIDEO_ENCODE_EMPHASIS_MAP_KHR") , (FormatFeatureFlags2 :: DEPTH_COPY_ON_COMPUTE_QUEUE_KHR . 0 , "DEPTH_COPY_ON_COMPUTE_QUEUE_KHR") , (FormatFeatureFlags2 :: DEPTH_COPY_ON_TRANSFER_QUEUE_KHR . 0 , "DEPTH_COPY_ON_TRANSFER_QUEUE_KHR") , (FormatFeatureFlags2 :: STENCIL_COPY_ON_COMPUTE_QUEUE_KHR . 0 , "STENCIL_COPY_ON_COMPUTE_QUEUE_KHR") , (FormatFeatureFlags2 :: STENCIL_COPY_ON_TRANSFER_QUEUE_KHR . 0 , "STENCIL_COPY_ON_TRANSFER_QUEUE_KHR") , (FormatFeatureFlags2 :: DATA_GRAPH_OPTICAL_FLOW_IMAGE_ARM . 0 , "DATA_GRAPH_OPTICAL_FLOW_IMAGE_ARM") , (FormatFeatureFlags2 :: DATA_GRAPH_OPTICAL_FLOW_VECTOR_ARM . 0 , "DATA_GRAPH_OPTICAL_FLOW_VECTOR_ARM") , (FormatFeatureFlags2 :: DATA_GRAPH_OPTICAL_FLOW_COST_ARM . 0 , "DATA_GRAPH_OPTICAL_FLOW_COST_ARM") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: HOST_IMAGE_TRANSFER . 0 , "HOST_IMAGE_TRANSFER")] ; debug_flags(f, KNOWN, self.0) } } @@ -3166,12 +3184,12 @@ impl fmt::Debug for GeometryInstanceFlagsKHR { "FORCE_NO_OPAQUE", ), ( - GeometryInstanceFlagsKHR::FORCE_OPACITY_MICROMAP_2_STATE_EXT.0, - "FORCE_OPACITY_MICROMAP_2_STATE_EXT", + GeometryInstanceFlagsKHR::FORCE_OPACITY_MICROMAP_2_STATE.0, + "FORCE_OPACITY_MICROMAP_2_STATE", ), ( - GeometryInstanceFlagsKHR::DISABLE_OPACITY_MICROMAPS_EXT.0, - "DISABLE_OPACITY_MICROMAPS_EXT", + GeometryInstanceFlagsKHR::DISABLE_OPACITY_MICROMAPS.0, + "DISABLE_OPACITY_MICROMAPS", ), ]; debug_flags(f, KNOWN, self.0) @@ -3189,6 +3207,115 @@ impl fmt::Debug for GeometryTypeKHR { Self::DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX => { Some("DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX") } + Self::MICROMAP => Some("MICROMAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for GpaDeviceClockModeAMD { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::QUERY => Some("QUERY"), + Self::PROFILING => Some("PROFILING"), + Self::MIN_MEMORY => Some("MIN_MEMORY"), + Self::MIN_ENGINE => Some("MIN_ENGINE"), + Self::PEAK => Some("PEAK"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for GpaPerfBlockAMD { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let name = match *self { + Self::CPF => Some("CPF"), + Self::IA => Some("IA"), + Self::VGT => Some("VGT"), + Self::PA => Some("PA"), + Self::SC => Some("SC"), + Self::SPI => Some("SPI"), + Self::SQ => Some("SQ"), + Self::SX => Some("SX"), + Self::TA => Some("TA"), + Self::TD => Some("TD"), + Self::TCP => Some("TCP"), + Self::TCC => Some("TCC"), + Self::TCA => Some("TCA"), + Self::DB => Some("DB"), + Self::CB => Some("CB"), + Self::GDS => Some("GDS"), + Self::SRBM => Some("SRBM"), + Self::GRBM => Some("GRBM"), + Self::GRBM_SE => Some("GRBM_SE"), + Self::RLC => Some("RLC"), + Self::DMA => Some("DMA"), + Self::MC => Some("MC"), + Self::CPG => Some("CPG"), + Self::CPC => Some("CPC"), + Self::WD => Some("WD"), + Self::TCS => Some("TCS"), + Self::ATC => Some("ATC"), + Self::ATC_L2 => Some("ATC_L2"), + Self::MC_VM_L2 => Some("MC_VM_L2"), + Self::EA => Some("EA"), + Self::RPB => Some("RPB"), + Self::RMI => Some("RMI"), + Self::UMCCH => Some("UMCCH"), + Self::GE => Some("GE"), + Self::GL1A => Some("GL1A"), + Self::GL1C => Some("GL1C"), + Self::GL1CG => Some("GL1CG"), + Self::GL2A => Some("GL2A"), + Self::GL2C => Some("GL2C"), + Self::CHA => Some("CHA"), + Self::CHC => Some("CHC"), + Self::CHCG => Some("CHCG"), + Self::GUS => Some("GUS"), + Self::GCR => Some("GCR"), + Self::PH => Some("PH"), + Self::UTCL1 => Some("UTCL1"), + Self::GE_DIST => Some("GE_DIST"), + Self::GE_SE => Some("GE_SE"), + Self::DF_MALL => Some("DF_MALL"), + Self::SQ_WGP => Some("SQ_WGP"), + Self::PC => Some("PC"), + Self::GL1XA => Some("GL1XA"), + Self::GL1XC => Some("GL1XC"), + Self::WGS => Some("WGS"), + Self::EACPWD => Some("EACPWD"), + Self::EASE => Some("EASE"), + Self::RLCUSER => Some("RLCUSER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for GpaPerfBlockPropertiesFlagsAMD { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for GpaSampleTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let name = match *self { + Self::CUMULATIVE => Some("CUMULATIVE"), + Self::TRACE => Some("TRACE"), + Self::TIMING => Some("TIMING"), _ => None, }; if let Some(x) = name { @@ -3198,6 +3325,20 @@ impl fmt::Debug for GeometryTypeKHR { } } } +impl fmt::Debug for GpaSqShaderStageFlagsAMD { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GpaSqShaderStageFlagsAMD::PS.0, "PS"), + (GpaSqShaderStageFlagsAMD::VS.0, "VS"), + (GpaSqShaderStageFlagsAMD::GS.0, "GS"), + (GpaSqShaderStageFlagsAMD::ES.0, "ES"), + (GpaSqShaderStageFlagsAMD::HS.0, "HS"), + (GpaSqShaderStageFlagsAMD::LS.0, "LS"), + (GpaSqShaderStageFlagsAMD::CS.0, "CS"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for GraphicsPipelineLibraryFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -4048,7 +4189,7 @@ impl fmt::Debug for NeuralAcceleratorStatisticsModeARM { } } } -impl fmt::Debug for OpacityMicromapFormatEXT { +impl fmt::Debug for OpacityMicromapFormatKHR { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let name = match *self { Self::TYPE_2_STATE => Some("TYPE_2_STATE"), @@ -4062,7 +4203,7 @@ impl fmt::Debug for OpacityMicromapFormatEXT { } } } -impl fmt::Debug for OpacityMicromapSpecialIndexEXT { +impl fmt::Debug for OpacityMicromapSpecialIndexKHR { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let name = match *self { Self::FULLY_TRANSPARENT => Some("FULLY_TRANSPARENT"), @@ -4447,6 +4588,12 @@ impl fmt::Debug for PhysicalDeviceDataGraphProcessingEngineTypeARM { } } } +impl fmt::Debug for PhysicalDeviceGpaPropertiesFlagsAMD { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for PhysicalDeviceLayeredApiKHR { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let name = match *self { @@ -4663,15 +4810,15 @@ impl fmt::Debug for PipelineCreateFlags { PipelineCreateFlags::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT.0, "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT", ), - ( - PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_EXT.0, - "RAY_TRACING_OPACITY_MICROMAP_EXT", - ), #[cfg(feature = "provisional")] ( PipelineCreateFlags::RAY_TRACING_DISPLACEMENT_MICROMAP_NV.0, "RAY_TRACING_DISPLACEMENT_MICROMAP_NV", ), + ( + PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_KHR.0, + "RAY_TRACING_OPACITY_MICROMAP_KHR", + ), (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ( PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, @@ -4809,10 +4956,6 @@ impl fmt::Debug for PipelineCreateFlags2 { PipelineCreateFlags2::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0, "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT", ), - ( - PipelineCreateFlags2::RAY_TRACING_OPACITY_MICROMAP_EXT.0, - "RAY_TRACING_OPACITY_MICROMAP_EXT", - ), ( PipelineCreateFlags2::COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT.0, "COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT", @@ -4846,6 +4989,14 @@ impl fmt::Debug for PipelineCreateFlags2 { PipelineCreateFlags2::PER_LAYER_FRAGMENT_DENSITY_VALVE.0, "PER_LAYER_FRAGMENT_DENSITY_VALVE", ), + ( + PipelineCreateFlags2::RAY_TRACING_OPACITY_MICROMAP_KHR.0, + "RAY_TRACING_OPACITY_MICROMAP_KHR", + ), + ( + PipelineCreateFlags2::OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_KHR.0, + "OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_KHR", + ), ( PipelineCreateFlags2::TYPE_64_INDEXING_EXT.0, "TYPE_64_INDEXING_EXT", @@ -5499,6 +5650,7 @@ impl fmt::Debug for QueryType { Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") } + Self::TIME_ELAPSED_QCOM => Some("TIME_ELAPSED_QCOM"), Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"), Self::VIDEO_ENCODE_FEEDBACK_KHR => Some("VIDEO_ENCODE_FEEDBACK_KHR"), Self::MESH_PRIMITIVES_GENERATED_EXT => Some("MESH_PRIMITIVES_GENERATED_EXT"), @@ -5933,6 +6085,10 @@ impl fmt::Debug for ShaderCreateFlagsEXT { ShaderCreateFlagsEXT::INDIRECT_BINDABLE.0, "INDIRECT_BINDABLE", ), + ( + ShaderCreateFlagsEXT::OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX.0, + "OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX", + ), (ShaderCreateFlagsEXT::TYPE_64_INDEXING.0, "TYPE_64_INDEXING"), ( ShaderCreateFlagsEXT::INDEPENDENT_SETS_KHR.0, @@ -6579,6 +6735,15 @@ impl fmt::Debug for StructureType { Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => { Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID") } + Self::PHYSICAL_DEVICE_GPA_FEATURES_AMD => Some("PHYSICAL_DEVICE_GPA_FEATURES_AMD"), + Self::PHYSICAL_DEVICE_GPA_PROPERTIES_AMD => Some("PHYSICAL_DEVICE_GPA_PROPERTIES_AMD"), + Self::GPA_SAMPLE_BEGIN_INFO_AMD => Some("GPA_SAMPLE_BEGIN_INFO_AMD"), + Self::GPA_SESSION_CREATE_INFO_AMD => Some("GPA_SESSION_CREATE_INFO_AMD"), + Self::GPA_DEVICE_CLOCK_MODE_INFO_AMD => Some("GPA_DEVICE_CLOCK_MODE_INFO_AMD"), + Self::PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD => { + Some("PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD") + } + Self::GPA_DEVICE_GET_CLOCK_INFO_AMD => Some("GPA_DEVICE_GET_CLOCK_INFO_AMD"), #[cfg(feature = "provisional")] Self::PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX => { Some("PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX") @@ -6815,6 +6980,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM => { Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM") } + Self::PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM") + } Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => { Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT") } @@ -7178,6 +7346,21 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM => { Some("PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM") } + Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM => { + Some("PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM") + } + Self::PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT") + } #[cfg(feature = "provisional")] Self::CUDA_MODULE_CREATE_INFO_NV => Some("CUDA_MODULE_CREATE_INFO_NV"), #[cfg(feature = "provisional")] @@ -8424,6 +8607,18 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR => { Some("PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR") } + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR") + } + Self::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR => { + Some("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR") + } Self::PHYSICAL_DEVICE_SHADER_64_INDEXING_FEATURES_EXT => { Some("PHYSICAL_DEVICE_SHADER_64_INDEXING_FEATURES_EXT") } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index d627db5c1..034364a2a 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -63,7 +63,7 @@ pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); #[doc = ""] pub const API_VERSION_1_4: u32 = make_api_version(0, 1, 4, 0); #[doc = ""] -pub const HEADER_VERSION: u32 = 350; +pub const HEADER_VERSION: u32 = 351; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 4, HEADER_VERSION); #[doc = ""] @@ -150,6 +150,16 @@ pub struct DirectDriverLoadingFlagsLUNARG(pub(crate) Flags); vk_bitflags_wrapped!(DirectDriverLoadingFlagsLUNARG, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GpaPerfBlockPropertiesFlagsAMD(pub(crate) Flags); +vk_bitflags_wrapped!(GpaPerfBlockPropertiesFlagsAMD, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PhysicalDeviceGpaPropertiesFlagsAMD(pub(crate) Flags); +vk_bitflags_wrapped!(PhysicalDeviceGpaPropertiesFlagsAMD, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags); @@ -558,6 +568,11 @@ handle_nondispatchable!( doc = "" ); +handle_nondispatchable!( + GpaSessionAMD, + GPA_SESSION_AMD, + doc = "" +); handle_nondispatchable!( DisplayKHR, DISPLAY_KHR, @@ -21663,6 +21678,46 @@ impl ShaderStatisticsInfoAMD { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub elapsed_timer_query: Bool32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'_> {} +unsafe impl Sync for PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'_> {} +impl ::core::default::Default for PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + elapsed_timer_query: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM; +} +unsafe impl Extends> + for PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'_> +{ +} +unsafe impl Extends> for PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceElapsedTimerQueryFeaturesQCOM<'a> { + #[inline] + pub fn elapsed_timer_query(mut self, elapsed_timer_query: bool) -> Self { + self.elapsed_timer_query = elapsed_timer_query.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct DeviceQueueGlobalPriorityCreateInfo<'a> { @@ -35986,6 +36041,509 @@ impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMD<'a> { } } #[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +#[must_use] +pub struct GpaPerfBlockPropertiesAMD { + pub block_type: GpaPerfBlockAMD, + pub flags: GpaPerfBlockPropertiesFlagsAMD, + pub instance_count: u32, + pub max_event_id: u32, + pub max_global_only_counters: u32, + pub max_global_shared_counters: u32, + pub max_streaming_counters: u32, +} +impl GpaPerfBlockPropertiesAMD { + #[inline] + pub fn block_type(mut self, block_type: GpaPerfBlockAMD) -> Self { + self.block_type = block_type; + self + } + #[inline] + pub fn flags(mut self, flags: GpaPerfBlockPropertiesFlagsAMD) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.instance_count = instance_count; + self + } + #[inline] + pub fn max_event_id(mut self, max_event_id: u32) -> Self { + self.max_event_id = max_event_id; + self + } + #[inline] + pub fn max_global_only_counters(mut self, max_global_only_counters: u32) -> Self { + self.max_global_only_counters = max_global_only_counters; + self + } + #[inline] + pub fn max_global_shared_counters(mut self, max_global_shared_counters: u32) -> Self { + self.max_global_shared_counters = max_global_shared_counters; + self + } + #[inline] + pub fn max_streaming_counters(mut self, max_streaming_counters: u32) -> Self { + self.max_streaming_counters = max_streaming_counters; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceGpaFeaturesAMD<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub perf_counters: Bool32, + pub streaming_perf_counters: Bool32, + pub sq_thread_tracing: Bool32, + pub clock_modes: Bool32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceGpaFeaturesAMD<'_> {} +unsafe impl Sync for PhysicalDeviceGpaFeaturesAMD<'_> {} +impl ::core::default::Default for PhysicalDeviceGpaFeaturesAMD<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + perf_counters: Bool32::default(), + streaming_perf_counters: Bool32::default(), + sq_thread_tracing: Bool32::default(), + clock_modes: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceGpaFeaturesAMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_GPA_FEATURES_AMD; +} +unsafe impl Extends> for PhysicalDeviceGpaFeaturesAMD<'_> {} +unsafe impl Extends> for PhysicalDeviceGpaFeaturesAMD<'_> {} +impl<'a> PhysicalDeviceGpaFeaturesAMD<'a> { + #[inline] + pub fn perf_counters(mut self, perf_counters: bool) -> Self { + self.perf_counters = perf_counters.into(); + self + } + #[inline] + pub fn streaming_perf_counters(mut self, streaming_perf_counters: bool) -> Self { + self.streaming_perf_counters = streaming_perf_counters.into(); + self + } + #[inline] + pub fn sq_thread_tracing(mut self, sq_thread_tracing: bool) -> Self { + self.sq_thread_tracing = sq_thread_tracing.into(); + self + } + #[inline] + pub fn clock_modes(mut self, clock_modes: bool) -> Self { + self.clock_modes = clock_modes.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceGpaPropertiesAMD<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: PhysicalDeviceGpaPropertiesFlagsAMD, + pub max_sqtt_se_buffer_size: DeviceSize, + pub shader_engine_count: u32, + pub perf_block_count: u32, + pub p_perf_blocks: *mut GpaPerfBlockPropertiesAMD, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceGpaPropertiesAMD<'_> {} +unsafe impl Sync for PhysicalDeviceGpaPropertiesAMD<'_> {} +impl ::core::default::Default for PhysicalDeviceGpaPropertiesAMD<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + flags: PhysicalDeviceGpaPropertiesFlagsAMD::default(), + max_sqtt_se_buffer_size: DeviceSize::default(), + shader_engine_count: u32::default(), + perf_block_count: u32::default(), + p_perf_blocks: ::core::ptr::null_mut(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceGpaPropertiesAMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_GPA_PROPERTIES_AMD; +} +unsafe impl Extends> for PhysicalDeviceGpaPropertiesAMD<'_> {} +impl<'a> PhysicalDeviceGpaPropertiesAMD<'a> { + #[inline] + pub fn flags(mut self, flags: PhysicalDeviceGpaPropertiesFlagsAMD) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn max_sqtt_se_buffer_size(mut self, max_sqtt_se_buffer_size: DeviceSize) -> Self { + self.max_sqtt_se_buffer_size = max_sqtt_se_buffer_size; + self + } + #[inline] + pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self { + self.shader_engine_count = shader_engine_count; + self + } + #[inline] + pub fn perf_blocks(mut self, perf_blocks: &'a mut [GpaPerfBlockPropertiesAMD]) -> Self { + self.perf_block_count = perf_blocks.len() as _; + self.p_perf_blocks = perf_blocks.as_mut_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceGpaProperties2AMD<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub revision_id: u32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceGpaProperties2AMD<'_> {} +unsafe impl Sync for PhysicalDeviceGpaProperties2AMD<'_> {} +impl ::core::default::Default for PhysicalDeviceGpaProperties2AMD<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + revision_id: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceGpaProperties2AMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD; +} +unsafe impl Extends> for PhysicalDeviceGpaProperties2AMD<'_> {} +impl<'a> PhysicalDeviceGpaProperties2AMD<'a> { + #[inline] + pub fn revision_id(mut self, revision_id: u32) -> Self { + self.revision_id = revision_id; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +#[must_use] +pub struct GpaPerfCounterAMD { + pub block_type: GpaPerfBlockAMD, + pub block_instance: u32, + pub event_id: u32, +} +impl GpaPerfCounterAMD { + #[inline] + pub fn block_type(mut self, block_type: GpaPerfBlockAMD) -> Self { + self.block_type = block_type; + self + } + #[inline] + pub fn block_instance(mut self, block_instance: u32) -> Self { + self.block_instance = block_instance; + self + } + #[inline] + pub fn event_id(mut self, event_id: u32) -> Self { + self.event_id = event_id; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct GpaSampleBeginInfoAMD<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_type: GpaSampleTypeAMD, + pub sample_internal_operations: Bool32, + pub cache_flush_on_counter_collection: Bool32, + pub sq_shader_mask_enable: Bool32, + pub sq_shader_mask: GpaSqShaderStageFlagsAMD, + pub perf_counter_count: u32, + pub p_perf_counters: *const GpaPerfCounterAMD, + pub streaming_perf_trace_sample_interval: u32, + pub perf_counter_device_memory_limit: DeviceSize, + pub sq_thread_trace_enable: Bool32, + pub sq_thread_trace_suppress_instruction_tokens: Bool32, + pub sq_thread_trace_device_memory_limit: DeviceSize, + pub timing_pre_sample: PipelineStageFlags, + pub timing_post_sample: PipelineStageFlags, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for GpaSampleBeginInfoAMD<'_> {} +unsafe impl Sync for GpaSampleBeginInfoAMD<'_> {} +impl ::core::default::Default for GpaSampleBeginInfoAMD<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null(), + sample_type: GpaSampleTypeAMD::default(), + sample_internal_operations: Bool32::default(), + cache_flush_on_counter_collection: Bool32::default(), + sq_shader_mask_enable: Bool32::default(), + sq_shader_mask: GpaSqShaderStageFlagsAMD::default(), + perf_counter_count: u32::default(), + p_perf_counters: ::core::ptr::null(), + streaming_perf_trace_sample_interval: u32::default(), + perf_counter_device_memory_limit: DeviceSize::default(), + sq_thread_trace_enable: Bool32::default(), + sq_thread_trace_suppress_instruction_tokens: Bool32::default(), + sq_thread_trace_device_memory_limit: DeviceSize::default(), + timing_pre_sample: PipelineStageFlags::default(), + timing_post_sample: PipelineStageFlags::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for GpaSampleBeginInfoAMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::GPA_SAMPLE_BEGIN_INFO_AMD; +} +impl<'a> GpaSampleBeginInfoAMD<'a> { + #[inline] + pub fn sample_type(mut self, sample_type: GpaSampleTypeAMD) -> Self { + self.sample_type = sample_type; + self + } + #[inline] + pub fn sample_internal_operations(mut self, sample_internal_operations: bool) -> Self { + self.sample_internal_operations = sample_internal_operations.into(); + self + } + #[inline] + pub fn cache_flush_on_counter_collection( + mut self, + cache_flush_on_counter_collection: bool, + ) -> Self { + self.cache_flush_on_counter_collection = cache_flush_on_counter_collection.into(); + self + } + #[inline] + pub fn sq_shader_mask_enable(mut self, sq_shader_mask_enable: bool) -> Self { + self.sq_shader_mask_enable = sq_shader_mask_enable.into(); + self + } + #[inline] + pub fn sq_shader_mask(mut self, sq_shader_mask: GpaSqShaderStageFlagsAMD) -> Self { + self.sq_shader_mask = sq_shader_mask; + self + } + #[inline] + pub fn perf_counters(mut self, perf_counters: &'a [GpaPerfCounterAMD]) -> Self { + self.perf_counter_count = perf_counters.len() as _; + self.p_perf_counters = perf_counters.as_ptr(); + self + } + #[inline] + pub fn streaming_perf_trace_sample_interval( + mut self, + streaming_perf_trace_sample_interval: u32, + ) -> Self { + self.streaming_perf_trace_sample_interval = streaming_perf_trace_sample_interval; + self + } + #[inline] + pub fn perf_counter_device_memory_limit( + mut self, + perf_counter_device_memory_limit: DeviceSize, + ) -> Self { + self.perf_counter_device_memory_limit = perf_counter_device_memory_limit; + self + } + #[inline] + pub fn sq_thread_trace_enable(mut self, sq_thread_trace_enable: bool) -> Self { + self.sq_thread_trace_enable = sq_thread_trace_enable.into(); + self + } + #[inline] + pub fn sq_thread_trace_suppress_instruction_tokens( + mut self, + sq_thread_trace_suppress_instruction_tokens: bool, + ) -> Self { + self.sq_thread_trace_suppress_instruction_tokens = + sq_thread_trace_suppress_instruction_tokens.into(); + self + } + #[inline] + pub fn sq_thread_trace_device_memory_limit( + mut self, + sq_thread_trace_device_memory_limit: DeviceSize, + ) -> Self { + self.sq_thread_trace_device_memory_limit = sq_thread_trace_device_memory_limit; + self + } + #[inline] + pub fn timing_pre_sample(mut self, timing_pre_sample: PipelineStageFlags) -> Self { + self.timing_pre_sample = timing_pre_sample; + self + } + #[inline] + pub fn timing_post_sample(mut self, timing_post_sample: PipelineStageFlags) -> Self { + self.timing_post_sample = timing_post_sample; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct GpaDeviceClockModeInfoAMD<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub clock_mode: GpaDeviceClockModeAMD, + pub memory_clock_ratio_to_peak: f32, + pub engine_clock_ratio_to_peak: f32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for GpaDeviceClockModeInfoAMD<'_> {} +unsafe impl Sync for GpaDeviceClockModeInfoAMD<'_> {} +impl ::core::default::Default for GpaDeviceClockModeInfoAMD<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null(), + clock_mode: GpaDeviceClockModeAMD::default(), + memory_clock_ratio_to_peak: f32::default(), + engine_clock_ratio_to_peak: f32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for GpaDeviceClockModeInfoAMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::GPA_DEVICE_CLOCK_MODE_INFO_AMD; +} +impl<'a> GpaDeviceClockModeInfoAMD<'a> { + #[inline] + pub fn clock_mode(mut self, clock_mode: GpaDeviceClockModeAMD) -> Self { + self.clock_mode = clock_mode; + self + } + #[inline] + pub fn memory_clock_ratio_to_peak(mut self, memory_clock_ratio_to_peak: f32) -> Self { + self.memory_clock_ratio_to_peak = memory_clock_ratio_to_peak; + self + } + #[inline] + pub fn engine_clock_ratio_to_peak(mut self, engine_clock_ratio_to_peak: f32) -> Self { + self.engine_clock_ratio_to_peak = engine_clock_ratio_to_peak; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct GpaDeviceGetClockInfoAMD<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_clock_ratio_to_peak: f32, + pub engine_clock_ratio_to_peak: f32, + pub memory_clock_frequency: u32, + pub engine_clock_frequency: u32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for GpaDeviceGetClockInfoAMD<'_> {} +unsafe impl Sync for GpaDeviceGetClockInfoAMD<'_> {} +impl ::core::default::Default for GpaDeviceGetClockInfoAMD<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + memory_clock_ratio_to_peak: f32::default(), + engine_clock_ratio_to_peak: f32::default(), + memory_clock_frequency: u32::default(), + engine_clock_frequency: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for GpaDeviceGetClockInfoAMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::GPA_DEVICE_GET_CLOCK_INFO_AMD; +} +impl<'a> GpaDeviceGetClockInfoAMD<'a> { + #[inline] + pub fn memory_clock_ratio_to_peak(mut self, memory_clock_ratio_to_peak: f32) -> Self { + self.memory_clock_ratio_to_peak = memory_clock_ratio_to_peak; + self + } + #[inline] + pub fn engine_clock_ratio_to_peak(mut self, engine_clock_ratio_to_peak: f32) -> Self { + self.engine_clock_ratio_to_peak = engine_clock_ratio_to_peak; + self + } + #[inline] + pub fn memory_clock_frequency(mut self, memory_clock_frequency: u32) -> Self { + self.memory_clock_frequency = memory_clock_frequency; + self + } + #[inline] + pub fn engine_clock_frequency(mut self, engine_clock_frequency: u32) -> Self { + self.engine_clock_frequency = engine_clock_frequency; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct GpaSessionCreateInfoAMD<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub secondary_copy_source: GpaSessionAMD, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for GpaSessionCreateInfoAMD<'_> {} +unsafe impl Sync for GpaSessionCreateInfoAMD<'_> {} +impl ::core::default::Default for GpaSessionCreateInfoAMD<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null(), + secondary_copy_source: GpaSessionAMD::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for GpaSessionCreateInfoAMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::GPA_SESSION_CREATE_INFO_AMD; +} +impl<'a> GpaSessionCreateInfoAMD<'a> { + #[inline] + pub fn secondary_copy_source(mut self, secondary_copy_source: GpaSessionAMD) -> Self { + self.secondary_copy_source = secondary_copy_source; + self + } +} +#[repr(C)] #[derive(Copy, Clone)] #[doc = ""] #[must_use] @@ -56367,6 +56925,77 @@ impl<'a> MicromapBuildInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct AccelerationStructureGeometryMicromapDataKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageKHR, + pub pp_usage_counts: *const *const MicromapUsageKHR, + pub data: DeviceAddress, + pub triangle_array: DeviceAddress, + pub triangle_array_stride: DeviceSize, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for AccelerationStructureGeometryMicromapDataKHR<'_> {} +unsafe impl Sync for AccelerationStructureGeometryMicromapDataKHR<'_> {} +impl ::core::default::Default for AccelerationStructureGeometryMicromapDataKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null(), + usage_counts_count: u32::default(), + p_usage_counts: ::core::ptr::null(), + pp_usage_counts: ::core::ptr::null(), + data: DeviceAddress::default(), + triangle_array: DeviceAddress::default(), + triangle_array_stride: DeviceSize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for AccelerationStructureGeometryMicromapDataKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR; +} +unsafe impl Extends> + for AccelerationStructureGeometryMicromapDataKHR<'_> +{ +} +impl<'a> AccelerationStructureGeometryMicromapDataKHR<'a> { + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageKHR]) -> Self { + self.usage_counts_count = usage_counts.len() as _; + self.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageKHR]) -> Self { + self.usage_counts_count = usage_counts_ptrs.len() as _; + self.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn data(mut self, data: DeviceAddress) -> Self { + self.data = data; + self + } + #[inline] + pub fn triangle_array(mut self, triangle_array: DeviceAddress) -> Self { + self.triangle_array = triangle_array; + self + } + #[inline] + pub fn triangle_array_stride(mut self, triangle_array_stride: DeviceSize) -> Self { + self.triangle_array_stride = triangle_array_stride; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct MicromapCreateInfoEXT<'a> { @@ -56684,6 +57313,33 @@ impl<'a> MicromapBuildSizesInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] +#[doc = ""] +#[must_use] +pub struct MicromapUsageKHR { + pub count: u32, + pub subdivision_level: u32, + pub format: OpacityMicromapFormatKHR, +} +impl MicromapUsageKHR { + #[inline] + pub fn count(mut self, count: u32) -> Self { + self.count = count; + self + } + #[inline] + pub fn subdivision_level(mut self, subdivision_level: u32) -> Self { + self.subdivision_level = subdivision_level; + self + } + #[inline] + pub fn format(mut self, format: OpacityMicromapFormatKHR) -> Self { + self.format = format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] #[doc = ""] #[must_use] pub struct MicromapUsageEXT { @@ -56711,14 +57367,14 @@ impl MicromapUsageEXT { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] -#[doc = ""] +#[doc = ""] #[must_use] -pub struct MicromapTriangleEXT { +pub struct MicromapTriangleKHR { pub data_offset: u32, pub subdivision_level: u16, pub format: u16, } -impl MicromapTriangleEXT { +impl MicromapTriangleKHR { #[inline] pub fn data_offset(mut self, data_offset: u32) -> Self { self.data_offset = data_offset; @@ -56738,6 +57394,43 @@ impl MicromapTriangleEXT { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceOpacityMicromapFeaturesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub micromap: Bool32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceOpacityMicromapFeaturesKHR<'_> {} +unsafe impl Sync for PhysicalDeviceOpacityMicromapFeaturesKHR<'_> {} +impl ::core::default::Default for PhysicalDeviceOpacityMicromapFeaturesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + micromap: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceOpacityMicromapFeaturesKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR; +} +unsafe impl Extends> for PhysicalDeviceOpacityMicromapFeaturesKHR<'_> {} +unsafe impl Extends> for PhysicalDeviceOpacityMicromapFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceOpacityMicromapFeaturesKHR<'a> { + #[inline] + pub fn micromap(mut self, micromap: bool) -> Self { + self.micromap = micromap.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { @@ -56789,6 +57482,76 @@ impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceOpacityMicromapPropertiesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_opacity2_state_subdivision_level: u32, + pub max_opacity4_state_subdivision_level: u32, + pub max_opacity_lossy4_state_subdivision_level: u32, + pub max_micromap_triangles: u64, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceOpacityMicromapPropertiesKHR<'_> {} +unsafe impl Sync for PhysicalDeviceOpacityMicromapPropertiesKHR<'_> {} +impl ::core::default::Default for PhysicalDeviceOpacityMicromapPropertiesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + max_opacity2_state_subdivision_level: u32::default(), + max_opacity4_state_subdivision_level: u32::default(), + max_opacity_lossy4_state_subdivision_level: u32::default(), + max_micromap_triangles: u64::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceOpacityMicromapPropertiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR; +} +unsafe impl Extends> + for PhysicalDeviceOpacityMicromapPropertiesKHR<'_> +{ +} +impl<'a> PhysicalDeviceOpacityMicromapPropertiesKHR<'a> { + #[inline] + pub fn max_opacity2_state_subdivision_level( + mut self, + max_opacity2_state_subdivision_level: u32, + ) -> Self { + self.max_opacity2_state_subdivision_level = max_opacity2_state_subdivision_level; + self + } + #[inline] + pub fn max_opacity4_state_subdivision_level( + mut self, + max_opacity4_state_subdivision_level: u32, + ) -> Self { + self.max_opacity4_state_subdivision_level = max_opacity4_state_subdivision_level; + self + } + #[inline] + pub fn max_opacity_lossy4_state_subdivision_level( + mut self, + max_opacity_lossy4_state_subdivision_level: u32, + ) -> Self { + self.max_opacity_lossy4_state_subdivision_level = + max_opacity_lossy4_state_subdivision_level; + self + } + #[inline] + pub fn max_micromap_triangles(mut self, max_micromap_triangles: u64) -> Self { + self.max_micromap_triangles = max_micromap_triangles; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { @@ -56839,6 +57602,78 @@ impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { } } #[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct AccelerationStructureTrianglesOpacityMicromapKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub index_type: IndexType, + pub index_buffer: DeviceAddress, + pub index_stride: DeviceSize, + pub base_triangle: u32, + pub micromap: AccelerationStructureKHR, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for AccelerationStructureTrianglesOpacityMicromapKHR<'_> {} +unsafe impl Sync for AccelerationStructureTrianglesOpacityMicromapKHR<'_> {} +impl ::core::default::Default for AccelerationStructureTrianglesOpacityMicromapKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + index_type: IndexType::default(), + index_buffer: DeviceAddress::default(), + index_stride: DeviceSize::default(), + base_triangle: u32::default(), + micromap: AccelerationStructureKHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for AccelerationStructureTrianglesOpacityMicromapKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR; +} +unsafe impl Extends> + for AccelerationStructureTrianglesOpacityMicromapKHR<'_> +{ +} +#[cfg(feature = "provisional")] +unsafe impl Extends> + for AccelerationStructureTrianglesOpacityMicromapKHR<'_> +{ +} +impl<'a> AccelerationStructureTrianglesOpacityMicromapKHR<'a> { + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.index_type = index_type; + self + } + #[inline] + pub fn index_buffer(mut self, index_buffer: DeviceAddress) -> Self { + self.index_buffer = index_buffer; + self + } + #[inline] + pub fn index_stride(mut self, index_stride: DeviceSize) -> Self { + self.index_stride = index_stride; + self + } + #[inline] + pub fn base_triangle(mut self, base_triangle: u32) -> Self { + self.base_triangle = base_triangle; + self + } + #[inline] + pub fn micromap(mut self, micromap: AccelerationStructureKHR) -> Self { + self.micromap = micromap; + self + } +} +#[repr(C)] #[derive(Copy, Clone)] #[doc = ""] #[must_use] @@ -58156,6 +58991,88 @@ impl<'a> ImageViewSampleWeightCreateInfoQCOM<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_multiple_wait_queues: Bool32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'_> {} +unsafe impl Sync for PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'_> {} +impl ::core::default::Default for PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + shader_multiple_wait_queues: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM; +} +unsafe impl Extends> + for PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'_> +{ +} +unsafe impl Extends> + for PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'_> +{ +} +impl<'a> PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM<'a> { + #[inline] + pub fn shader_multiple_wait_queues(mut self, shader_multiple_wait_queues: bool) -> Self { + self.shader_multiple_wait_queues = shader_multiple_wait_queues.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_shader_wait_queues: u32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<'_> {} +unsafe impl Sync for PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<'_> {} +impl ::core::default::Default for PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + max_shader_wait_queues: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM; +} +unsafe impl Extends> + for PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<'_> +{ +} +impl<'a> PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM<'a> { + #[inline] + pub fn max_shader_wait_queues(mut self, max_shader_wait_queues: u32) -> Self { + self.max_shader_wait_queues = max_shader_wait_queues; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct PhysicalDeviceImageProcessingFeaturesQCOM<'a> { @@ -63757,6 +64674,63 @@ impl<'a> SamplerBlockMatchWindowCreateInfoQCOM<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceImageProcessing3FeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_gather_linear: Bool32, + pub image_gather_extended_modes: Bool32, + pub block_match_extended_clamp_to_edge: Bool32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceImageProcessing3FeaturesQCOM<'_> {} +unsafe impl Sync for PhysicalDeviceImageProcessing3FeaturesQCOM<'_> {} +impl ::core::default::Default for PhysicalDeviceImageProcessing3FeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + image_gather_linear: Bool32::default(), + image_gather_extended_modes: Bool32::default(), + block_match_extended_clamp_to_edge: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceImageProcessing3FeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM; +} +unsafe impl Extends> + for PhysicalDeviceImageProcessing3FeaturesQCOM<'_> +{ +} +unsafe impl Extends> for PhysicalDeviceImageProcessing3FeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceImageProcessing3FeaturesQCOM<'a> { + #[inline] + pub fn image_gather_linear(mut self, image_gather_linear: bool) -> Self { + self.image_gather_linear = image_gather_linear.into(); + self + } + #[inline] + pub fn image_gather_extended_modes(mut self, image_gather_extended_modes: bool) -> Self { + self.image_gather_extended_modes = image_gather_extended_modes.into(); + self + } + #[inline] + pub fn block_match_extended_clamp_to_edge( + mut self, + block_match_extended_clamp_to_edge: bool, + ) -> Self { + self.block_match_extended_clamp_to_edge = block_match_extended_clamp_to_edge.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { @@ -72540,6 +73514,88 @@ impl<'a> SubsampledImageFormatPropertiesEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceShaderSplitBarrierFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_split_barrier: Bool32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceShaderSplitBarrierFeaturesEXT<'_> {} +unsafe impl Sync for PhysicalDeviceShaderSplitBarrierFeaturesEXT<'_> {} +impl ::core::default::Default for PhysicalDeviceShaderSplitBarrierFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + shader_split_barrier: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderSplitBarrierFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT; +} +unsafe impl Extends> + for PhysicalDeviceShaderSplitBarrierFeaturesEXT<'_> +{ +} +unsafe impl Extends> for PhysicalDeviceShaderSplitBarrierFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceShaderSplitBarrierFeaturesEXT<'a> { + #[inline] + pub fn shader_split_barrier(mut self, shader_split_barrier: bool) -> Self { + self.shader_split_barrier = shader_split_barrier.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceShaderSplitBarrierPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub split_barrier_reserved_shared_memory: u32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceShaderSplitBarrierPropertiesEXT<'_> {} +unsafe impl Sync for PhysicalDeviceShaderSplitBarrierPropertiesEXT<'_> {} +impl ::core::default::Default for PhysicalDeviceShaderSplitBarrierPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + split_barrier_reserved_shared_memory: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderSplitBarrierPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT; +} +unsafe impl Extends> + for PhysicalDeviceShaderSplitBarrierPropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceShaderSplitBarrierPropertiesEXT<'a> { + #[inline] + pub fn split_barrier_reserved_shared_memory( + mut self, + split_barrier_reserved_shared_memory: u32, + ) -> Self { + self.split_barrier_reserved_shared_memory = split_barrier_reserved_shared_memory; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct PhysicalDeviceDescriptorHeapFeaturesEXT<'a> { diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index b0719c49c..1871d71f3 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -2616,9 +2616,9 @@ impl BuildMicromapModeEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[doc = ""] -pub struct OpacityMicromapFormatEXT(pub(crate) i32); -impl OpacityMicromapFormatEXT { +#[doc = ""] +pub struct OpacityMicromapFormatKHR(pub(crate) i32); +impl OpacityMicromapFormatKHR { #[inline] pub const fn from_raw(x: i32) -> Self { Self(x) @@ -2632,9 +2632,9 @@ impl OpacityMicromapFormatEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[doc = ""] -pub struct OpacityMicromapSpecialIndexEXT(pub(crate) i32); -impl OpacityMicromapSpecialIndexEXT { +#[doc = ""] +pub struct OpacityMicromapSpecialIndexKHR(pub(crate) i32); +impl OpacityMicromapSpecialIndexKHR { #[inline] pub const fn from_raw(x: i32) -> Self { Self(x) @@ -2650,6 +2650,21 @@ impl OpacityMicromapSpecialIndexEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[doc = ""] +pub struct AccelerationStructureSerializedBlockTypeKHR(pub(crate) i32); +impl AccelerationStructureSerializedBlockTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } + pub const OPACITY_MICROMAP: Self = Self(0); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[doc = ""] pub struct DepthBiasRepresentationEXT(pub(crate) i32); impl DepthBiasRepresentationEXT { @@ -3165,6 +3180,116 @@ impl DescriptorMappingSourceEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[doc = ""] +pub struct GpaPerfBlockAMD(pub(crate) i32); +impl GpaPerfBlockAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } + pub const CPF: Self = Self(0); + pub const IA: Self = Self(1); + pub const VGT: Self = Self(2); + pub const PA: Self = Self(3); + pub const SC: Self = Self(4); + pub const SPI: Self = Self(5); + pub const SQ: Self = Self(6); + pub const SX: Self = Self(7); + pub const TA: Self = Self(8); + pub const TD: Self = Self(9); + pub const TCP: Self = Self(10); + pub const TCC: Self = Self(11); + pub const TCA: Self = Self(12); + pub const DB: Self = Self(13); + pub const CB: Self = Self(14); + pub const GDS: Self = Self(15); + pub const SRBM: Self = Self(16); + pub const GRBM: Self = Self(17); + pub const GRBM_SE: Self = Self(18); + pub const RLC: Self = Self(19); + pub const DMA: Self = Self(20); + pub const MC: Self = Self(21); + pub const CPG: Self = Self(22); + pub const CPC: Self = Self(23); + pub const WD: Self = Self(24); + pub const TCS: Self = Self(25); + pub const ATC: Self = Self(26); + pub const ATC_L2: Self = Self(27); + pub const MC_VM_L2: Self = Self(28); + pub const EA: Self = Self(29); + pub const RPB: Self = Self(30); + pub const RMI: Self = Self(31); + pub const UMCCH: Self = Self(32); + pub const GE: Self = Self(33); + pub const GL1A: Self = Self(34); + pub const GL1C: Self = Self(35); + pub const GL1CG: Self = Self(36); + pub const GL2A: Self = Self(37); + pub const GL2C: Self = Self(38); + pub const CHA: Self = Self(39); + pub const CHC: Self = Self(40); + pub const CHCG: Self = Self(41); + pub const GUS: Self = Self(42); + pub const GCR: Self = Self(43); + pub const PH: Self = Self(44); + pub const UTCL1: Self = Self(45); + pub const GE1: Self = Self::GE; + pub const GE_DIST: Self = Self(46); + pub const GE_SE: Self = Self(47); + pub const DF_MALL: Self = Self(48); + pub const SQ_WGP: Self = Self(49); + pub const PC: Self = Self(50); + pub const GL1XA: Self = Self(51); + pub const GL1XC: Self = Self(52); + pub const WGS: Self = Self(53); + pub const EACPWD: Self = Self(54); + pub const EASE: Self = Self(55); + pub const RLCUSER: Self = Self(56); + pub const RLCLOCAL: Self = Self::RLCUSER; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[doc = ""] +pub struct GpaSampleTypeAMD(pub(crate) i32); +impl GpaSampleTypeAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } + pub const CUMULATIVE: Self = Self(0); + pub const TRACE: Self = Self(1); + pub const TIMING: Self = Self(2); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[doc = ""] +pub struct GpaDeviceClockModeAMD(pub(crate) i32); +impl GpaDeviceClockModeAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } + pub const DEFAULT: Self = Self(0); + pub const QUERY: Self = Self(1); + pub const PROFILING: Self = Self(2); + pub const MIN_MEMORY: Self = Self(3); + pub const MIN_ENGINE: Self = Self(4); + pub const PEAK: Self = Self(5); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[doc = ""] pub struct DataGraphTOSALevelARM(pub(crate) i32); impl DataGraphTOSALevelARM { @@ -3281,6 +3406,7 @@ impl fmt::Debug for ObjectType { 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::GPA_SESSION_AMD => Some("GPA_SESSION_AMD"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 5e161e586..91ccef9e7 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -985,6 +985,20 @@ impl StructureType { pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self = Self::SAMPLER_REDUCTION_MODE_CREATE_INFO; } +#[doc = "Generated from 'VK_AMD_gpa_interface'"] +impl ObjectType { + pub const GPA_SESSION_AMD: Self = Self(1_000_133_000); +} +#[doc = "Generated from 'VK_AMD_gpa_interface'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GPA_FEATURES_AMD: Self = Self(1_000_133_000); + pub const PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: Self = Self(1_000_133_001); + pub const GPA_SAMPLE_BEGIN_INFO_AMD: Self = Self(1_000_133_002); + pub const GPA_SESSION_CREATE_INFO_AMD: Self = Self(1_000_133_003); + pub const GPA_DEVICE_CLOCK_MODE_INFO_AMD: Self = Self(1_000_133_004); + pub const PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: Self = Self(1_000_133_005); + pub const GPA_DEVICE_GET_CLOCK_INFO_AMD: Self = Self(1_000_133_006); +} #[doc = "Generated from 'VK_AMDX_shader_enqueue'"] #[cfg(feature = "provisional")] impl BufferUsageFlags { @@ -1704,6 +1718,14 @@ impl StructureType { pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: Self = Self(1_000_172_000); } +#[doc = "Generated from 'VK_QCOM_elapsed_timer_query'"] +impl QueryType { + pub const TIME_ELAPSED_QCOM: Self = Self(1_000_173_000); +} +#[doc = "Generated from 'VK_QCOM_elapsed_timer_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: Self = Self(1_000_173_000); +} #[doc = "Generated from 'VK_EXT_global_priority'"] impl QueueGlobalPriority { pub const LOW_EXT: Self = Self::LOW; @@ -2795,6 +2817,26 @@ impl StructureType { pub const PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM: Self = Self(1_000_302_001); pub const PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM: Self = Self(1_000_302_002); } +#[doc = "Generated from 'VK_QCOM_image_processing3'"] +impl FormatFeatureFlags2 { + pub const BLOCK_MATCHING_SXD_QCOM: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_image_processing3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: Self = Self(1_000_303_000); +} +#[doc = "Generated from 'VK_QCOM_shader_multiple_wait_queues'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: Self = Self(1_000_304_000); + pub const PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: Self = + Self(1_000_304_001); +} +#[doc = "Generated from 'VK_EXT_shader_split_barrier'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: Self = Self(1_000_305_000); + pub const PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: Self = Self(1_000_305_001); +} #[doc = "Generated from 'VK_NV_cuda_kernel_launch'"] #[cfg(feature = "provisional")] impl DebugReportObjectTypeEXT { @@ -3628,23 +3670,44 @@ impl BufferUsageFlags { pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl BufferUsageFlags2 { + pub const MICROMAP_BUILD_INPUT_READ_ONLY_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl BuildAccelerationStructureFlagsKHR { - pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self(0b100_0000); - pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b1000_0000); + pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self::ALLOW_OPACITY_MICROMAP_UPDATE; + pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self::ALLOW_DISABLE_OPACITY_MICROMAPS; pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: Self = Self(0b1_0000_0000); } #[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl GeometryInstanceFlagsKHR { - pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self(0b1_0000); - pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b10_0000); + pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self::FORCE_OPACITY_MICROMAP_2_STATE; + pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self::DISABLE_OPACITY_MICROMAPS; } #[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl ObjectType { pub const MICROMAP_EXT: Self = Self(1_000_396_000); } #[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl OpacityMicromapFormatKHR { + pub const TYPE_2_STATE_EXT: Self = Self::TYPE_2_STATE; + pub const TYPE_4_STATE_EXT: Self = Self::TYPE_4_STATE; +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl OpacityMicromapSpecialIndexKHR { + pub const FULLY_TRANSPARENT_EXT: Self = Self::FULLY_TRANSPARENT; + pub const FULLY_OPAQUE_EXT: Self = Self::FULLY_OPAQUE; + pub const FULLY_UNKNOWN_TRANSPARENT_EXT: Self = Self::FULLY_UNKNOWN_TRANSPARENT; + pub const FULLY_UNKNOWN_OPAQUE_EXT: Self = Self::FULLY_UNKNOWN_OPAQUE; +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl PipelineCreateFlags { - pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self::RAY_TRACING_OPACITY_MICROMAP_KHR; +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl PipelineCreateFlags2 { + pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self::RAY_TRACING_OPACITY_MICROMAP_KHR; } #[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl PipelineStageFlags2 { @@ -4192,8 +4255,6 @@ impl BufferUsageFlags2 { pub const RESOURCE_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); - pub const MICROMAP_BUILD_INPUT_READ_ONLY_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); - pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_KHR_maintenance5'"] impl Format { @@ -4228,7 +4289,6 @@ impl PipelineCreateFlags2 { Self(0b10_0000_0000_0000_0000_0000); pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); - pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); @@ -5003,7 +5063,7 @@ impl BuildAccelerationStructureFlagsKHR { pub const ALLOW_CLUSTER_OPACITY_MICROMAPS_NV: Self = Self(0b1_0000_0000_0000); } #[doc = "Generated from 'VK_NV_cluster_acceleration_structure'"] -impl OpacityMicromapSpecialIndexEXT { +impl OpacityMicromapSpecialIndexKHR { pub const CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: Self = Self(-5); } #[doc = "Generated from 'VK_NV_cluster_acceleration_structure'"] @@ -5304,6 +5364,46 @@ impl StructureType { pub const PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: Self = Self(1_000_361_000); } +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl AccelerationStructureTypeKHR { + pub const OPACITY_MICROMAP: Self = Self(1_000_623_000); +} +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_OPACITY_MICROMAP_UPDATE: Self = Self(0b100_0000); + pub const ALLOW_DISABLE_OPACITY_MICROMAPS: Self = Self(0b1000_0000); + pub const MICROMAP_LOSSY: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl GeometryInstanceFlagsKHR { + pub const FORCE_OPACITY_MICROMAP_2_STATE: Self = Self(0b1_0000); + pub const DISABLE_OPACITY_MICROMAPS: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl GeometryTypeKHR { + pub const MICROMAP: Self = Self(1_000_623_000); +} +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_OPACITY_MICROMAP_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl PipelineCreateFlags2 { + pub const RAY_TRACING_OPACITY_MICROMAP_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl ShaderCreateFlagsEXT { + pub const OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_opacity_micromap'"] +impl StructureType { + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: Self = Self(1_000_623_000); + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: Self = Self(1_000_623_001); + pub const ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR: Self = Self(1_000_623_002); + pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR: Self = Self(1_000_623_003); +} #[doc = "Generated from 'VK_EXT_shader_64bit_indexing'"] impl PipelineCreateFlags2 { pub const TYPE_64_INDEXING_EXT: Self = @@ -6861,6 +6961,68 @@ pub const KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION: u32 = 1u32; pub const AMD_GPU_SHADER_INT16_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_int16\0") }; pub const AMD_GPU_SHADER_INT16_SPEC_VERSION: u32 = 2u32; +pub const AMD_GPA_INTERFACE_NAME: &CStr = + unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpa_interface\0") }; +pub const AMD_GPA_INTERFACE_SPEC_VERSION: u32 = 1u32; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateGpaSessionAMD = unsafe extern "system" fn( + device: crate::vk::Device, + p_create_info: *const GpaSessionCreateInfoAMD<'_>, + p_allocator: *const AllocationCallbacks, + p_gpa_session: *mut GpaSessionAMD, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyGpaSessionAMD = unsafe extern "system" fn( + device: crate::vk::Device, + gpa_session: GpaSessionAMD, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkSetGpaDeviceClockModeAMD = unsafe extern "system" fn( + device: crate::vk::Device, + p_info: *mut GpaDeviceClockModeInfoAMD<'_>, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetGpaDeviceClockInfoAMD = unsafe extern "system" fn( + device: crate::vk::Device, + p_info: *mut GpaDeviceGetClockInfoAMD<'_>, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginGpaSessionAMD = + unsafe extern "system" fn(command_buffer: CommandBuffer, gpa_session: GpaSessionAMD) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndGpaSessionAMD = + unsafe extern "system" fn(command_buffer: CommandBuffer, gpa_session: GpaSessionAMD) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginGpaSampleAMD = unsafe extern "system" fn( + command_buffer: CommandBuffer, + gpa_session: GpaSessionAMD, + p_gpa_sample_begin_info: *const GpaSampleBeginInfoAMD<'_>, + p_sample_id: *mut u32, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndGpaSampleAMD = unsafe extern "system" fn( + command_buffer: CommandBuffer, + gpa_session: GpaSessionAMD, + sample_id: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetGpaSessionStatusAMD = + unsafe extern "system" fn(device: crate::vk::Device, gpa_session: GpaSessionAMD) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetGpaSessionResultsAMD = unsafe extern "system" fn( + device: crate::vk::Device, + gpa_session: GpaSessionAMD, + sample_id: u32, + p_size_in_bytes: *mut usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkResetGpaSessionAMD = + unsafe extern "system" fn(device: crate::vk::Device, gpa_session: GpaSessionAMD) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyGpaSessionResultsAMD = + unsafe extern "system" fn(command_buffer: CommandBuffer, gpa_session: GpaSessionAMD); #[cfg(feature = "provisional")] pub const AMDX_SHADER_ENQUEUE_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_AMDX_shader_enqueue\0") }; @@ -7458,6 +7620,9 @@ pub const QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION: u32 = 4u32; pub const QCOM_COOPERATIVE_MATRIX_CONVERSION_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_cooperative_matrix_conversion\0") }; pub const QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION: u32 = 1u32; +pub const QCOM_ELAPSED_TIMER_QUERY_NAME: &CStr = + unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_elapsed_timer_query\0") }; +pub const QCOM_ELAPSED_TIMER_QUERY_SPEC_VERSION: u32 = 1u32; pub const EXT_GLOBAL_PRIORITY_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority\0") }; pub const EXT_GLOBAL_PRIORITY_SPEC_VERSION: u32 = 2u32; @@ -8324,6 +8489,15 @@ pub type PFN_vkQueueSetPerfHintQCOM = unsafe extern "system" fn( queue: Queue, p_perf_hint_info: *const PerfHintInfoQCOM<'_>, ) -> Result; +pub const QCOM_IMAGE_PROCESSING3_NAME: &CStr = + unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_image_processing3\0") }; +pub const QCOM_IMAGE_PROCESSING3_SPEC_VERSION: u32 = 1u32; +pub const QCOM_SHADER_MULTIPLE_WAIT_QUEUES_NAME: &CStr = + unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_shader_multiple_wait_queues\0") }; +pub const QCOM_SHADER_MULTIPLE_WAIT_QUEUES_SPEC_VERSION: u32 = 1u32; +pub const EXT_SHADER_SPLIT_BARRIER_NAME: &CStr = + unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_split_barrier\0") }; +pub const EXT_SHADER_SPLIT_BARRIER_SPEC_VERSION: u32 = 1u32; #[cfg(feature = "provisional")] pub const NV_CUDA_KERNEL_LAUNCH_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_NV_cuda_kernel_launch\0") }; @@ -10427,6 +10601,9 @@ pub const EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION: u32 = 1u32; pub const KHR_PRESENT_MODE_FIFO_LATEST_READY_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_mode_fifo_latest_ready\0") }; pub const KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION: u32 = 1u32; +pub const KHR_OPACITY_MICROMAP_NAME: &CStr = + unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_KHR_opacity_micromap\0") }; +pub const KHR_OPACITY_MICROMAP_SPEC_VERSION: u32 = 1u32; pub const EXT_SHADER_64BIT_INDEXING_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_64bit_indexing\0") }; pub const EXT_SHADER_64BIT_INDEXING_SPEC_VERSION: u32 = 1u32; diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 8864cdc89..0e9de566b 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 8864cdc896bbc2a9b6eb36b3218fc9ef57908d77 +Subproject commit 0e9de566b7d4051c5cc1b762e242c46565956bdf From b112383a37b2581a45323d30b04734b2d11a3c90 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Mon, 18 May 2026 11:10:26 +0200 Subject: [PATCH 2/2] Update Vulkan-Headers to 1.4.352 --- Changelog.md | 2 +- ash/Cargo.toml | 2 +- ash/src/extensions_generated.rs | 7 +++++ ash/src/vk/const_debugs.rs | 4 +++ ash/src/vk/definitions.rs | 48 ++++++++++++++++++++++++++++++++- ash/src/vk/enums.rs | 2 ++ ash/src/vk/extensions.rs | 8 ++++++ generator/Vulkan-Headers | 2 +- 8 files changed, 71 insertions(+), 4 deletions(-) diff --git a/Changelog.md b/Changelog.md index 9bf5cc095..f2a48bda2 100644 --- a/Changelog.md +++ b/Changelog.md @@ -10,7 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Added `push()` method to all root structs to insert a single extension-struct in the pointer chain. (#909) -- Update Vulkan-Headers to 1.4.351 (#910, #951, #1040) +- Update Vulkan-Headers to 1.4.352 (#910, #951, #1040) - Added `VK_KHR_get_display_properties2` instance extension (#932) - Added `VK_EXT_display_surface_counter` instance extension (#933) - Added `VK_EXT_display_control` display extension (#934) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index 4a398a77f..577aba1c7 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.38.0+1.4.351" +version = "0.38.0+1.4.352" authors = [ "Maik Klein ", "Benjamin Saunders ", diff --git a/ash/src/extensions_generated.rs b/ash/src/extensions_generated.rs index aa98b56cc..b89314194 100644 --- a/ash/src/extensions_generated.rs +++ b/ash/src/extensions_generated.rs @@ -24435,6 +24435,13 @@ pub mod nv { } } } + #[doc = "VK_NV_cooperative_matrix_decode_vector"] + pub mod cooperative_matrix_decode_vector { + pub use { + crate::vk::NV_COOPERATIVE_MATRIX_DECODE_VECTOR_NAME as NAME, + crate::vk::NV_COOPERATIVE_MATRIX_DECODE_VECTOR_SPEC_VERSION as SPEC_VERSION, + }; + } } #[doc = "Extensions tagged NVX"] pub mod nvx { diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index ab9cb7731..d664bde82 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -2345,6 +2345,7 @@ impl fmt::Debug for DriverId { Self::MESA_HONEYKRISP => Some("MESA_HONEYKRISP"), Self::VULKAN_SC_EMULATION_ON_VULKAN => Some("VULKAN_SC_EMULATION_ON_VULKAN"), Self::MESA_KOSMICKRISP => Some("MESA_KOSMICKRISP"), + Self::MESA_GFXSTREAM => Some("MESA_GFXSTREAM"), _ => None, }; if let Some(x) = name { @@ -8718,6 +8719,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV") + } Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"), Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"), Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"), diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 034364a2a..9f7889bcd 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -63,7 +63,7 @@ pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); #[doc = ""] pub const API_VERSION_1_4: u32 = make_api_version(0, 1, 4, 0); #[doc = ""] -pub const HEADER_VERSION: u32 = 351; +pub const HEADER_VERSION: u32 = 352; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 4, HEADER_VERSION); #[doc = ""] @@ -67188,6 +67188,52 @@ impl<'a> CooperativeMatrixFlexibleDimensionsPropertiesNV<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +#[must_use] +pub struct PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cooperative_matrix_decode_vector: Bool32, + pub _marker: PhantomData<&'a ()>, +} +unsafe impl Send for PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'_> {} +unsafe impl Sync for PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'_> {} +impl ::core::default::Default for PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::core::ptr::null_mut(), + cooperative_matrix_decode_vector: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV; +} +unsafe impl Extends> + for PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'_> +{ +} +unsafe impl Extends> + for PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'_> +{ +} +impl<'a> PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV<'a> { + #[inline] + pub fn cooperative_matrix_decode_vector( + mut self, + cooperative_matrix_decode_vector: bool, + ) -> Self { + self.cooperative_matrix_decode_vector = cooperative_matrix_decode_vector.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] #[must_use] pub struct PhysicalDeviceHdrVividFeaturesHUAWEI<'a> { diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 1871d71f3..f42e21f59 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1836,6 +1836,8 @@ impl DriverId { pub const VULKAN_SC_EMULATION_ON_VULKAN: Self = Self(27); #[doc = "Mesa open source project"] pub const MESA_KOSMICKRISP: Self = Self(28); + #[doc = "Mesa open source project"] + pub const MESA_GFXSTREAM: Self = Self(29); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 91ccef9e7..1f790fcb4 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -5621,6 +5621,11 @@ impl StructureType { impl StructureType { pub const PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT: Self = Self(1_000_678_000); } +#[doc = "Generated from 'VK_NV_cooperative_matrix_decode_vector'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: Self = + Self(1_000_689_000); +} pub const KHR_SURFACE_NAME: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_KHR_surface\0") }; pub const KHR_SURFACE_SPEC_VERSION: u32 = 25u32; @@ -10689,3 +10694,6 @@ pub const EXT_PRIMITIVE_RESTART_INDEX_SPEC_VERSION: u32 = 1u32; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetPrimitiveRestartIndexEXT = unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_restart_index: u32); +pub const NV_COOPERATIVE_MATRIX_DECODE_VECTOR_NAME: &CStr = + unsafe { CStr::from_bytes_with_nul_unchecked(b"VK_NV_cooperative_matrix_decode_vector\0") }; +pub const NV_COOPERATIVE_MATRIX_DECODE_VECTOR_SPEC_VERSION: u32 = 1u32; diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 0e9de566b..015e25c3c 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 0e9de566b7d4051c5cc1b762e242c46565956bdf +Subproject commit 015e25c3c91b70eb1a754d36fb14c4ba6ad9b0b9