kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-04-19 05:51:57 +02:00
Code Issues Packages Projects Releases Wiki Activity

update dependencies (#198)

Browse Source 
Automated changes by
[create-pull-request](https://github.com/peter-evans/create-pull-request)
GitHub action
This commit is contained in:
kbz_8
2026-02-01 13:45:15 +01:00
committed by GitHub
parent 55eb31551a b286da89e2
commit 0ff3085448
15 changed files with 9718 additions and 1415 deletions
Download Patch File Download Diff File Expand all files Collapse all files

181
third_party/vulkan/vulkan.cppm vendored
View File

@@ -625,6 +625,13 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagBitsEXT;
using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT;
//=== VK_EXT_descriptor_heap ===
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceEXT;
using VULKAN_HPP_NAMESPACE::SpirvResourceTypeFlagBitsEXT;
using VULKAN_HPP_NAMESPACE::SpirvResourceTypeFlagsEXT;
using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagBitsARM;
using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagsARM;
//=== VK_EXT_blend_operation_advanced ===
using VULKAN_HPP_NAMESPACE::BlendOverlapEXT;
@@ -890,8 +897,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::TensorTilingARM;
using VULKAN_HPP_NAMESPACE::TensorUsageFlagBitsARM;
using VULKAN_HPP_NAMESPACE::TensorUsageFlagsARM;
using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagBitsARM;
using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagsARM;
//=== VK_NV_optical_flow ===
using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagBitsNV;
@@ -1647,6 +1652,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ShaderIndexUnusedAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
using VULKAN_HPP_NAMESPACE::EXTDescriptorHeapExtensionName;
using VULKAN_HPP_NAMESPACE::EXTDescriptorHeapSpecVersion;
//=== VK_AMD_mixed_attachment_samples ===
using VULKAN_HPP_NAMESPACE::AMDMixedAttachmentSamplesExtensionName;
using VULKAN_HPP_NAMESPACE::AMDMixedAttachmentSamplesSpecVersion;
@@ -1779,6 +1788,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::QCOMRenderPassShaderResolveExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMRenderPassShaderResolveSpecVersion;
//=== VK_QCOM_cooperative_matrix_conversion ===
using VULKAN_HPP_NAMESPACE::QCOMCooperativeMatrixConversionExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMCooperativeMatrixConversionSpecVersion;
//=== VK_EXT_global_priority ===
using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityExtensionName;
using VULKAN_HPP_NAMESPACE::EXTGlobalPrioritySpecVersion;
@@ -2704,6 +2717,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTDynamicRenderingUnusedAttachmentsExtensionName;
using VULKAN_HPP_NAMESPACE::EXTDynamicRenderingUnusedAttachmentsSpecVersion;
//=== VK_KHR_internally_synchronized_queues ===
using VULKAN_HPP_NAMESPACE::KHRInternallySynchronizedQueuesExtensionName;
using VULKAN_HPP_NAMESPACE::KHRInternallySynchronizedQueuesSpecVersion;
//=== VK_NV_low_latency2 ===
using VULKAN_HPP_NAMESPACE::NVLowLatency2ExtensionName;
using VULKAN_HPP_NAMESPACE::NVLowLatency2SpecVersion;
@@ -2902,6 +2919,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::KHRShaderFmaExtensionName;
using VULKAN_HPP_NAMESPACE::KHRShaderFmaSpecVersion;
//=== VK_NV_push_constant_bank ===
using VULKAN_HPP_NAMESPACE::NVPushConstantBankExtensionName;
using VULKAN_HPP_NAMESPACE::NVPushConstantBankSpecVersion;
//=== VK_EXT_ray_tracing_invocation_reorder ===
using VULKAN_HPP_NAMESPACE::EXTRayTracingInvocationReorderExtensionName;
using VULKAN_HPP_NAMESPACE::EXTRayTracingInvocationReorderSpecVersion;
@@ -3020,6 +3041,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVComputeOccupancyPriorityExtensionName;
using VULKAN_HPP_NAMESPACE::NVComputeOccupancyPrioritySpecVersion;
//=== VK_EXT_shader_subgroup_partitioned ===
using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupPartitionedExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupPartitionedSpecVersion;
//========================
//=== CONSTEXPR VALUEs ===
//========================
@@ -4005,6 +4030,36 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
using VULKAN_HPP_NAMESPACE::BindHeapInfoEXT;
using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT;
using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT;
using VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT;
using VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT;
using VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT;
using VULKAN_HPP_NAMESPACE::HostAddressRangeEXT;
using VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT;
using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV;
using VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM;
using VULKAN_HPP_NAMESPACE::PushDataInfoEXT;
using VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT;
using VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT;
using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT;
using VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT;
using VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT;
using VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM;
using VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT;
//=== VK_AMD_mixed_attachment_samples ===
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;
@@ -4127,6 +4182,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT;
//=== VK_QCOM_cooperative_matrix_conversion ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM;
//=== VK_EXT_external_memory_host ===
using VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT;
using VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT;
@@ -4793,7 +4851,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM;
using VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM;
using VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM;
using VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM;
using VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM;
//=== VK_EXT_shader_module_identifier ===
@@ -4941,6 +4998,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_dynamic_rendering_unused_attachments ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
//=== VK_KHR_internally_synchronized_queues ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR;
//=== VK_NV_low_latency2 ===
using VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV;
using VULKAN_HPP_NAMESPACE::LatencySleepInfoNV;
@@ -5224,6 +5284,11 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_shader_fma ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR;
//=== VK_NV_push_constant_bank ===
using VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV;
using VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV;
using VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV;
//=== VK_EXT_ray_tracing_invocation_reorder ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT;
@@ -5352,6 +5417,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityParametersNV;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV;
//=== VK_EXT_shader_subgroup_partitioned ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT;
//===============
//=== HANDLEs ===
//===============
@@ -5416,6 +5484,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_debug_utils ===
using VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
//=== VK_EXT_descriptor_heap ===
using VULKAN_HPP_NAMESPACE::TensorARM;
//=== VK_KHR_acceleration_structure ===
using VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
@@ -5532,6 +5603,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_debug_utils ===
using VULKAN_HPP_NAMESPACE::UniqueDebugUtilsMessengerEXT;
//=== VK_EXT_descriptor_heap ===
using VULKAN_HPP_NAMESPACE::UniqueTensorARM;
//=== VK_KHR_acceleration_structure ===
using VULKAN_HPP_NAMESPACE::UniqueAccelerationStructureKHR;
@@ -5653,6 +5727,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_debug_utils ===
using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT;
//=== VK_EXT_descriptor_heap ===
using VULKAN_HPP_NAMESPACE::SharedTensorARM;
//=== VK_KHR_acceleration_structure ===
using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureKHR;
@@ -5865,6 +5942,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_debug_utils ===
using VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT;
//=== VK_EXT_descriptor_heap ===
using VULKAN_HPP_RAII_NAMESPACE::TensorARM;
//=== VK_KHR_acceleration_structure ===
using VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR;
@@ -6036,6 +6116,10 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>;
//=== VK_EXT_descriptor_heap ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::TensorARM>;
//=== VK_KHR_acceleration_structure ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>;
@@ -7362,6 +7446,64 @@ export namespace std
struct hash<VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstAMDX>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::HostAddressRangeEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::BindHeapInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PushDataInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM>;
//=== VK_AMD_mixed_attachment_samples ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>;
@@ -7562,6 +7704,10 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>;
//=== VK_QCOM_cooperative_matrix_conversion ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>;
//=== VK_EXT_external_memory_host ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>;
@@ -8826,6 +8972,10 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>;
//=== VK_KHR_internally_synchronized_queues ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>;
//=== VK_NV_low_latency2 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV>;
@@ -9292,6 +9442,14 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>;
//=== VK_NV_push_constant_bank ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV>;
//=== VK_EXT_ray_tracing_invocation_reorder ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT>;
@@ -9472,6 +9630,10 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV>;
//=== VK_EXT_shader_subgroup_partitioned ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>;
//=================================================================
//=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain ===
//=================================================================
@@ -9840,6 +10002,7 @@ export
using ::PFN_vkDestroyCuModuleNVX;
//=== VK_NVX_image_view_handle ===
using ::PFN_vkGetDeviceCombinedImageSamplerIndexNVX;
using ::PFN_vkGetImageViewAddressNVX;
using ::PFN_vkGetImageViewHandle64NVX;
using ::PFN_vkGetImageViewHandleNVX;
@@ -10043,6 +10206,18 @@ export
using ::PFN_vkGetExecutionGraphPipelineScratchSizeAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
using ::PFN_vkCmdBindResourceHeapEXT;
using ::PFN_vkCmdBindSamplerHeapEXT;
using ::PFN_vkCmdPushDataEXT;
using ::PFN_vkGetImageOpaqueCaptureDataEXT;
using ::PFN_vkGetPhysicalDeviceDescriptorSizeEXT;
using ::PFN_vkGetTensorOpaqueCaptureDataARM;
using ::PFN_vkRegisterCustomBorderColorEXT;
using ::PFN_vkUnregisterCustomBorderColorEXT;
using ::PFN_vkWriteResourceDescriptorsEXT;
using ::PFN_vkWriteSamplerDescriptorsEXT;
//=== VK_EXT_sample_locations ===
using ::PFN_vkCmdSetSampleLocationsEXT;
using ::PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT;

404
third_party/vulkan/vulkan.hpp vendored
View File

@@ -57,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 339, "Wrong VK_HEADER_VERSION!" );
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 342, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@@ -1098,6 +1098,8 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkCmdBindInvocationMaskHUAWEI )
DECLARE_IS_DISPATCHED( vkCmdBindPipeline )
DECLARE_IS_DISPATCHED( vkCmdBindPipelineShaderGroupNV )
DECLARE_IS_DISPATCHED( vkCmdBindResourceHeapEXT )
DECLARE_IS_DISPATCHED( vkCmdBindSamplerHeapEXT )
DECLARE_IS_DISPATCHED( vkCmdBindShadersEXT )
DECLARE_IS_DISPATCHED( vkCmdBindShadingRateImageNV )
DECLARE_IS_DISPATCHED( vkCmdBindTileMemoryQCOM )
@@ -1217,6 +1219,7 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkCmdPushConstants )
DECLARE_IS_DISPATCHED( vkCmdPushConstants2 )
DECLARE_IS_DISPATCHED( vkCmdPushConstants2KHR )
DECLARE_IS_DISPATCHED( vkCmdPushDataEXT )
DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet )
DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetKHR )
DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet2 )
@@ -1560,6 +1563,7 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkGetDeviceAccelerationStructureCompatibilityKHR )
DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirements )
DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirementsKHR )
DECLARE_IS_DISPATCHED( vkGetDeviceCombinedImageSamplerIndexNVX )
DECLARE_IS_DISPATCHED( vkGetDeviceFaultInfoEXT )
DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeatures )
DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeaturesKHR )
@@ -1606,6 +1610,7 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements )
DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements2 )
DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements2KHR )
DECLARE_IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT )
DECLARE_IS_DISPATCHED( vkGetImageOpaqueCaptureDescriptorDataEXT )
DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements )
DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements2 )
@@ -1646,6 +1651,7 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR )
DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesNV )
DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeVectorPropertiesNV )
DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDescriptorSizeEXT )
DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDirectFBPresentationSupportEXT )
DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPlaneProperties2KHR )
DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPlanePropertiesKHR )
@@ -1754,6 +1760,7 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkGetSwapchainTimeDomainPropertiesEXT )
DECLARE_IS_DISPATCHED( vkGetSwapchainTimingPropertiesEXT )
DECLARE_IS_DISPATCHED( vkGetTensorMemoryRequirementsARM )
DECLARE_IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM )
DECLARE_IS_DISPATCHED( vkGetTensorOpaqueCaptureDescriptorDataARM )
DECLARE_IS_DISPATCHED( vkGetTensorViewOpaqueCaptureDescriptorDataARM )
DECLARE_IS_DISPATCHED( vkGetValidationCacheDataEXT )
@@ -1788,6 +1795,7 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkQueueSubmit2 )
DECLARE_IS_DISPATCHED( vkQueueSubmit2KHR )
DECLARE_IS_DISPATCHED( vkQueueWaitIdle )
DECLARE_IS_DISPATCHED( vkRegisterCustomBorderColorEXT )
DECLARE_IS_DISPATCHED( vkRegisterDeviceEventEXT )
DECLARE_IS_DISPATCHED( vkRegisterDisplayEventEXT )
DECLARE_IS_DISPATCHED( vkReleaseCapturedPipelineDataKHR )
@@ -1828,6 +1836,7 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkUnmapMemory )
DECLARE_IS_DISPATCHED( vkUnmapMemory2 )
DECLARE_IS_DISPATCHED( vkUnmapMemory2KHR )
DECLARE_IS_DISPATCHED( vkUnregisterCustomBorderColorEXT )
DECLARE_IS_DISPATCHED( vkUpdateDescriptorSetWithTemplate )
DECLARE_IS_DISPATCHED( vkUpdateDescriptorSetWithTemplateKHR )
DECLARE_IS_DISPATCHED( vkUpdateDescriptorSets )
@@ -1841,6 +1850,8 @@ namespace VULKAN_HPP_NAMESPACE
DECLARE_IS_DISPATCHED( vkWaitSemaphoresKHR )
DECLARE_IS_DISPATCHED( vkWriteAccelerationStructuresPropertiesKHR )
DECLARE_IS_DISPATCHED( vkWriteMicromapsPropertiesEXT )
DECLARE_IS_DISPATCHED( vkWriteResourceDescriptorsEXT )
DECLARE_IS_DISPATCHED( vkWriteSamplerDescriptorsEXT )
#undef DECLARE_IS_DISPATCHED
@@ -3922,6 +3933,11 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
}
uint64_t vkGetDeviceCombinedImageSamplerIndexNVX( VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetDeviceCombinedImageSamplerIndexNVX( device, imageViewIndex, samplerIndex );
}
//=== VK_AMD_draw_indirect_count ===
void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
@@ -4688,6 +4704,73 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
VkResult vkWriteSamplerDescriptorsEXT( VkDevice device,
uint32_t samplerCount,
const VkSamplerCreateInfo * pSamplers,
const VkHostAddressRangeEXT * pDescriptors ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWriteSamplerDescriptorsEXT( device, samplerCount, pSamplers, pDescriptors );
}
VkResult vkWriteResourceDescriptorsEXT( VkDevice device,
uint32_t resourceCount,
const VkResourceDescriptorInfoEXT * pResources,
const VkHostAddressRangeEXT * pDescriptors ) const VULKAN_HPP_NOEXCEPT
{
return ::vkWriteResourceDescriptorsEXT( device, resourceCount, pResources, pDescriptors );
}
void vkCmdBindSamplerHeapEXT( VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT * pBindInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindSamplerHeapEXT( commandBuffer, pBindInfo );
}
void vkCmdBindResourceHeapEXT( VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT * pBindInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindResourceHeapEXT( commandBuffer, pBindInfo );
}
void vkCmdPushDataEXT( VkCommandBuffer commandBuffer, const VkPushDataInfoEXT * pPushDataInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdPushDataEXT( commandBuffer, pPushDataInfo );
}
VkResult vkGetImageOpaqueCaptureDataEXT( VkDevice device,
uint32_t imageCount,
const VkImage * pImages,
VkHostAddressRangeEXT * pDatas ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetImageOpaqueCaptureDataEXT( device, imageCount, pImages, pDatas );
}
VkDeviceSize vkGetPhysicalDeviceDescriptorSizeEXT( VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetPhysicalDeviceDescriptorSizeEXT( physicalDevice, descriptorType );
}
VkResult vkRegisterCustomBorderColorEXT( VkDevice device,
const VkSamplerCustomBorderColorCreateInfoEXT * pBorderColor,
VkBool32 requestIndex,
uint32_t * pIndex ) const VULKAN_HPP_NOEXCEPT
{
return ::vkRegisterCustomBorderColorEXT( device, pBorderColor, requestIndex, pIndex );
}
void vkUnregisterCustomBorderColorEXT( VkDevice device, uint32_t index ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUnregisterCustomBorderColorEXT( device, index );
}
VkResult vkGetTensorOpaqueCaptureDataARM( VkDevice device,
uint32_t tensorCount,
const VkTensorARM * pTensors,
VkHostAddressRangeEXT * pDatas ) const VULKAN_HPP_NOEXCEPT
{
return ::vkGetTensorOpaqueCaptureDataARM( device, tensorCount, pTensors, pDatas );
}
//=== VK_EXT_sample_locations ===
void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
@@ -9152,6 +9235,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueExtensionName = VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorHeapSpecVersion = VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorHeapExtensionName = VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME;
//=== VK_AMD_mixed_attachment_samples ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesSpecVersion = VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesExtensionName = VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME;
@@ -9284,6 +9371,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveSpecVersion = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveExtensionName = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME;
//=== VK_QCOM_cooperative_matrix_conversion ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMCooperativeMatrixConversionSpecVersion = VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMCooperativeMatrixConversionExtensionName = VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_EXTENSION_NAME;
//=== VK_EXT_global_priority ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPrioritySpecVersion = VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityExtensionName = VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME;
@@ -9733,7 +9824,9 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2ExtensionName = VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME;
//=== VK_EXT_descriptor_buffer ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferSpecVersion = VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION;
VULKAN_HPP_DEPRECATED( "The VK_EXT_descriptor_buffer extension has been deprecated by VK_EXT_descriptor_heap." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferSpecVersion = VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION;
VULKAN_HPP_DEPRECATED( "The VK_EXT_descriptor_buffer extension has been deprecated by VK_EXT_descriptor_heap." )
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferExtensionName = VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME;
//=== VK_EXT_graphics_pipeline_library ===
@@ -10206,6 +10299,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsSpecVersion = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsExtensionName = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME;
//=== VK_KHR_internally_synchronized_queues ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRInternallySynchronizedQueuesSpecVersion = VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRInternallySynchronizedQueuesExtensionName = VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME;
//=== VK_NV_low_latency2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2SpecVersion = VK_NV_LOW_LATENCY_2_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2ExtensionName = VK_NV_LOW_LATENCY_2_EXTENSION_NAME;
@@ -10400,6 +10497,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaSpecVersion = VK_KHR_SHADER_FMA_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaExtensionName = VK_KHR_SHADER_FMA_EXTENSION_NAME;
//=== VK_NV_push_constant_bank ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPushConstantBankSpecVersion = VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto NVPushConstantBankExtensionName = VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME;
//=== VK_EXT_ray_tracing_invocation_reorder ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderSpecVersion = VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderExtensionName = VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME;
@@ -10514,6 +10615,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeOccupancyPrioritySpecVersion = VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeOccupancyPriorityExtensionName = VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME;
//=== VK_EXT_shader_subgroup_partitioned ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedSpecVersion = VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedExtensionName = VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME;
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@@ -13609,6 +13714,24 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<DebugUtilsObjectNameInfoEXT, ResourceDescriptorInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DebugUtilsObjectNameInfoEXT, SamplerCreateInfo>
{
enum
{
value = true
};
};
# if defined( VK_USE_PLATFORM_ANDROID_KHR )
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
template <>
@@ -13732,6 +13855,115 @@ namespace VULKAN_HPP_NAMESPACE
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
template <>
struct StructExtends<ShaderDescriptorSetAndBindingMappingInfoEXT, PipelineShaderStageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ShaderDescriptorSetAndBindingMappingInfoEXT, ShaderCreateInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDataCreateInfoEXT, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<OpaqueCaptureDataCreateInfoEXT, TensorCreateInfoARM>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorHeapFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorHeapFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorHeapPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<CommandBufferInheritanceDescriptorHeapInfoEXT, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SamplerCustomBorderColorIndexCreateInfoEXT, SamplerCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<IndirectCommandsLayoutPushDataTokenNV, IndirectCommandsLayoutTokenNV>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SubsampledImageFormatPropertiesEXT, ImageFormatProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDescriptorHeapTensorPropertiesARM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_AMD_mixed_attachment_samples ===
template <>
struct StructExtends<AttachmentSampleCountInfoAMD, CommandBufferInheritanceInfo>
@@ -14192,6 +14424,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_QCOM_cooperative_matrix_conversion ===
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_external_memory_host ===
template <>
struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo>
@@ -18692,6 +18943,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_internally_synchronized_queues ===
template <>
struct StructExtends<PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_NV_low_latency2 ===
template <>
struct StructExtends<LatencySubmissionPresentIdNV, SubmitInfo>
@@ -20201,6 +20471,70 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_NV_push_constant_bank ===
template <>
struct StructExtends<PushConstantBankInfoNV, DescriptorSetAndBindingMappingEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PushConstantBankInfoNV, PushDataInfoEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PushConstantBankInfoNV, PushConstantsInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PushConstantBankInfoNV, IndirectCommandsLayoutTokenEXT>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePushConstantBankFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePushConstantBankFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePushConstantBankPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_ray_tracing_invocation_reorder ===
template <>
struct StructExtends<PhysicalDeviceRayTracingInvocationReorderPropertiesEXT, PhysicalDeviceProperties2>
@@ -20933,6 +21267,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_EXT_shader_subgroup_partitioned ===
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
namespace detail
@@ -21436,9 +21789,10 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
//=== VK_NVX_image_view_handle ===
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0;
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0;
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
PFN_vkGetDeviceCombinedImageSamplerIndexNVX vkGetDeviceCombinedImageSamplerIndexNVX = 0;
//=== VK_AMD_draw_indirect_count ===
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
@@ -21672,6 +22026,18 @@ namespace VULKAN_HPP_NAMESPACE
PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
PFN_vkWriteSamplerDescriptorsEXT vkWriteSamplerDescriptorsEXT = 0;
PFN_vkWriteResourceDescriptorsEXT vkWriteResourceDescriptorsEXT = 0;
PFN_vkCmdBindSamplerHeapEXT vkCmdBindSamplerHeapEXT = 0;
PFN_vkCmdBindResourceHeapEXT vkCmdBindResourceHeapEXT = 0;
PFN_vkCmdPushDataEXT vkCmdPushDataEXT = 0;
PFN_vkGetImageOpaqueCaptureDataEXT vkGetImageOpaqueCaptureDataEXT = 0;
PFN_vkGetPhysicalDeviceDescriptorSizeEXT vkGetPhysicalDeviceDescriptorSizeEXT = 0;
PFN_vkRegisterCustomBorderColorEXT vkRegisterCustomBorderColorEXT = 0;
PFN_vkUnregisterCustomBorderColorEXT vkUnregisterCustomBorderColorEXT = 0;
PFN_vkGetTensorOpaqueCaptureDataARM vkGetTensorOpaqueCaptureDataARM = 0;
//=== VK_EXT_sample_locations ===
PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
@@ -22815,6 +23181,8 @@ namespace VULKAN_HPP_NAMESPACE
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandle64NVX" ) );
vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) );
vkGetDeviceCombinedImageSamplerIndexNVX =
PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetInstanceProcAddr( instance, "vkGetDeviceCombinedImageSamplerIndexNVX" ) );
//=== VK_AMD_draw_indirect_count ===
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
@@ -23100,6 +23468,19 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectCountAMDX" ) );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetInstanceProcAddr( instance, "vkWriteSamplerDescriptorsEXT" ) );
vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetInstanceProcAddr( instance, "vkWriteResourceDescriptorsEXT" ) );
vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetInstanceProcAddr( instance, "vkCmdBindSamplerHeapEXT" ) );
vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetInstanceProcAddr( instance, "vkCmdBindResourceHeapEXT" ) );
vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetInstanceProcAddr( instance, "vkCmdPushDataEXT" ) );
vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDataEXT" ) );
vkGetPhysicalDeviceDescriptorSizeEXT =
PFN_vkGetPhysicalDeviceDescriptorSizeEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDescriptorSizeEXT" ) );
vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetInstanceProcAddr( instance, "vkRegisterCustomBorderColorEXT" ) );
vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetInstanceProcAddr( instance, "vkUnregisterCustomBorderColorEXT" ) );
vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorOpaqueCaptureDataARM" ) );
//=== VK_EXT_sample_locations ===
vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
vkGetPhysicalDeviceMultisamplePropertiesEXT =
@@ -24290,6 +24671,8 @@ namespace VULKAN_HPP_NAMESPACE
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) );
vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
vkGetDeviceCombinedImageSamplerIndexNVX =
PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetDeviceProcAddr( device, "vkGetDeviceCombinedImageSamplerIndexNVX" ) );
//=== VK_AMD_draw_indirect_count ===
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
@@ -24462,6 +24845,17 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteSamplerDescriptorsEXT" ) );
vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteResourceDescriptorsEXT" ) );
vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindSamplerHeapEXT" ) );
vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindResourceHeapEXT" ) );
vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetDeviceProcAddr( device, "vkCmdPushDataEXT" ) );
vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDataEXT" ) );
vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkRegisterCustomBorderColorEXT" ) );
vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkUnregisterCustomBorderColorEXT" ) );
vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDataARM" ) );
//=== VK_EXT_sample_locations ===
vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );

515
third_party/vulkan/vulkan_core.h vendored
View File

@@ -66,7 +66,7 @@ extern "C" {
//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 339
#define VK_HEADER_VERSION 342
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@@ -655,6 +655,21 @@ typedef enum VkStructureType {
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004,
#endif
VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT = 1000135000,
VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT = 1000135001,
VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT = 1000135002,
VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT = 1000135003,
VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT = 1000135004,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT = 1000135005,
VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT = 1000135006,
VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT = 1000135007,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT = 1000135008,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT = 1000135009,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT = 1000135010,
VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT = 1000135011,
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV = 1000135012,
VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT = 1000135013,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM = 1000135014,
VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR = 1000141000,
VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
@@ -723,6 +738,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,
VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM = 1000172000,
VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
@@ -1163,6 +1179,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR = 1000504000,
VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000,
VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001,
VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002,
@@ -1323,6 +1340,9 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001,
VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR = 1000579000,
VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV = 1000580000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV = 1000580001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV = 1000580002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT = 1000581000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT = 1000581001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000,
@@ -1385,6 +1405,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000,
VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV = 1000645000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV = 1000645001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
// VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias
@@ -2712,9 +2733,9 @@ typedef enum VkImageCreateFlagBits {
VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,
VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT = 0x00010000,
VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,
VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000,
VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000,
VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,
VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000,
@@ -2725,6 +2746,7 @@ typedef enum VkImageCreateFlagBits {
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT,
VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageCreateFlagBits;
@@ -2820,6 +2842,7 @@ typedef VkFlags VkDeviceCreateFlags;
typedef enum VkDeviceQueueCreateFlagBits {
VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR = 0x00000004,
VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkDeviceQueueCreateFlagBits;
typedef VkFlags VkDeviceQueueCreateFlags;
@@ -2958,6 +2981,7 @@ typedef enum VkBufferUsageFlagBits {
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000,
#endif
VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT = 0x10000000,
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000,
VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000,
VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400,
@@ -5543,7 +5567,8 @@ typedef enum VkSubgroupFeatureFlagBits {
VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
VK_SUBGROUP_FEATURE_ROTATE_BIT = 0x00000200,
VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT = 0x00000400,
VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT = 0x00000100,
VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT,
VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_BIT,
VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT,
VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
@@ -7116,6 +7141,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000
static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL;
static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL;
static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;
static const VkAccessFlagBits2 VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT = 0x200000000000000ULL;
static const VkAccessFlagBits2 VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT = 0x400000000000000ULL;
static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;
static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;
static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM = 0x8000000000000ULL;
@@ -7830,7 +7857,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType
typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData);
typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);
typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);
typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);
typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
@@ -8129,6 +8156,7 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT
#ifdef VK_ENABLE_BETA_EXTENSIONS
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000ULL;
#endif
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x10000000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000004ULL;
@@ -8190,6 +8218,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONL
#ifdef VK_ENABLE_BETA_EXTENSIONS
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 0x100000000ULL;
#endif
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x1000000000ULL;
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = 0x00001000ULL;
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 0x200000000ULL;
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL;
@@ -12243,7 +12272,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer
typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos);
typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);
typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
#ifndef VK_NO_PROTOTYPES
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
@@ -12927,6 +12956,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR(
#endif
// VK_KHR_internally_synchronized_queues is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_internally_synchronized_queues 1
#define VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION 1
#define VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME "VK_KHR_internally_synchronized_queues"
typedef struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 internallySynchronizedQueues;
} VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR;
// VK_KHR_cooperative_matrix is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_cooperative_matrix 1
#define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2
@@ -14485,7 +14526,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(
// VK_NVX_image_view_handle is a preprocessor guard. Do not pass it to API calls.
#define VK_NVX_image_view_handle 1
#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 3
#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 4
#define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"
typedef struct VkImageViewHandleInfoNVX {
VkStructureType sType;
@@ -14505,6 +14546,7 @@ typedef struct VkImageViewAddressPropertiesNVX {
typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
typedef uint64_t (VKAPI_PTR *PFN_vkGetImageViewHandle64NVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties);
typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceCombinedImageSamplerIndexNVX)(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex);
#ifndef VK_NO_PROTOTYPES
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
@@ -14525,6 +14567,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(
VkImageView imageView,
VkImageViewAddressPropertiesNVX* pProperties);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceCombinedImageSamplerIndexNVX(
VkDevice device,
uint64_t imageViewIndex,
uint64_t samplerIndex);
#endif
#endif
@@ -15494,6 +15543,380 @@ typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFil
#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
// VK_EXT_descriptor_heap is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_descriptor_heap 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorARM)
#define VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION 1
#define VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME "VK_EXT_descriptor_heap"
typedef enum VkDescriptorMappingSourceEXT {
VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT = 0,
VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT = 1,
VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT = 2,
VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT = 3,
VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT = 4,
VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT = 5,
VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT = 6,
VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT = 7,
VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT = 8,
VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT = 9,
VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT = 10,
VK_DESCRIPTOR_MAPPING_SOURCE_MAX_ENUM_EXT = 0x7FFFFFFF
} VkDescriptorMappingSourceEXT;
typedef VkFlags64 VkTensorViewCreateFlagsARM;
// Flag bits for VkTensorViewCreateFlagBitsARM
typedef VkFlags64 VkTensorViewCreateFlagBitsARM;
static const VkTensorViewCreateFlagBitsARM VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000001ULL;
typedef enum VkSpirvResourceTypeFlagBitsEXT {
VK_SPIRV_RESOURCE_TYPE_ALL_EXT = 0x7FFFFFFF,
VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT = 0x00000001,
VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT = 0x00000002,
VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT = 0x00000004,
VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT = 0x00000008,
VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT = 0x00000010,
VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT = 0x00000020,
VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT = 0x00000040,
VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT = 0x00000080,
VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT = 0x00000100,
VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM = 0x00000200,
VK_SPIRV_RESOURCE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
} VkSpirvResourceTypeFlagBitsEXT;
typedef VkFlags VkSpirvResourceTypeFlagsEXT;
typedef struct VkHostAddressRangeEXT {
void* address;
size_t size;
} VkHostAddressRangeEXT;
typedef struct VkHostAddressRangeConstEXT {
const void* address;
size_t size;
} VkHostAddressRangeConstEXT;
typedef struct VkDeviceAddressRangeEXT {
VkDeviceAddress address;
VkDeviceSize size;
} VkDeviceAddressRangeEXT;
typedef struct VkTexelBufferDescriptorInfoEXT {
VkStructureType sType;
const void* pNext;
VkFormat format;
VkDeviceAddressRangeEXT addressRange;
} VkTexelBufferDescriptorInfoEXT;
typedef struct VkImageDescriptorInfoEXT {
VkStructureType sType;
const void* pNext;
const VkImageViewCreateInfo* pView;
VkImageLayout layout;
} VkImageDescriptorInfoEXT;
typedef struct VkTensorViewCreateInfoARM {
VkStructureType sType;
const void* pNext;
VkTensorViewCreateFlagsARM flags;
VkTensorARM tensor;
VkFormat format;
} VkTensorViewCreateInfoARM;
typedef union VkResourceDescriptorDataEXT {
const VkImageDescriptorInfoEXT* pImage;
const VkTexelBufferDescriptorInfoEXT* pTexelBuffer;
const VkDeviceAddressRangeEXT* pAddressRange;
const VkTensorViewCreateInfoARM* pTensorARM;
} VkResourceDescriptorDataEXT;
typedef struct VkResourceDescriptorInfoEXT {
VkStructureType sType;
const void* pNext;
VkDescriptorType type;
VkResourceDescriptorDataEXT data;
} VkResourceDescriptorInfoEXT;
typedef struct VkBindHeapInfoEXT {
VkStructureType sType;
const void* pNext;
VkDeviceAddressRangeEXT heapRange;
VkDeviceSize reservedRangeOffset;
VkDeviceSize reservedRangeSize;
} VkBindHeapInfoEXT;
typedef struct VkPushDataInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t offset;
VkHostAddressRangeConstEXT data;
} VkPushDataInfoEXT;
typedef struct VkDescriptorMappingSourceConstantOffsetEXT {
uint32_t heapOffset;
uint32_t heapArrayStride;
const VkSamplerCreateInfo* pEmbeddedSampler;
uint32_t samplerHeapOffset;
uint32_t samplerHeapArrayStride;
} VkDescriptorMappingSourceConstantOffsetEXT;
typedef struct VkDescriptorMappingSourcePushIndexEXT {
uint32_t heapOffset;
uint32_t pushOffset;
uint32_t heapIndexStride;
uint32_t heapArrayStride;
const VkSamplerCreateInfo* pEmbeddedSampler;
VkBool32 useCombinedImageSamplerIndex;
uint32_t samplerHeapOffset;
uint32_t samplerPushOffset;
uint32_t samplerHeapIndexStride;
uint32_t samplerHeapArrayStride;
} VkDescriptorMappingSourcePushIndexEXT;
typedef struct VkDescriptorMappingSourceIndirectIndexEXT {
uint32_t heapOffset;
uint32_t pushOffset;
uint32_t addressOffset;
uint32_t heapIndexStride;
uint32_t heapArrayStride;
const VkSamplerCreateInfo* pEmbeddedSampler;
VkBool32 useCombinedImageSamplerIndex;
uint32_t samplerHeapOffset;
uint32_t samplerPushOffset;
uint32_t samplerAddressOffset;
uint32_t samplerHeapIndexStride;
uint32_t samplerHeapArrayStride;
} VkDescriptorMappingSourceIndirectIndexEXT;
typedef struct VkDescriptorMappingSourceHeapDataEXT {
uint32_t heapOffset;
uint32_t pushOffset;
} VkDescriptorMappingSourceHeapDataEXT;
typedef struct VkDescriptorMappingSourceIndirectAddressEXT {
uint32_t pushOffset;
uint32_t addressOffset;
} VkDescriptorMappingSourceIndirectAddressEXT;
typedef struct VkDescriptorMappingSourceShaderRecordIndexEXT {
uint32_t heapOffset;
uint32_t shaderRecordOffset;
uint32_t heapIndexStride;
uint32_t heapArrayStride;
const VkSamplerCreateInfo* pEmbeddedSampler;
VkBool32 useCombinedImageSamplerIndex;
uint32_t samplerHeapOffset;
uint32_t samplerShaderRecordOffset;
uint32_t samplerHeapIndexStride;
uint32_t samplerHeapArrayStride;
} VkDescriptorMappingSourceShaderRecordIndexEXT;
typedef struct VkDescriptorMappingSourceIndirectIndexArrayEXT {
uint32_t heapOffset;
uint32_t pushOffset;
uint32_t addressOffset;
uint32_t heapIndexStride;
const VkSamplerCreateInfo* pEmbeddedSampler;
VkBool32 useCombinedImageSamplerIndex;
uint32_t samplerHeapOffset;
uint32_t samplerPushOffset;
uint32_t samplerAddressOffset;
uint32_t samplerHeapIndexStride;
} VkDescriptorMappingSourceIndirectIndexArrayEXT;
typedef union VkDescriptorMappingSourceDataEXT {
VkDescriptorMappingSourceConstantOffsetEXT constantOffset;
VkDescriptorMappingSourcePushIndexEXT pushIndex;
VkDescriptorMappingSourceIndirectIndexEXT indirectIndex;
VkDescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray;
VkDescriptorMappingSourceHeapDataEXT heapData;
uint32_t pushDataOffset;
uint32_t pushAddressOffset;
VkDescriptorMappingSourceIndirectAddressEXT indirectAddress;
VkDescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex;
uint32_t shaderRecordDataOffset;
uint32_t shaderRecordAddressOffset;
} VkDescriptorMappingSourceDataEXT;
typedef struct VkDescriptorSetAndBindingMappingEXT {
VkStructureType sType;
const void* pNext;
uint32_t descriptorSet;
uint32_t firstBinding;
uint32_t bindingCount;
VkSpirvResourceTypeFlagsEXT resourceMask;
VkDescriptorMappingSourceEXT source;
VkDescriptorMappingSourceDataEXT sourceData;
} VkDescriptorSetAndBindingMappingEXT;
typedef struct VkShaderDescriptorSetAndBindingMappingInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t mappingCount;
const VkDescriptorSetAndBindingMappingEXT* pMappings;
} VkShaderDescriptorSetAndBindingMappingInfoEXT;
typedef struct VkOpaqueCaptureDataCreateInfoEXT {
VkStructureType sType;
const void* pNext;
const VkHostAddressRangeConstEXT* pData;
} VkOpaqueCaptureDataCreateInfoEXT;
typedef struct VkPhysicalDeviceDescriptorHeapFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 descriptorHeap;
VkBool32 descriptorHeapCaptureReplay;
} VkPhysicalDeviceDescriptorHeapFeaturesEXT;
typedef struct VkPhysicalDeviceDescriptorHeapPropertiesEXT {
VkStructureType sType;
void* pNext;
VkDeviceSize samplerHeapAlignment;
VkDeviceSize resourceHeapAlignment;
VkDeviceSize maxSamplerHeapSize;
VkDeviceSize maxResourceHeapSize;
VkDeviceSize minSamplerHeapReservedRange;
VkDeviceSize minSamplerHeapReservedRangeWithEmbedded;
VkDeviceSize minResourceHeapReservedRange;
VkDeviceSize samplerDescriptorSize;
VkDeviceSize imageDescriptorSize;
VkDeviceSize bufferDescriptorSize;
VkDeviceSize samplerDescriptorAlignment;
VkDeviceSize imageDescriptorAlignment;
VkDeviceSize bufferDescriptorAlignment;
VkDeviceSize maxPushDataSize;
size_t imageCaptureReplayOpaqueDataSize;
uint32_t maxDescriptorHeapEmbeddedSamplers;
uint32_t samplerYcbcrConversionCount;
VkBool32 sparseDescriptorHeaps;
VkBool32 protectedDescriptorHeaps;
} VkPhysicalDeviceDescriptorHeapPropertiesEXT;
typedef struct VkCommandBufferInheritanceDescriptorHeapInfoEXT {
VkStructureType sType;
const void* pNext;
const VkBindHeapInfoEXT* pSamplerHeapBindInfo;
const VkBindHeapInfoEXT* pResourceHeapBindInfo;
} VkCommandBufferInheritanceDescriptorHeapInfoEXT;
typedef struct VkSamplerCustomBorderColorIndexCreateInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t index;
} VkSamplerCustomBorderColorIndexCreateInfoEXT;
typedef struct VkSamplerCustomBorderColorCreateInfoEXT {
VkStructureType sType;
const void* pNext;
VkClearColorValue customBorderColor;
VkFormat format;
} VkSamplerCustomBorderColorCreateInfoEXT;
typedef struct VkIndirectCommandsLayoutPushDataTokenNV {
VkStructureType sType;
const void* pNext;
uint32_t pushDataOffset;
uint32_t pushDataSize;
} VkIndirectCommandsLayoutPushDataTokenNV;
typedef struct VkSubsampledImageFormatPropertiesEXT {
VkStructureType sType;
const void* pNext;
uint32_t subsampledImageDescriptorCount;
} VkSubsampledImageFormatPropertiesEXT;
typedef struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM {
VkStructureType sType;
void* pNext;
VkDeviceSize tensorDescriptorSize;
VkDeviceSize tensorDescriptorAlignment;
size_t tensorCaptureReplayOpaqueDataSize;
} VkPhysicalDeviceDescriptorHeapTensorPropertiesARM;
typedef VkResult (VKAPI_PTR *PFN_vkWriteSamplerDescriptorsEXT)(VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors);
typedef VkResult (VKAPI_PTR *PFN_vkWriteResourceDescriptorsEXT)(VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors);
typedef void (VKAPI_PTR *PFN_vkCmdBindSamplerHeapEXT)(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo);
typedef void (VKAPI_PTR *PFN_vkCmdBindResourceHeapEXT)(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo);
typedef void (VKAPI_PTR *PFN_vkCmdPushDataEXT)(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo);
typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDataEXT)(VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas);
typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetPhysicalDeviceDescriptorSizeEXT)(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType);
typedef VkResult (VKAPI_PTR *PFN_vkRegisterCustomBorderColorEXT)(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex);
typedef void (VKAPI_PTR *PFN_vkUnregisterCustomBorderColorEXT)(VkDevice device, uint32_t index);
typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDataARM)(VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas);
#ifndef VK_NO_PROTOTYPES
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(
VkDevice device,
uint32_t samplerCount,
const VkSamplerCreateInfo* pSamplers,
const VkHostAddressRangeEXT* pDescriptors);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkWriteResourceDescriptorsEXT(
VkDevice device,
uint32_t resourceCount,
const VkResourceDescriptorInfoEXT* pResources,
const VkHostAddressRangeEXT* pDescriptors);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdBindSamplerHeapEXT(
VkCommandBuffer commandBuffer,
const VkBindHeapInfoEXT* pBindInfo);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdBindResourceHeapEXT(
VkCommandBuffer commandBuffer,
const VkBindHeapInfoEXT* pBindInfo);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdPushDataEXT(
VkCommandBuffer commandBuffer,
const VkPushDataInfoEXT* pPushDataInfo);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDataEXT(
VkDevice device,
uint32_t imageCount,
const VkImage* pImages,
VkHostAddressRangeEXT* pDatas);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetPhysicalDeviceDescriptorSizeEXT(
VkPhysicalDevice physicalDevice,
VkDescriptorType descriptorType);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterCustomBorderColorEXT(
VkDevice device,
const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor,
VkBool32 requestIndex,
uint32_t* pIndex);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkUnregisterCustomBorderColorEXT(
VkDevice device,
uint32_t index);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM(
VkDevice device,
uint32_t tensorCount,
const VkTensorARM* pTensors,
VkHostAddressRangeEXT* pDatas);
#endif
#endif
// VK_AMD_mixed_attachment_samples is a preprocessor guard. Do not pass it to API calls.
#define VK_AMD_mixed_attachment_samples 1
#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
@@ -16463,6 +16886,18 @@ typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {
#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve"
// VK_QCOM_cooperative_matrix_conversion is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_cooperative_matrix_conversion 1
#define VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION 1
#define VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_EXTENSION_NAME "VK_QCOM_cooperative_matrix_conversion"
typedef struct VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM {
VkStructureType sType;
void* pNext;
VkBool32 cooperativeMatrixConversion;
} VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM;
// VK_EXT_global_priority is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_global_priority 1
#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
@@ -17227,7 +17662,7 @@ VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(
// VK_EXT_fragment_density_map is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_fragment_density_map 1
#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 2
#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 3
#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"
typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
VkStructureType sType;
@@ -18030,6 +18465,7 @@ typedef enum VkIndirectCommandsTokenTypeNV {
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV = 1000135000,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV = 1000428003,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV = 1000428004,
@@ -18405,13 +18841,6 @@ typedef VkPhysicalDeviceRobustness2PropertiesKHR VkPhysicalDeviceRobustness2Prop
#define VK_EXT_custom_border_color 1
#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12
#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color"
typedef struct VkSamplerCustomBorderColorCreateInfoEXT {
VkStructureType sType;
const void* pNext;
VkClearColorValue customBorderColor;
VkFormat format;
} VkSamplerCustomBorderColorCreateInfoEXT;
typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
VkStructureType sType;
void* pNext;
@@ -21252,7 +21681,6 @@ typedef struct VkDirectDriverLoadingListLUNARG {
// VK_ARM_tensors is a preprocessor guard. Do not pass it to API calls.
#define VK_ARM_tensors 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorARM)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorViewARM)
#define VK_ARM_TENSORS_SPEC_VERSION 1
#define VK_ARM_TENSORS_EXTENSION_NAME "VK_ARM_tensors"
@@ -21268,14 +21696,9 @@ typedef VkFlags64 VkTensorCreateFlagsARM;
typedef VkFlags64 VkTensorCreateFlagBitsARM;
static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM = 0x00000001ULL;
static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_PROTECTED_BIT_ARM = 0x00000002ULL;
static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM = 0x00000008ULL;
static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000004ULL;
typedef VkFlags64 VkTensorViewCreateFlagsARM;
// Flag bits for VkTensorViewCreateFlagBitsARM
typedef VkFlags64 VkTensorViewCreateFlagBitsARM;
static const VkTensorViewCreateFlagBitsARM VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000001ULL;
typedef VkFlags64 VkTensorUsageFlagsARM;
// Flag bits for VkTensorUsageFlagBitsARM
@@ -21307,14 +21730,6 @@ typedef struct VkTensorCreateInfoARM {
const uint32_t* pQueueFamilyIndices;
} VkTensorCreateInfoARM;
typedef struct VkTensorViewCreateInfoARM {
VkStructureType sType;
const void* pNext;
VkTensorViewCreateFlagsARM flags;
VkTensorARM tensor;
VkFormat format;
} VkTensorViewCreateInfoARM;
typedef struct VkTensorMemoryRequirementsInfoARM {
VkStructureType sType;
const void* pNext;
@@ -21894,6 +22309,7 @@ typedef enum VkDepthClampModeEXT {
typedef enum VkShaderCreateFlagBitsEXT {
VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001,
VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT = 0x00000400,
VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002,
VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004,
VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008,
@@ -23560,6 +23976,8 @@ typedef enum VkIndirectCommandsTokenTypeEXT {
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = 7,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = 8,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = 9,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT = 1000135000,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT = 1000135001,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = 1000202002,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = 1000202003,
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = 1000328000,
@@ -23858,6 +24276,33 @@ typedef struct VkImageAlignmentControlCreateInfoMESA {
// VK_NV_push_constant_bank is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_push_constant_bank 1
#define VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION 1
#define VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME "VK_NV_push_constant_bank"
typedef struct VkPushConstantBankInfoNV {
VkStructureType sType;
const void* pNext;
uint32_t bank;
} VkPushConstantBankInfoNV;
typedef struct VkPhysicalDevicePushConstantBankFeaturesNV {
VkStructureType sType;
void* pNext;
VkBool32 pushConstantBank;
} VkPhysicalDevicePushConstantBankFeaturesNV;
typedef struct VkPhysicalDevicePushConstantBankPropertiesNV {
VkStructureType sType;
void* pNext;
uint32_t maxGraphicsPushConstantBanks;
uint32_t maxComputePushConstantBanks;
uint32_t maxGraphicsPushDataBanks;
uint32_t maxComputePushDataBanks;
} VkPhysicalDevicePushConstantBankPropertiesNV;
// VK_EXT_ray_tracing_invocation_reorder is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_ray_tracing_invocation_reorder 1
#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1
@@ -24285,6 +24730,18 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV(
#endif
// VK_EXT_shader_subgroup_partitioned is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_shader_subgroup_partitioned 1
#define VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
#define VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_EXT_shader_subgroup_partitioned"
typedef struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 shaderSubgroupPartitioned;
} VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT;
// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_acceleration_structure 1
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

288
third_party/vulkan/vulkan_enums.hpp vendored
View File

@@ -993,6 +993,21 @@ namespace VULKAN_HPP_NAMESPACE
eExecutionGraphPipelineCreateInfoAMDX = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX,
ePipelineShaderStageNodeCreateInfoAMDX = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eTexelBufferDescriptorInfoEXT = VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT,
eImageDescriptorInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT,
eResourceDescriptorInfoEXT = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
eBindHeapInfoEXT = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
ePushDataInfoEXT = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
eDescriptorSetAndBindingMappingEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT,
eShaderDescriptorSetAndBindingMappingInfoEXT = VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT,
eOpaqueCaptureDataCreateInfoEXT = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT,
ePhysicalDeviceDescriptorHeapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT,
ePhysicalDeviceDescriptorHeapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT,
eCommandBufferInheritanceDescriptorHeapInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT,
eSamplerCustomBorderColorIndexCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT,
eIndirectCommandsLayoutPushDataTokenNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV,
eSubsampledImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT,
ePhysicalDeviceDescriptorHeapTensorPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM,
eAttachmentSampleCountInfoAMD = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
eAttachmentSampleCountInfoNV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV,
ePhysicalDeviceShaderBfloat16FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR,
@@ -1041,39 +1056,40 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDevicePortabilitySubsetFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
ePhysicalDevicePortabilitySubsetPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,
eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV,
eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV,
eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
eVideoDecodeH265CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR,
eVideoDecodeH265SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
eVideoDecodeH265SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR,
eVideoDecodeH265ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR,
eVideoDecodeH265PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR,
eVideoDecodeH265DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR,
eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,
eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV,
eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV,
eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
ePhysicalDeviceCooperativeMatrixConversionFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM,
eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
eVideoDecodeH265CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR,
eVideoDecodeH265SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
eVideoDecodeH265SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR,
eVideoDecodeH265ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR,
eVideoDecodeH265PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR,
eVideoDecodeH265DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR,
eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
#if defined( VK_USE_PLATFORM_GGP )
ePresentFrameTokenGGP = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP,
#endif /*VK_USE_PLATFORM_GGP*/
@@ -1522,6 +1538,7 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceShaderCoreBuiltinsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM,
ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT,
ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT,
ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR,
eLatencySleepModeInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV,
eLatencySleepInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV,
eSetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV,
@@ -1689,6 +1706,9 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceImageAlignmentControlPropertiesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA,
eImageAlignmentControlCreateInfoMESA = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA,
ePhysicalDeviceShaderFmaFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR,
ePushConstantBankInfoNV = VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV,
ePhysicalDevicePushConstantBankFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV,
ePhysicalDevicePushConstantBankPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV,
ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT,
ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT,
ePhysicalDeviceDepthClampControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT,
@@ -1760,7 +1780,8 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC,
ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT,
eComputeOccupancyPriorityParametersNV = VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV,
ePhysicalDeviceComputeOccupancyPriorityFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV
ePhysicalDeviceComputeOccupancyPriorityFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV,
ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT
};
// wrapper class for enum VkObjectType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkObjectType.html
@@ -2298,9 +2319,10 @@ namespace VULKAN_HPP_NAMESPACE
eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT,
eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR,
eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV,
eDescriptorHeapCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT,
eDescriptorBufferCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT,
eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT,
eDescriptorBufferCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT,
eMultisampledRenderToSingleSampledEXT = VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT,
e2DViewCompatibleEXT = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT,
eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR,
@@ -2321,7 +2343,7 @@ namespace VULKAN_HPP_NAMESPACE
ImageCreateFlagBits::eCubeCompatible | ImageCreateFlagBits::eAlias | ImageCreateFlagBits::eSplitInstanceBindRegions |
ImageCreateFlagBits::e2DArrayCompatible | ImageCreateFlagBits::eBlockTexelViewCompatible | ImageCreateFlagBits::eExtendedUsage |
ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV |
ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT |
ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT | ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT |
ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT |
ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT;
};
@@ -2554,7 +2576,8 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper class for enum VkDeviceQueueCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlagBits.html
enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags
{
eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT,
eInternallySynchronizedKHR = VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR
};
// wrapper using for bitmask VkDeviceQueueCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlags.html
@@ -2565,7 +2588,8 @@ namespace VULKAN_HPP_NAMESPACE
{
using WrappedType = VkDeviceQueueCreateFlagBits;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = DeviceQueueCreateFlagBits::eProtected;
static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags =
DeviceQueueCreateFlagBits::eProtected | DeviceQueueCreateFlagBits::eInternallySynchronizedKHR;
};
// wrapper class for enum VkPipelineStageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits.html
@@ -2861,6 +2885,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eDescriptorHeapEXT = VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT,
eAccelerationStructureBuildInputReadOnlyKHR = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR,
eAccelerationStructureStorageKHR = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR,
eShaderBindingTableKHR = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
@@ -2892,9 +2917,9 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
| BufferUsageFlagBits::eExecutionGraphScratchAMDX
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
| BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR | BufferUsageFlagBits::eAccelerationStructureStorageKHR |
BufferUsageFlagBits::eShaderBindingTableKHR | BufferUsageFlagBits::eVideoEncodeDstKHR | BufferUsageFlagBits::eVideoEncodeSrcKHR |
BufferUsageFlagBits::eSamplerDescriptorBufferEXT | BufferUsageFlagBits::eResourceDescriptorBufferEXT |
| BufferUsageFlagBits::eDescriptorHeapEXT | BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR |
BufferUsageFlagBits::eAccelerationStructureStorageKHR | BufferUsageFlagBits::eShaderBindingTableKHR | BufferUsageFlagBits::eVideoEncodeDstKHR |
BufferUsageFlagBits::eVideoEncodeSrcKHR | BufferUsageFlagBits::eSamplerDescriptorBufferEXT | BufferUsageFlagBits::eResourceDescriptorBufferEXT |
BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT |
BufferUsageFlagBits::eMicromapStorageEXT | BufferUsageFlagBits::eTileMemoryQCOM;
};
@@ -4603,6 +4628,7 @@ namespace VULKAN_HPP_NAMESPACE
eRotateKHR = VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR,
eRotateClustered = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT,
eRotateClusteredKHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR,
ePartitionedEXT = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT,
ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV
};
@@ -4617,7 +4643,7 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags =
SubgroupFeatureFlagBits::eBasic | SubgroupFeatureFlagBits::eVote | SubgroupFeatureFlagBits::eArithmetic | SubgroupFeatureFlagBits::eBallot |
SubgroupFeatureFlagBits::eShuffle | SubgroupFeatureFlagBits::eShuffleRelative | SubgroupFeatureFlagBits::eClustered | SubgroupFeatureFlagBits::eQuad |
SubgroupFeatureFlagBits::eRotate | SubgroupFeatureFlagBits::eRotateClustered | SubgroupFeatureFlagBits::ePartitionedNV;
SubgroupFeatureFlagBits::eRotate | SubgroupFeatureFlagBits::eRotateClustered | SubgroupFeatureFlagBits::ePartitionedEXT;
};
// wrapper class for enum VkDescriptorUpdateTemplateType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateType.html
@@ -5000,6 +5026,8 @@ namespace VULKAN_HPP_NAMESPACE
eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT,
eVideoDecodeReadKHR = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR,
eVideoDecodeWriteKHR = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
eSamplerHeapReadEXT = VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT,
eResourceHeapReadEXT = VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT,
eVideoEncodeReadKHR = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR,
eVideoEncodeWriteKHR = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR,
eShaderTileAttachmentReadQCOM = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM,
@@ -5051,15 +5079,16 @@ namespace VULKAN_HPP_NAMESPACE
AccessFlagBits2::eDepthStencilAttachmentWrite | AccessFlagBits2::eTransferRead | AccessFlagBits2::eTransferWrite | AccessFlagBits2::eHostRead |
AccessFlagBits2::eHostWrite | AccessFlagBits2::eMemoryRead | AccessFlagBits2::eMemoryWrite | AccessFlagBits2::eShaderSampledRead |
AccessFlagBits2::eShaderStorageRead | AccessFlagBits2::eShaderStorageWrite | AccessFlagBits2::eVideoDecodeReadKHR |
AccessFlagBits2::eVideoDecodeWriteKHR | AccessFlagBits2::eVideoEncodeReadKHR | AccessFlagBits2::eVideoEncodeWriteKHR |
AccessFlagBits2::eShaderTileAttachmentReadQCOM | AccessFlagBits2::eShaderTileAttachmentWriteQCOM | AccessFlagBits2::eTransformFeedbackWriteEXT |
AccessFlagBits2::eTransformFeedbackCounterReadEXT | AccessFlagBits2::eTransformFeedbackCounterWriteEXT | AccessFlagBits2::eConditionalRenderingReadEXT |
AccessFlagBits2::eCommandPreprocessReadEXT | AccessFlagBits2::eCommandPreprocessWriteEXT | AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR |
AccessFlagBits2::eAccelerationStructureReadKHR | AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT |
AccessFlagBits2::eColorAttachmentReadNoncoherentEXT | AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI |
AccessFlagBits2::eShaderBindingTableReadKHR | AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT |
AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV | AccessFlagBits2::eDataGraphReadARM | AccessFlagBits2::eDataGraphWriteARM |
AccessFlagBits2::eMemoryDecompressionReadEXT | AccessFlagBits2::eMemoryDecompressionWriteEXT;
AccessFlagBits2::eVideoDecodeWriteKHR | AccessFlagBits2::eSamplerHeapReadEXT | AccessFlagBits2::eResourceHeapReadEXT |
AccessFlagBits2::eVideoEncodeReadKHR | AccessFlagBits2::eVideoEncodeWriteKHR | AccessFlagBits2::eShaderTileAttachmentReadQCOM |
AccessFlagBits2::eShaderTileAttachmentWriteQCOM | AccessFlagBits2::eTransformFeedbackWriteEXT | AccessFlagBits2::eTransformFeedbackCounterReadEXT |
AccessFlagBits2::eTransformFeedbackCounterWriteEXT | AccessFlagBits2::eConditionalRenderingReadEXT | AccessFlagBits2::eCommandPreprocessReadEXT |
AccessFlagBits2::eCommandPreprocessWriteEXT | AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits2::eAccelerationStructureReadKHR |
AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT | AccessFlagBits2::eColorAttachmentReadNoncoherentEXT |
AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI | AccessFlagBits2::eShaderBindingTableReadKHR |
AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT | AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV |
AccessFlagBits2::eDataGraphReadARM | AccessFlagBits2::eDataGraphWriteARM | AccessFlagBits2::eMemoryDecompressionReadEXT |
AccessFlagBits2::eMemoryDecompressionWriteEXT;
};
// wrapper class for enum VkSubmitFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagBits.html
@@ -5292,6 +5321,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eDescriptorHeapEXT = VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT,
eConditionalRenderingEXT = VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT,
eShaderBindingTableKHR = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR,
eRayTracingNV = VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV,
@@ -5336,12 +5366,13 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
| BufferUsageFlagBits2::eExecutionGraphScratchAMDX
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
| BufferUsageFlagBits2::eConditionalRenderingEXT | BufferUsageFlagBits2::eShaderBindingTableKHR | BufferUsageFlagBits2::eTransformFeedbackBufferEXT |
BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT | BufferUsageFlagBits2::eVideoDecodeSrcKHR | BufferUsageFlagBits2::eVideoDecodeDstKHR |
BufferUsageFlagBits2::eVideoEncodeDstKHR | BufferUsageFlagBits2::eVideoEncodeSrcKHR | BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR |
BufferUsageFlagBits2::eAccelerationStructureStorageKHR | BufferUsageFlagBits2::eSamplerDescriptorBufferEXT |
BufferUsageFlagBits2::eResourceDescriptorBufferEXT | BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT |
BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits2::eMicromapStorageEXT
| BufferUsageFlagBits2::eDescriptorHeapEXT | BufferUsageFlagBits2::eConditionalRenderingEXT | BufferUsageFlagBits2::eShaderBindingTableKHR |
BufferUsageFlagBits2::eTransformFeedbackBufferEXT | BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT | BufferUsageFlagBits2::eVideoDecodeSrcKHR |
BufferUsageFlagBits2::eVideoDecodeDstKHR | BufferUsageFlagBits2::eVideoEncodeDstKHR | BufferUsageFlagBits2::eVideoEncodeSrcKHR |
BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR | BufferUsageFlagBits2::eAccelerationStructureStorageKHR |
BufferUsageFlagBits2::eSamplerDescriptorBufferEXT | BufferUsageFlagBits2::eResourceDescriptorBufferEXT |
BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT |
BufferUsageFlagBits2::eMicromapStorageEXT
#if defined( VK_ENABLE_BETA_EXTENSIONS )
| BufferUsageFlagBits2::eCompressedDataDgf1AMDX
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -5386,6 +5417,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eExecutionGraphAMDX = VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eDescriptorHeapEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT,
eRayTracingAllowSpheresAndLinearSweptSpheresNV = VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV,
eEnableLegacyDitheringEXT = VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT,
eDeferCompileNV = VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV,
@@ -5436,9 +5468,10 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
| PipelineCreateFlagBits2::eExecutionGraphAMDX
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
| PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV | PipelineCreateFlagBits2::eEnableLegacyDitheringEXT |
PipelineCreateFlagBits2::eDeferCompileNV | PipelineCreateFlagBits2::eCaptureStatisticsKHR | PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR |
PipelineCreateFlagBits2::eLinkTimeOptimizationEXT | PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT | PipelineCreateFlagBits2::eLibraryKHR |
| PipelineCreateFlagBits2::eDescriptorHeapEXT | PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV |
PipelineCreateFlagBits2::eEnableLegacyDitheringEXT | PipelineCreateFlagBits2::eDeferCompileNV | PipelineCreateFlagBits2::eCaptureStatisticsKHR |
PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR | PipelineCreateFlagBits2::eLinkTimeOptimizationEXT |
PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT | PipelineCreateFlagBits2::eLibraryKHR |
PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR | PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR |
PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR | PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR |
PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR | PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR |
@@ -6879,6 +6912,72 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCreateFlagsEXT allFlags = {};
};
//=== VK_EXT_descriptor_heap ===
// wrapper class for enum VkDescriptorMappingSourceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceEXT.html
enum class DescriptorMappingSourceEXT
{
eHeapWithConstantOffset = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT,
eHeapWithPushIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT,
eHeapWithIndirectIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT,
eHeapWithIndirectIndexArray = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT,
eResourceHeapData = VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT,
ePushData = VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT,
ePushAddress = VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT,
eIndirectAddress = VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT,
eHeapWithShaderRecordIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT,
eShaderRecordData = VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT,
eShaderRecordAddress = VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT
};
// wrapper class for enum VkSpirvResourceTypeFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagBitsEXT.html
enum class SpirvResourceTypeFlagBitsEXT : VkSpirvResourceTypeFlagsEXT
{
eAll = VK_SPIRV_RESOURCE_TYPE_ALL_EXT,
eSampler = VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT,
eSampledImage = VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT,
eReadOnlyImage = VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT,
eReadWriteImage = VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT,
eCombinedSampledImage = VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT,
eUniformBuffer = VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT,
eReadOnlyStorageBuffer = VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT,
eReadWriteStorageBuffer = VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT,
eAccelerationStructure = VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT,
eTensorARM = VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM
};
// wrapper using for bitmask VkSpirvResourceTypeFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagsEXT.html
using SpirvResourceTypeFlagsEXT = Flags<SpirvResourceTypeFlagBitsEXT>;
template <>
struct FlagTraits<SpirvResourceTypeFlagBitsEXT>
{
using WrappedType = VkSpirvResourceTypeFlagBitsEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR SpirvResourceTypeFlagsEXT allFlags =
SpirvResourceTypeFlagBitsEXT::eAll | SpirvResourceTypeFlagBitsEXT::eSampler | SpirvResourceTypeFlagBitsEXT::eSampledImage |
SpirvResourceTypeFlagBitsEXT::eReadOnlyImage | SpirvResourceTypeFlagBitsEXT::eReadWriteImage | SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage |
SpirvResourceTypeFlagBitsEXT::eUniformBuffer | SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer |
SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer | SpirvResourceTypeFlagBitsEXT::eAccelerationStructure | SpirvResourceTypeFlagBitsEXT::eTensorARM;
};
// wrapper class for enum VkTensorViewCreateFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagBitsARM.html
enum class TensorViewCreateFlagBitsARM : VkTensorViewCreateFlagsARM
{
eDescriptorBufferCaptureReplay = VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM
};
// wrapper using for bitmask VkTensorViewCreateFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagsARM.html
using TensorViewCreateFlagsARM = Flags<TensorViewCreateFlagBitsARM>;
template <>
struct FlagTraits<TensorViewCreateFlagBitsARM>
{
using WrappedType = VkTensorViewCreateFlagBitsARM;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR TensorViewCreateFlagsARM allFlags = TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay;
};
//=== VK_EXT_blend_operation_advanced ===
// wrapper class for enum VkBlendOverlapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendOverlapEXT.html
@@ -7527,6 +7626,7 @@ namespace VULKAN_HPP_NAMESPACE
eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV,
eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV,
eDrawTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV,
ePushData = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV,
eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV,
ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV,
eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV
@@ -8405,6 +8505,7 @@ namespace VULKAN_HPP_NAMESPACE
{
eMutableFormat = VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM,
eProtected = VK_TENSOR_CREATE_PROTECTED_BIT_ARM,
eDescriptorHeapCaptureReplay = VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM,
eDescriptorBufferCaptureReplay = VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM
};
@@ -8416,25 +8517,9 @@ namespace VULKAN_HPP_NAMESPACE
{
using WrappedType = VkTensorCreateFlagBitsARM;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR TensorCreateFlagsARM allFlags =
TensorCreateFlagBitsARM::eMutableFormat | TensorCreateFlagBitsARM::eProtected | TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay;
};
// wrapper class for enum VkTensorViewCreateFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagBitsARM.html
enum class TensorViewCreateFlagBitsARM : VkTensorViewCreateFlagsARM
{
eDescriptorBufferCaptureReplay = VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM
};
// wrapper using for bitmask VkTensorViewCreateFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagsARM.html
using TensorViewCreateFlagsARM = Flags<TensorViewCreateFlagBitsARM>;
template <>
struct FlagTraits<TensorViewCreateFlagBitsARM>
{
using WrappedType = VkTensorViewCreateFlagBitsARM;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR TensorViewCreateFlagsARM allFlags = TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay;
static VULKAN_HPP_CONST_OR_CONSTEXPR TensorCreateFlagsARM allFlags = TensorCreateFlagBitsARM::eMutableFormat | TensorCreateFlagBitsARM::eProtected |
TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay |
TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay;
};
// wrapper class for enum VkTensorUsageFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorUsageFlagBitsARM.html
@@ -8617,6 +8702,7 @@ namespace VULKAN_HPP_NAMESPACE
enum class ShaderCreateFlagBitsEXT : VkShaderCreateFlagsEXT
{
eLinkStage = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT,
eDescriptorHeap = VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT,
eAllowVaryingSubgroupSize = VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT,
eRequireFullSubgroups = VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT,
eNoTaskShader = VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT,
@@ -8636,9 +8722,10 @@ namespace VULKAN_HPP_NAMESPACE
using WrappedType = VkShaderCreateFlagBitsEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCreateFlagsEXT allFlags =
ShaderCreateFlagBitsEXT::eLinkStage | ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize | ShaderCreateFlagBitsEXT::eRequireFullSubgroups |
ShaderCreateFlagBitsEXT::eNoTaskShader | ShaderCreateFlagBitsEXT::eDispatchBase | ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment |
ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment | ShaderCreateFlagBitsEXT::eIndirectBindable | ShaderCreateFlagBitsEXT::e64BitIndexing;
ShaderCreateFlagBitsEXT::eLinkStage | ShaderCreateFlagBitsEXT::eDescriptorHeap | ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize |
ShaderCreateFlagBitsEXT::eRequireFullSubgroups | ShaderCreateFlagBitsEXT::eNoTaskShader | ShaderCreateFlagBitsEXT::eDispatchBase |
ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment | ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment |
ShaderCreateFlagBitsEXT::eIndirectBindable | ShaderCreateFlagBitsEXT::e64BitIndexing;
};
// wrapper class for enum VkShaderCodeTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCodeTypeEXT.html
@@ -9361,21 +9448,23 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper class for enum VkIndirectCommandsTokenTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsTokenTypeEXT.html
enum class IndirectCommandsTokenTypeEXT
{
eExecutionSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT,
ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT,
eSequenceIndex = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT,
eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT,
eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT,
eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT,
eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT,
eDrawIndexedCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT,
eDrawCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT,
eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT,
eDrawMeshTasksNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT,
eDrawMeshTasksCountNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT,
eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT,
eDrawMeshTasksCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT,
eTraceRays2 = VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT
eExecutionSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT,
ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT,
eSequenceIndex = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT,
eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT,
eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT,
eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT,
eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT,
eDrawIndexedCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT,
eDrawCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT,
eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT,
ePushData = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT,
ePushDataSequenceIndex = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT,
eDrawMeshTasksNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT,
eDrawMeshTasksCountNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT,
eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT,
eDrawMeshTasksCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT,
eTraceRays2 = VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT
};
// wrapper class for enum VkIndirectExecutionSetInfoTypeEXT, see
@@ -9640,6 +9729,10 @@ namespace VULKAN_HPP_NAMESPACE
case ObjectType::eDebugUtilsMessengerEXT:
return DebugReportObjectTypeEXT::eUnknown;
//=== VK_EXT_descriptor_heap ===
case ObjectType::eTensorARM:
return DebugReportObjectTypeEXT::eUnknown;
//=== VK_KHR_acceleration_structure ===
case ObjectType::eAccelerationStructureKHR:
return DebugReportObjectTypeEXT::eAccelerationStructureKHR;
@@ -9679,7 +9772,6 @@ namespace VULKAN_HPP_NAMESPACE
return DebugReportObjectTypeEXT::eUnknown;
//=== VK_ARM_tensors ===
case ObjectType::eTensorARM: return DebugReportObjectTypeEXT::eUnknown;
case ObjectType::eTensorViewARM:
return DebugReportObjectTypeEXT::eUnknown;

107
third_party/vulkan/vulkan_extension_inspection.hpp vendored
View File

@@ -67,6 +67,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" },
{ "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" },
{ "VK_EXT_validation_features", "VK_EXT_layer_settings" },
{ "VK_EXT_descriptor_buffer", "VK_EXT_descriptor_heap" },
#if defined( VK_ENABLE_BETA_EXTENSIONS )
{ "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -175,6 +176,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_AMDX_shader_enqueue",
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
"VK_EXT_descriptor_heap",
"VK_AMD_mixed_attachment_samples",
"VK_AMD_shader_fragment_mask",
"VK_EXT_inline_uniform_block",
@@ -209,6 +211,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_draw_indirect_count",
"VK_EXT_filter_cubic",
"VK_QCOM_render_pass_shader_resolve",
"VK_QCOM_cooperative_matrix_conversion",
"VK_EXT_global_priority",
"VK_KHR_shader_subgroup_extended_types",
"VK_KHR_8bit_storage",
@@ -436,6 +439,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_ARM_shader_core_builtins",
"VK_EXT_pipeline_library_group_handles",
"VK_EXT_dynamic_rendering_unused_attachments",
"VK_KHR_internally_synchronized_queues",
"VK_NV_low_latency2",
"VK_KHR_cooperative_matrix",
"VK_ARM_data_graph",
@@ -485,6 +489,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_maintenance8",
"VK_MESA_image_alignment_control",
"VK_KHR_shader_fma",
"VK_NV_push_constant_bank",
"VK_EXT_ray_tracing_invocation_reorder",
"VK_EXT_depth_clamp_control",
"VK_KHR_maintenance9",
@@ -514,7 +519,8 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_shader_long_vector",
"VK_SEC_pipeline_cache_incremental_mode",
"VK_EXT_shader_uniform_buffer_unsized_array",
"VK_NV_compute_occupancy_priority" };
"VK_NV_compute_occupancy_priority",
"VK_EXT_shader_subgroup_partitioned" };
return deviceExtensions;
}
@@ -1105,6 +1111,16 @@ namespace VULKAN_HPP_NAMESPACE
} } } } }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
,
{ "VK_EXT_descriptor_heap",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_buffer_device_address",
"VK_KHR_maintenance5",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_maintenance5",
} } } } },
{ "VK_EXT_inline_uniform_block",
{ { "VK_VERSION_1_0",
{ {
@@ -1226,6 +1242,11 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_QCOM_cooperative_matrix_conversion",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_cooperative_matrix",
} } } } },
{ "VK_KHR_shader_subgroup_extended_types", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_8bit_storage",
{ { "VK_VERSION_1_0",
@@ -1817,11 +1838,8 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_QCOM_tile_shading",
{ { "VK_VERSION_1_0",
{ {
"VK_QCOM_tile_properties",
},
{
"VK_KHR_get_physical_device_properties2",
} } } } },
"VK_QCOM_tile_properties",
} } } } },
{ "VK_KHR_synchronization2",
{ { "VK_VERSION_1_0",
{ {
@@ -2498,22 +2516,21 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_KHR_surface_maintenance1",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
},
{
"VK_KHR_get_surface_capabilities2",
} } } } },
"VK_KHR_get_surface_capabilities2",
"VK_KHR_surface",
} } } } },
{ "VK_KHR_swapchain_maintenance1",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_swapchain",
},
{
"VK_KHR_surface_maintenance1",
},
{
"VK_KHR_get_physical_device_properties2",
} } } } },
"VK_KHR_get_physical_device_properties2",
"VK_KHR_surface_maintenance1",
"VK_KHR_swapchain",
} } },
{ "VK_VERSION_1_1",
{ {
"VK_KHR_surface_maintenance1",
"VK_KHR_swapchain",
} } } } },
{ "VK_QCOM_multiview_per_view_viewports",
{ { "VK_VERSION_1_0",
{ {
@@ -2571,6 +2588,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_dynamic_rendering",
} } },
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_KHR_internally_synchronized_queues", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_low_latency2",
{ { "VK_VERSION_1_0",
{ {
@@ -3041,6 +3059,12 @@ namespace VULKAN_HPP_NAMESPACE
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_compute_occupancy_priority",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_shader_subgroup_partitioned",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
@@ -3141,6 +3165,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_EXT_pipeline_creation_feedback", "VK_VERSION_1_3" },
{ "VK_KHR_driver_properties", "VK_VERSION_1_2" },
{ "VK_KHR_shader_float_controls", "VK_VERSION_1_2" },
{ "VK_NV_shader_subgroup_partitioned", "VK_EXT_shader_subgroup_partitioned" },
{ "VK_KHR_depth_stencil_resolve", "VK_VERSION_1_2" },
{ "VK_NV_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives" },
{ "VK_NV_fragment_shader_barycentric", "VK_KHR_fragment_shader_barycentric" },
@@ -3281,6 +3306,10 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_EXT_layer_settings";
}
if ( extension == "VK_EXT_descriptor_buffer" )
{
return "VK_EXT_descriptor_heap";
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( extension == "VK_NV_displacement_micromap" )
{
@@ -3508,6 +3537,10 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_VERSION_1_2";
}
if ( extension == "VK_NV_shader_subgroup_partitioned" )
{
return "VK_EXT_shader_subgroup_partitioned";
}
if ( extension == "VK_KHR_depth_stencil_resolve" )
{
return "VK_VERSION_1_2";
@@ -3767,7 +3800,7 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_MVK_macos_surface" )
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
|| ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
( extension == "VK_EXT_validation_features" )
( extension == "VK_EXT_validation_features" ) || ( extension == "VK_EXT_descriptor_buffer" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_displacement_micromap" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@@ -3830,7 +3863,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_AMDX_shader_enqueue" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|| ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
|| ( extension == "VK_EXT_descriptor_heap" ) || ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) ||
( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) ||
@@ -3845,8 +3878,8 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|| ( extension == "VK_NV_shading_rate_image" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_NV_representative_fragment_test" ) ||
( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) || ( extension == "VK_EXT_filter_cubic" ) ||
( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_EXT_global_priority" ) ||
( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_QCOM_cooperative_matrix_conversion" ) ||
( extension == "VK_EXT_global_priority" ) || ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
( extension == "VK_EXT_external_memory_host" ) || ( extension == "VK_AMD_buffer_marker" ) || ( extension == "VK_KHR_shader_atomic_int64" ) ||
( extension == "VK_KHR_shader_clock" ) || ( extension == "VK_AMD_pipeline_compiler_control" ) || ( extension == "VK_EXT_calibrated_timestamps" ) ||
( extension == "VK_AMD_shader_core_properties" ) || ( extension == "VK_KHR_video_decode_h265" ) || ( extension == "VK_KHR_global_priority" ) ||
@@ -3962,14 +3995,14 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_NV_cooperative_vector" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
( extension == "VK_KHR_compute_shader_derivatives" ) || ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) ||
( extension == "VK_KHR_video_decode_vp9" ) || ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) ||
( extension == "VK_QCOM_image_processing2" ) || ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) ||
( extension == "VK_QCOM_filter_cubic_clamp" ) || ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) ||
( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
( extension == "VK_KHR_unified_image_layouts" ) || ( extension == "VK_KHR_shader_float_controls2" )
( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_KHR_internally_synchronized_queues" ) ||
( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) ||
( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) ||
( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_decode_vp9" ) ||
( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_unified_image_layouts" ) || ( extension == "VK_KHR_shader_float_controls2" )
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|| ( extension == "VK_QNX_external_memory_screen_buffer" )
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
@@ -3985,9 +4018,9 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) ||
( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) ||
( extension == "VK_EXT_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
( extension == "VK_NV_push_constant_bank" ) || ( extension == "VK_EXT_ray_tracing_invocation_reorder" ) ||
( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) ||
( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
@@ -4001,7 +4034,8 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) ||
( extension == "VK_EXT_custom_resolve" ) || ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) ||
( extension == "VK_EXT_shader_long_vector" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" );
( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" ) ||
( extension == "VK_EXT_shader_subgroup_partitioned" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@@ -4099,7 +4133,8 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || ( extension == "VK_KHR_global_priority" ) ||
( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_EXT_pipeline_creation_feedback" ) ||
( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) ||
( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) ||
( extension == "VK_NV_shader_subgroup_partitioned" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) ||
( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) ||
( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_KHR_vulkan_memory_model" ) ||
( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_scalar_block_layout" ) ||

384
third_party/vulkan/vulkan_funcs.hpp vendored
View File

@@ -12503,6 +12503,17 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetDeviceCombinedImageSamplerIndexNVX ), bool>::type>
VULKAN_HPP_INLINE uint64_t Device::getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex,
uint64_t samplerIndex,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return d.vkGetDeviceCombinedImageSamplerIndexNVX( static_cast<VkDevice>( m_device ), imageViewIndex, samplerIndex );
}
//=== VK_AMD_draw_indirect_count ===
// wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html
@@ -17011,6 +17022,379 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkWriteSamplerDescriptorsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkWriteSamplerDescriptorsEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeSamplerDescriptorsEXT( uint32_t samplerCount,
const SamplerCreateInfo * pSamplers,
const HostAddressRangeEXT * pDescriptors,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkWriteSamplerDescriptorsEXT( static_cast<VkDevice>( m_device ),
samplerCount,
reinterpret_cast<const VkSamplerCreateInfo *>( pSamplers ),
reinterpret_cast<const VkHostAddressRangeEXT *>( pDescriptors ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkWriteSamplerDescriptorsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkWriteSamplerDescriptorsEXT ), bool>::type>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::writeSamplerDescriptorsEXT(
ArrayProxy<const SamplerCreateInfo> const & samplers, ArrayProxy<const HostAddressRangeEXT> const & descriptors, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkWriteSamplerDescriptorsEXT && "Function <vkWriteSamplerDescriptorsEXT> requires <VK_EXT_descriptor_heap>" );
# endif
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( samplers.size() == descriptors.size() );
# else
if ( samplers.size() != descriptors.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT: samplers.size() != descriptors.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
Result result = static_cast<Result>( d.vkWriteSamplerDescriptorsEXT( m_device,
samplers.size(),
reinterpret_cast<const VkSamplerCreateInfo *>( samplers.data() ),
reinterpret_cast<const VkHostAddressRangeEXT *>( descriptors.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT" );
return detail::createResultValueType( result );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkWriteResourceDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkWriteResourceDescriptorsEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeResourceDescriptorsEXT( uint32_t resourceCount,
const ResourceDescriptorInfoEXT * pResources,
const HostAddressRangeEXT * pDescriptors,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkWriteResourceDescriptorsEXT( static_cast<VkDevice>( m_device ),
resourceCount,
reinterpret_cast<const VkResourceDescriptorInfoEXT *>( pResources ),
reinterpret_cast<const VkHostAddressRangeEXT *>( pDescriptors ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkWriteResourceDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkWriteResourceDescriptorsEXT ), bool>::type>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::writeResourceDescriptorsEXT(
ArrayProxy<const ResourceDescriptorInfoEXT> const & resources, ArrayProxy<const HostAddressRangeEXT> const & descriptors, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkWriteResourceDescriptorsEXT && "Function <vkWriteResourceDescriptorsEXT> requires <VK_EXT_descriptor_heap>" );
# endif
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( resources.size() == descriptors.size() );
# else
if ( resources.size() != descriptors.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT: resources.size() != descriptors.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
Result result = static_cast<Result>( d.vkWriteResourceDescriptorsEXT( m_device,
resources.size(),
reinterpret_cast<const VkResourceDescriptorInfoEXT *>( resources.data() ),
reinterpret_cast<const VkHostAddressRangeEXT *>( descriptors.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT" );
return detail::createResultValueType( result );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdBindSamplerHeapEXT ), bool>::type>
VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdBindSamplerHeapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBindHeapInfoEXT *>( pBindInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdBindSamplerHeapEXT ), bool>::type>
VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdBindSamplerHeapEXT && "Function <vkCmdBindSamplerHeapEXT> requires <VK_EXT_descriptor_heap>" );
# endif
d.vkCmdBindSamplerHeapEXT( m_commandBuffer, reinterpret_cast<const VkBindHeapInfoEXT *>( &bindInfo ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdBindResourceHeapEXT ), bool>::type>
VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdBindResourceHeapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBindHeapInfoEXT *>( pBindInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdBindResourceHeapEXT ), bool>::type>
VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdBindResourceHeapEXT && "Function <vkCmdBindResourceHeapEXT> requires <VK_EXT_descriptor_heap>" );
# endif
d.vkCmdBindResourceHeapEXT( m_commandBuffer, reinterpret_cast<const VkBindHeapInfoEXT *>( &bindInfo ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdPushDataEXT ), bool>::type>
VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT * pPushDataInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdPushDataEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPushDataInfoEXT *>( pPushDataInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkCmdPushDataEXT ), bool>::type>
VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT & pushDataInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdPushDataEXT && "Function <vkCmdPushDataEXT> requires <VK_EXT_descriptor_heap>" );
# endif
d.vkCmdPushDataEXT( m_commandBuffer, reinterpret_cast<const VkPushDataInfoEXT *>( &pushDataInfo ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageOpaqueCaptureDataEXT( uint32_t imageCount,
const Image * pImages,
HostAddressRangeEXT * pDatas,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetImageOpaqueCaptureDataEXT(
static_cast<VkDevice>( m_device ), imageCount, reinterpret_cast<const VkImage *>( pImages ), reinterpret_cast<VkHostAddressRangeEXT *>( pDatas ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename HostAddressRangeEXTAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
Device::getImageOpaqueCaptureDataEXT( ArrayProxy<const Image> const & images, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function <vkGetImageOpaqueCaptureDataEXT> requires <VK_EXT_descriptor_heap>" );
# endif
std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator> datas( images.size() );
Result result = static_cast<Result>( d.vkGetImageOpaqueCaptureDataEXT(
m_device, images.size(), reinterpret_cast<const VkImage *>( images.data() ), reinterpret_cast<VkHostAddressRangeEXT *>( datas.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" );
return detail::createResultValueType( result, std::move( datas ) );
}
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename HostAddressRangeEXTAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
Device::getImageOpaqueCaptureDataEXT( ArrayProxy<const Image> const & images,
HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function <vkGetImageOpaqueCaptureDataEXT> requires <VK_EXT_descriptor_heap>" );
# endif
std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator> datas( images.size(), {}, hostAddressRangeEXTAllocator );
Result result = static_cast<Result>( d.vkGetImageOpaqueCaptureDataEXT(
m_device, images.size(), reinterpret_cast<const VkImage *>( images.data() ), reinterpret_cast<VkHostAddressRangeEXT *>( datas.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" );
return detail::createResultValueType( result, std::move( datas ) );
}
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HostAddressRangeEXT>::type Device::getImageOpaqueCaptureDataEXT( const Image & image,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function <vkGetImageOpaqueCaptureDataEXT> requires <VK_EXT_descriptor_heap>" );
# endif
HostAddressRangeEXT data;
Result result = static_cast<Result>(
d.vkGetImageOpaqueCaptureDataEXT( m_device, 1, reinterpret_cast<const VkImage *>( &image ), reinterpret_cast<VkHostAddressRangeEXT *>( &data ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" );
return detail::createResultValueType( result, std::move( data ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceDescriptorSizeEXT ), bool>::type>
VULKAN_HPP_INLINE DeviceSize PhysicalDevice::getDescriptorSizeEXT( DescriptorType descriptorType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<DeviceSize>(
d.vkGetPhysicalDeviceDescriptorSizeEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDescriptorType>( descriptorType ) ) );
}
// wrapper function for command vkRegisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkRegisterCustomBorderColorEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT * pBorderColor,
Bool32 requestIndex,
uint32_t * pIndex,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkRegisterCustomBorderColorEXT( static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>( pBorderColor ),
static_cast<VkBool32>( requestIndex ),
pIndex ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkRegisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkRegisterCustomBorderColorEXT ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type
Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkRegisterCustomBorderColorEXT && "Function <vkRegisterCustomBorderColorEXT> requires <VK_EXT_descriptor_heap>" );
# endif
uint32_t index;
Result result = static_cast<Result>( d.vkRegisterCustomBorderColorEXT(
m_device, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>( &borderColor ), static_cast<VkBool32>( requestIndex ), &index ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerCustomBorderColorEXT" );
return detail::createResultValueType( result, std::move( index ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkUnregisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkUnregisterCustomBorderColorEXT ), bool>::type>
VULKAN_HPP_INLINE void Device::unregisterCustomBorderColorEXT( uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkUnregisterCustomBorderColorEXT( static_cast<VkDevice>( m_device ), index );
}
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorOpaqueCaptureDataARM( uint32_t tensorCount,
const TensorARM * pTensors,
HostAddressRangeEXT * pDatas,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkGetTensorOpaqueCaptureDataARM( static_cast<VkDevice>( m_device ),
tensorCount,
reinterpret_cast<const VkTensorARM *>( pTensors ),
reinterpret_cast<VkHostAddressRangeEXT *>( pDatas ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename HostAddressRangeEXTAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
Device::getTensorOpaqueCaptureDataARM( ArrayProxy<const TensorARM> const & tensors, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function <vkGetTensorOpaqueCaptureDataARM> requires <VK_EXT_descriptor_heap>" );
# endif
std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator> datas( tensors.size() );
Result result = static_cast<Result>( d.vkGetTensorOpaqueCaptureDataARM(
m_device, tensors.size(), reinterpret_cast<const VkTensorARM *>( tensors.data() ), reinterpret_cast<VkHostAddressRangeEXT *>( datas.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" );
return detail::createResultValueType( result, std::move( datas ) );
}
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename HostAddressRangeEXTAllocator,
typename Dispatch,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
Device::getTensorOpaqueCaptureDataARM( ArrayProxy<const TensorARM> const & tensors,
HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function <vkGetTensorOpaqueCaptureDataARM> requires <VK_EXT_descriptor_heap>" );
# endif
std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator> datas( tensors.size(), {}, hostAddressRangeEXTAllocator );
Result result = static_cast<Result>( d.vkGetTensorOpaqueCaptureDataARM(
m_device, tensors.size(), reinterpret_cast<const VkTensorARM *>( tensors.data() ), reinterpret_cast<VkHostAddressRangeEXT *>( datas.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" );
return detail::createResultValueType( result, std::move( datas ) );
}
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HostAddressRangeEXT>::type Device::getTensorOpaqueCaptureDataARM( const TensorARM & tensor,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function <vkGetTensorOpaqueCaptureDataARM> requires <VK_EXT_descriptor_heap>" );
# endif
HostAddressRangeEXT data;
Result result = static_cast<Result>(
d.vkGetTensorOpaqueCaptureDataARM( m_device, 1, reinterpret_cast<const VkTensorARM *>( &tensor ), reinterpret_cast<VkHostAddressRangeEXT *>( &data ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" );
return detail::createResultValueType( result, std::move( data ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_sample_locations ===
// wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html

243
third_party/vulkan/vulkan_handles.hpp vendored
View File

@@ -945,6 +945,36 @@ namespace VULKAN_HPP_NAMESPACE
union DeviceOrHostAddressConstAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
struct HostAddressRangeEXT;
struct HostAddressRangeConstEXT;
struct DeviceAddressRangeEXT;
struct TexelBufferDescriptorInfoEXT;
struct ImageDescriptorInfoEXT;
struct ResourceDescriptorInfoEXT;
union ResourceDescriptorDataEXT;
struct BindHeapInfoEXT;
struct PushDataInfoEXT;
struct DescriptorMappingSourceConstantOffsetEXT;
struct DescriptorMappingSourcePushIndexEXT;
struct DescriptorMappingSourceIndirectIndexEXT;
struct DescriptorMappingSourceHeapDataEXT;
struct DescriptorMappingSourceIndirectAddressEXT;
struct DescriptorMappingSourceShaderRecordIndexEXT;
union DescriptorMappingSourceDataEXT;
struct DescriptorMappingSourceIndirectIndexArrayEXT;
struct DescriptorSetAndBindingMappingEXT;
struct ShaderDescriptorSetAndBindingMappingInfoEXT;
struct OpaqueCaptureDataCreateInfoEXT;
struct PhysicalDeviceDescriptorHeapFeaturesEXT;
struct PhysicalDeviceDescriptorHeapPropertiesEXT;
struct CommandBufferInheritanceDescriptorHeapInfoEXT;
struct SamplerCustomBorderColorIndexCreateInfoEXT;
struct IndirectCommandsLayoutPushDataTokenNV;
struct SubsampledImageFormatPropertiesEXT;
struct TensorViewCreateInfoARM;
struct PhysicalDeviceDescriptorHeapTensorPropertiesARM;
//=== VK_AMD_mixed_attachment_samples ===
struct AttachmentSampleCountInfoAMD;
using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
@@ -1067,6 +1097,9 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceImageViewImageFormatInfoEXT;
struct FilterCubicImageViewImageFormatPropertiesEXT;
//=== VK_QCOM_cooperative_matrix_conversion ===
struct PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM;
//=== VK_EXT_external_memory_host ===
struct ImportMemoryHostPointerInfoEXT;
struct MemoryHostPointerPropertiesEXT;
@@ -1713,7 +1746,6 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_ARM_tensors ===
struct TensorDescriptionARM;
struct TensorCreateInfoARM;
struct TensorViewCreateInfoARM;
struct TensorMemoryRequirementsInfoARM;
struct BindTensorMemoryInfoARM;
struct WriteDescriptorSetTensorARM;
@@ -1881,6 +1913,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_dynamic_rendering_unused_attachments ===
struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
//=== VK_KHR_internally_synchronized_queues ===
struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR;
//=== VK_NV_low_latency2 ===
struct LatencySleepModeInfoNV;
struct LatencySleepInfoNV;
@@ -2164,6 +2199,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_shader_fma ===
struct PhysicalDeviceShaderFmaFeaturesKHR;
//=== VK_NV_push_constant_bank ===
struct PushConstantBankInfoNV;
struct PhysicalDevicePushConstantBankFeaturesNV;
struct PhysicalDevicePushConstantBankPropertiesNV;
//=== VK_EXT_ray_tracing_invocation_reorder ===
struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT;
struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT;
@@ -2292,6 +2332,9 @@ namespace VULKAN_HPP_NAMESPACE
struct ComputeOccupancyPriorityParametersNV;
struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV;
//=== VK_EXT_shader_subgroup_partitioned ===
struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT;
//===================================
//=== HANDLE forward declarations ===
//===================================
@@ -2354,6 +2397,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_debug_utils ===
class DebugUtilsMessengerEXT;
//=== VK_EXT_descriptor_heap ===
class TensorARM;
//=== VK_KHR_acceleration_structure ===
class AccelerationStructureKHR;
@@ -2744,6 +2790,16 @@ namespace VULKAN_HPP_NAMESPACE
using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_EXT_descriptor_heap ===
template <typename Dispatch>
class UniqueHandleTraits<TensorARM, Dispatch>
{
public:
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueTensorARM = UniqueHandle<TensorARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_KHR_acceleration_structure ===
template <typename Dispatch>
class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
@@ -2848,15 +2904,6 @@ namespace VULKAN_HPP_NAMESPACE
using UniqueMicromapEXT = UniqueHandle<MicromapEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
//=== VK_ARM_tensors ===
template <typename Dispatch>
class UniqueHandleTraits<TensorARM, Dispatch>
{
public:
using deleter = detail::ObjectDestroy<Device, Dispatch>;
};
using UniqueTensorARM = UniqueHandle<TensorARM, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Dispatch>
class UniqueHandleTraits<TensorViewARM, Dispatch>
{
@@ -6525,6 +6572,35 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdBindSamplerHeapEXT ), bool>::type = true>
void bindSamplerHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdBindSamplerHeapEXT ), bool>::type = true>
void bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdBindResourceHeapEXT ), bool>::type = true>
void bindResourceHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdBindResourceHeapEXT ), bool>::type = true>
void bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdPushDataEXT ), bool>::type = true>
void pushDataEXT( const PushDataInfoEXT * pPushDataInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkCmdPushDataEXT ), bool>::type = true>
void pushDataEXT( const PushDataInfoEXT & pushDataInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_sample_locations ===
// wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
@@ -14186,6 +14262,14 @@ namespace VULKAN_HPP_NAMESPACE
getImageViewAddressNVX( ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkGetDeviceCombinedImageSamplerIndexNVX ), bool>::type = true>
uint64_t getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex,
uint64_t samplerIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_AMD_shader_info ===
// wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html
@@ -14922,6 +15006,137 @@ namespace VULKAN_HPP_NAMESPACE
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkWriteSamplerDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkWriteSamplerDescriptorsEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD Result writeSamplerDescriptorsEXT( uint32_t samplerCount,
const SamplerCreateInfo * pSamplers,
const HostAddressRangeEXT * pDescriptors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkWriteSamplerDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, typename std::enable_if<IS_DISPATCHED( vkWriteSamplerDescriptorsEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
writeSamplerDescriptorsEXT( ArrayProxy<const SamplerCreateInfo> const & samplers,
ArrayProxy<const HostAddressRangeEXT> const & descriptors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkWriteResourceDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkWriteResourceDescriptorsEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD Result writeResourceDescriptorsEXT( uint32_t resourceCount,
const ResourceDescriptorInfoEXT * pResources,
const HostAddressRangeEXT * pDescriptors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkWriteResourceDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkWriteResourceDescriptorsEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
writeResourceDescriptorsEXT( ArrayProxy<const ResourceDescriptorInfoEXT> const & resources,
ArrayProxy<const HostAddressRangeEXT> const & descriptors,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDataEXT( uint32_t imageCount,
const Image * pImages,
HostAddressRangeEXT * pDatas,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename HostAddressRangeEXTAllocator = std::allocator<HostAddressRangeEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
getImageOpaqueCaptureDataEXT( ArrayProxy<const Image> const & images, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename HostAddressRangeEXTAllocator = std::allocator<HostAddressRangeEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
getImageOpaqueCaptureDataEXT( ArrayProxy<const Image> const & images,
HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<HostAddressRangeEXT>::type
getImageOpaqueCaptureDataEXT( const Image & image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkRegisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkRegisterCustomBorderColorEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD Result registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT * pBorderColor,
Bool32 requestIndex,
uint32_t * pIndex,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkRegisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkRegisterCustomBorderColorEXT ), bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type registerCustomBorderColorEXT(
const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkUnregisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkUnregisterCustomBorderColorEXT ), bool>::type = true>
void unregisterCustomBorderColorEXT( uint32_t index, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type = true>
VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDataARM( uint32_t tensorCount,
const TensorARM * pTensors,
HostAddressRangeEXT * pDatas,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename HostAddressRangeEXTAllocator = std::allocator<HostAddressRangeEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
getTensorOpaqueCaptureDataARM( ArrayProxy<const TensorARM> const & tensors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename HostAddressRangeEXTAllocator = std::allocator<HostAddressRangeEXT>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<std::is_same<typename HostAddressRangeEXTAllocator::value_type, HostAddressRangeEXT>::value, int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<HostAddressRangeEXT, HostAddressRangeEXTAllocator>>::type
getTensorOpaqueCaptureDataARM( ArrayProxy<const TensorARM> const & tensors,
HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ), bool>::type = true>
VULKAN_HPP_NODISCARD typename ResultValueType<HostAddressRangeEXT>::type
getTensorOpaqueCaptureDataARM( const TensorARM & tensor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_get_memory_requirements2 ===
// wrapper function for command vkGetImageMemoryRequirements2KHR, see
@@ -20866,6 +21081,14 @@ namespace VULKAN_HPP_NAMESPACE
getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceDescriptorSizeEXT ), bool>::type = true>
DeviceSize getDescriptorSizeEXT( DescriptorType descriptorType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_sample_locations ===
// wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see

596
third_party/vulkan/vulkan_hash.hpp vendored
View File

@@ -391,6 +391,17 @@ namespace std
}
};
//=== VK_EXT_descriptor_heap ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::TensorARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorARM const & tensorARM ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkTensorARM>{}( static_cast<VkTensorARM>( tensorARM ) );
}
};
//=== VK_KHR_acceleration_structure ===
template <>
@@ -505,15 +516,6 @@ namespace std
//=== VK_ARM_tensors ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::TensorARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorARM const & tensorARM ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkTensorARM>{}( static_cast<VkTensorARM>( tensorARM ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TensorViewARM>
{
@@ -1497,6 +1499,33 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT const & deviceAddressRangeEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.address );
VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.size );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::BindHeapInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::BindHeapInfoEXT const & bindHeapInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.heapRange );
VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.reservedRangeOffset );
VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.reservedRangeSize );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::Offset2D>
{
@@ -2677,6 +2706,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT const & commandBufferInheritanceDescriptorHeapInfoEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pSamplerHeapBindInfo );
VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pResourceHeapBindInfo );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
{
@@ -4213,6 +4257,160 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT const & descriptorMappingSourceConstantOffsetEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.heapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.heapArrayStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.pEmbeddedSampler );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.samplerHeapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.samplerHeapArrayStride );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT const & descriptorMappingSourcePushIndexEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.pushOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapIndexStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapArrayStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.pEmbeddedSampler );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.useCombinedImageSamplerIndex );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerPushOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapIndexStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapArrayStride );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT const & descriptorMappingSourceIndirectIndexEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.pushOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.addressOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapIndexStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapArrayStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.pEmbeddedSampler );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.useCombinedImageSamplerIndex );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerPushOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerAddressOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapIndexStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapArrayStride );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT const & descriptorMappingSourceIndirectIndexArrayEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.heapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.pushOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.addressOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.heapIndexStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.pEmbeddedSampler );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.useCombinedImageSamplerIndex );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerHeapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerPushOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerAddressOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerHeapIndexStride );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT const & descriptorMappingSourceHeapDataEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceHeapDataEXT.heapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceHeapDataEXT.pushOffset );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT const & descriptorMappingSourceIndirectAddressEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectAddressEXT.pushOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectAddressEXT.addressOffset );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT const & descriptorMappingSourceShaderRecordIndexEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.shaderRecordOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapIndexStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapArrayStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.pEmbeddedSampler );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.useCombinedImageSamplerIndex );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerShaderRecordOffset );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapIndexStride );
VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapArrayStride );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
{
@@ -6806,6 +7004,30 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT const & hostAddressRangeConstEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeConstEXT.address );
VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeConstEXT.size );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::HostAddressRangeEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::HostAddressRangeEXT const & hostAddressRangeEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeEXT.address );
VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeEXT.size );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery>
{
@@ -6980,6 +7202,38 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT const & imageDescriptorInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.pView );
VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.layout );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
{
@@ -7240,24 +7494,6 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components );
VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
{
@@ -7752,6 +7988,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV const & indirectCommandsLayoutPushDataTokenNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pushDataOffset );
VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pushDataSize );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT>
{
@@ -8629,6 +8880,19 @@ namespace std
};
# endif /*VK_USE_PLATFORM_OHOS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT const & opaqueCaptureDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.pData );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
{
@@ -9538,6 +9802,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM const &
physicalDeviceCooperativeMatrixConversionFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixConversionFeaturesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixConversionFeaturesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixConversionFeaturesQCOM.cooperativeMatrixConversion );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR>
{
@@ -10060,6 +10338,69 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT const & physicalDeviceDescriptorHeapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.descriptorHeap );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.descriptorHeapCaptureReplay );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT const & physicalDeviceDescriptorHeapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerHeapAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.resourceHeapAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxSamplerHeapSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxResourceHeapSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minSamplerHeapReservedRange );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minSamplerHeapReservedRangeWithEmbedded );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minResourceHeapReservedRange );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerDescriptorSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageDescriptorSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.bufferDescriptorSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerDescriptorAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageDescriptorAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.bufferDescriptorAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxPushDataSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageCaptureReplayOpaqueDataSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxDescriptorHeapEmbeddedSamplers );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerYcbcrConversionCount );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.sparseDescriptorHeaps );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.protectedDescriptorHeaps );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM>
{
std::size_t operator()(
VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM const & physicalDeviceDescriptorHeapTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorDescriptorSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorDescriptorAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorCaptureReplayOpaqueDataSize );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
{
@@ -11490,6 +11831,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const &
physicalDeviceInternallySynchronizedQueuesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.internallySynchronizedQueues );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
{
@@ -13104,6 +13459,37 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV const & physicalDevicePushConstantBankFeaturesNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.pushConstantBank );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV const & physicalDevicePushConstantBankPropertiesNV ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxGraphicsPushConstantBanks );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxComputePushConstantBanks );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxGraphicsPushDataBanks );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxComputePushDataBanks );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties>
{
@@ -14236,6 +14622,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & physicalDeviceShaderSubgroupPartitionedFeaturesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.shaderSubgroupPartitioned );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures>
{
@@ -16601,6 +17002,19 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV const & pushConstantBankInfoNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.bank );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PushConstantsInfo>
{
@@ -16618,6 +17032,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PushDataInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDataInfoEXT const & pushDataInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.offset );
VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.data );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
{
@@ -17599,6 +18027,35 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT const & texelBufferDescriptorInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.format );
VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.addressRange );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM const & tensorViewCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.flags );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.tensor );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.format );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>
{
@@ -17642,34 +18099,6 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor );
VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM>
{
@@ -17683,6 +18112,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT const & samplerCustomBorderColorIndexCreateInfoEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.index );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
{
@@ -18003,6 +18446,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT const & shaderDescriptorSetAndBindingMappingInfoEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.mappingCount );
VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.pMappings );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
{
@@ -18300,6 +18758,19 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT const & subsampledImageFormatPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.subsampledImageDescriptorCount );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
{
@@ -18809,21 +19280,6 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM const & tensorViewCreateInfoARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.flags );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.tensor );
VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.format );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
{

296
third_party/vulkan/vulkan_raii.hpp vendored
View File

@@ -285,6 +285,10 @@ namespace VULKAN_HPP_NAMESPACE
vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
//=== VK_EXT_descriptor_heap ===
vkGetPhysicalDeviceDescriptorSizeEXT =
PFN_vkGetPhysicalDeviceDescriptorSizeEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDescriptorSizeEXT" ) );
//=== VK_EXT_sample_locations ===
vkGetPhysicalDeviceMultisamplePropertiesEXT =
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
@@ -591,6 +595,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
//=== VK_EXT_descriptor_heap ===
PFN_vkGetPhysicalDeviceDescriptorSizeEXT vkGetPhysicalDeviceDescriptorSizeEXT = 0;
//=== VK_EXT_sample_locations ===
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
@@ -984,6 +991,8 @@ namespace VULKAN_HPP_NAMESPACE
vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) );
vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
vkGetDeviceCombinedImageSamplerIndexNVX =
PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetDeviceProcAddr( device, "vkGetDeviceCombinedImageSamplerIndexNVX" ) );
//=== VK_AMD_draw_indirect_count ===
vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
@@ -1156,6 +1165,17 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) );
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteSamplerDescriptorsEXT" ) );
vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteResourceDescriptorsEXT" ) );
vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindSamplerHeapEXT" ) );
vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindResourceHeapEXT" ) );
vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetDeviceProcAddr( device, "vkCmdPushDataEXT" ) );
vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDataEXT" ) );
vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkRegisterCustomBorderColorEXT" ) );
vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkUnregisterCustomBorderColorEXT" ) );
vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDataARM" ) );
//=== VK_EXT_sample_locations ===
vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
@@ -2226,9 +2246,10 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
//=== VK_NVX_image_view_handle ===
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0;
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0;
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
PFN_vkGetDeviceCombinedImageSamplerIndexNVX vkGetDeviceCombinedImageSamplerIndexNVX = 0;
//=== VK_AMD_draw_indirect_count ===
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
@@ -2380,6 +2401,17 @@ namespace VULKAN_HPP_NAMESPACE
PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0;
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
PFN_vkWriteSamplerDescriptorsEXT vkWriteSamplerDescriptorsEXT = 0;
PFN_vkWriteResourceDescriptorsEXT vkWriteResourceDescriptorsEXT = 0;
PFN_vkCmdBindSamplerHeapEXT vkCmdBindSamplerHeapEXT = 0;
PFN_vkCmdBindResourceHeapEXT vkCmdBindResourceHeapEXT = 0;
PFN_vkCmdPushDataEXT vkCmdPushDataEXT = 0;
PFN_vkGetImageOpaqueCaptureDataEXT vkGetImageOpaqueCaptureDataEXT = 0;
PFN_vkRegisterCustomBorderColorEXT vkRegisterCustomBorderColorEXT = 0;
PFN_vkUnregisterCustomBorderColorEXT vkUnregisterCustomBorderColorEXT = 0;
PFN_vkGetTensorOpaqueCaptureDataARM vkGetTensorOpaqueCaptureDataARM = 0;
//=== VK_EXT_sample_locations ===
PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
@@ -3050,6 +3082,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_debug_utils ===
class DebugUtilsMessengerEXT;
//=== VK_EXT_descriptor_heap ===
class TensorARM;
//=== VK_KHR_acceleration_structure ===
class AccelerationStructureKHR;
@@ -4006,6 +4041,12 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD typename ResultValueType<DisplayPlaneCapabilities2KHR>::type
getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const;
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html
VULKAN_HPP_NODISCARD DeviceSize getDescriptorSizeEXT( DescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_sample_locations ===
// wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see
@@ -4678,6 +4719,10 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html
VULKAN_HPP_NODISCARD uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html
VULKAN_HPP_NODISCARD uint64_t getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_device_group ===
// wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see
@@ -4861,6 +4906,46 @@ namespace VULKAN_HPP_NAMESPACE
Optional<const AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkWriteSamplerDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html
typename ResultValueType<void>::type writeSamplerDescriptorsEXT( ArrayProxy<const SamplerCreateInfo> const & samplers,
ArrayProxy<const HostAddressRangeEXT> const & descriptors ) const;
// wrapper function for command vkWriteResourceDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html
typename ResultValueType<void>::type writeResourceDescriptorsEXT( ArrayProxy<const ResourceDescriptorInfoEXT> const & resources,
ArrayProxy<const HostAddressRangeEXT> const & descriptors ) const;
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<HostAddressRangeEXT>>::type
getImageOpaqueCaptureDataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Image> const & images ) const;
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
VULKAN_HPP_NODISCARD typename ResultValueType<HostAddressRangeEXT>::type getImageOpaqueCaptureDataEXT( const VULKAN_HPP_NAMESPACE::Image & image ) const;
// wrapper function for command vkRegisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html
VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor,
Bool32 requestIndex ) const;
// wrapper function for command vkUnregisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html
void unregisterCustomBorderColorEXT( uint32_t index ) const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<HostAddressRangeEXT>>::type
getTensorOpaqueCaptureDataARM( ArrayProxy<const VULKAN_HPP_NAMESPACE::TensorARM> const & tensors ) const;
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
VULKAN_HPP_NODISCARD typename ResultValueType<HostAddressRangeEXT>::type
getTensorOpaqueCaptureDataARM( const VULKAN_HPP_NAMESPACE::TensorARM & tensor ) const;
//=== VK_KHR_get_memory_requirements2 ===
// wrapper function for command vkGetImageMemoryRequirements2KHR, see
@@ -7252,6 +7337,17 @@ namespace VULKAN_HPP_NAMESPACE
void dispatchGraphIndirectCountAMDX( DeviceAddress scratch, DeviceSize scratchSize, DeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT;
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html
void bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html
void bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html
void pushDataEXT( const PushDataInfoEXT & pushDataInfo ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_sample_locations ===
// wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html
@@ -19620,6 +19716,19 @@ namespace VULKAN_HPP_NAMESPACE
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) );
}
// wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex,
uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceCombinedImageSamplerIndexNVX &&
"Function <vkGetDeviceCombinedImageSamplerIndexNVX> requires <VK_NVX_image_view_handle>" );
uint64_t result = getDispatcher()->vkGetDeviceCombinedImageSamplerIndexNVX( static_cast<VkDevice>( m_device ), imageViewIndex, samplerIndex );
return result;
}
//=== VK_AMD_draw_indirect_count ===
// wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html
@@ -21634,6 +21743,187 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
// wrapper function for command vkWriteSamplerDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::writeSamplerDescriptorsEXT( ArrayProxy<const SamplerCreateInfo> const & samplers,
ArrayProxy<const HostAddressRangeEXT> const & descriptors ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkWriteSamplerDescriptorsEXT && "Function <vkWriteSamplerDescriptorsEXT> requires <VK_EXT_descriptor_heap>" );
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( samplers.size() == descriptors.size() );
# else
if ( samplers.size() != descriptors.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT: samplers.size() != descriptors.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
Result result =
static_cast<Result>( getDispatcher()->vkWriteSamplerDescriptorsEXT( static_cast<VkDevice>( m_device ),
samplers.size(),
reinterpret_cast<const VkSamplerCreateInfo *>( samplers.data() ),
reinterpret_cast<const VkHostAddressRangeEXT *>( descriptors.data() ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result );
}
// wrapper function for command vkWriteResourceDescriptorsEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html
VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::writeResourceDescriptorsEXT( ArrayProxy<const ResourceDescriptorInfoEXT> const & resources,
ArrayProxy<const HostAddressRangeEXT> const & descriptors ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkWriteResourceDescriptorsEXT && "Function <vkWriteResourceDescriptorsEXT> requires <VK_EXT_descriptor_heap>" );
# ifdef VULKAN_HPP_NO_EXCEPTIONS
VULKAN_HPP_ASSERT( resources.size() == descriptors.size() );
# else
if ( resources.size() != descriptors.size() )
{
throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT: resources.size() != descriptors.size()" );
}
# endif /*VULKAN_HPP_NO_EXCEPTIONS*/
Result result =
static_cast<Result>( getDispatcher()->vkWriteResourceDescriptorsEXT( static_cast<VkDevice>( m_device ),
resources.size(),
reinterpret_cast<const VkResourceDescriptorInfoEXT *>( resources.data() ),
reinterpret_cast<const VkHostAddressRangeEXT *>( descriptors.data() ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result );
}
// wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html
VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindSamplerHeapEXT && "Function <vkCmdBindSamplerHeapEXT> requires <VK_EXT_descriptor_heap>" );
getDispatcher()->vkCmdBindSamplerHeapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBindHeapInfoEXT *>( &bindInfo ) );
}
// wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html
VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindResourceHeapEXT && "Function <vkCmdBindResourceHeapEXT> requires <VK_EXT_descriptor_heap>" );
getDispatcher()->vkCmdBindResourceHeapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBindHeapInfoEXT *>( &bindInfo ) );
}
// wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html
VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT & pushDataInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDataEXT && "Function <vkCmdPushDataEXT> requires <VK_EXT_descriptor_heap>" );
getDispatcher()->vkCmdPushDataEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPushDataInfoEXT *>( &pushDataInfo ) );
}
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<HostAddressRangeEXT>>::type
Device::getImageOpaqueCaptureDataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Image> const & images ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDataEXT && "Function <vkGetImageOpaqueCaptureDataEXT> requires <VK_EXT_descriptor_heap>" );
std::vector<HostAddressRangeEXT> datas( images.size() );
Result result = static_cast<Result>( getDispatcher()->vkGetImageOpaqueCaptureDataEXT( static_cast<VkDevice>( m_device ),
images.size(),
reinterpret_cast<const VkImage *>( images.data() ),
reinterpret_cast<VkHostAddressRangeEXT *>( datas.data() ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( datas ) );
}
// wrapper function for command vkGetImageOpaqueCaptureDataEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HostAddressRangeEXT>::type
Device::getImageOpaqueCaptureDataEXT( const VULKAN_HPP_NAMESPACE::Image & image ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDataEXT && "Function <vkGetImageOpaqueCaptureDataEXT> requires <VK_EXT_descriptor_heap>" );
HostAddressRangeEXT data;
Result result = static_cast<Result>( getDispatcher()->vkGetImageOpaqueCaptureDataEXT(
static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkImage *>( &image ), reinterpret_cast<VkHostAddressRangeEXT *>( &data ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) );
}
// wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize PhysicalDevice::getDescriptorSizeEXT( DescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDescriptorSizeEXT &&
"Function <vkGetPhysicalDeviceDescriptorSizeEXT> requires <VK_EXT_descriptor_heap>" );
VkDeviceSize result = getDispatcher()->vkGetPhysicalDeviceDescriptorSizeEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
static_cast<VkDescriptorType>( descriptorType ) );
return static_cast<DeviceSize>( result );
}
// wrapper function for command vkRegisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<uint32_t>::type
Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkRegisterCustomBorderColorEXT && "Function <vkRegisterCustomBorderColorEXT> requires <VK_EXT_descriptor_heap>" );
uint32_t index;
Result result =
static_cast<Result>( getDispatcher()->vkRegisterCustomBorderColorEXT( static_cast<VkDevice>( m_device ),
reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>( &borderColor ),
static_cast<VkBool32>( requestIndex ),
&index ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::registerCustomBorderColorEXT" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( index ) );
}
// wrapper function for command vkUnregisterCustomBorderColorEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html
VULKAN_HPP_INLINE void Device::unregisterCustomBorderColorEXT( uint32_t index ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkUnregisterCustomBorderColorEXT && "Function <vkUnregisterCustomBorderColorEXT> requires <VK_EXT_descriptor_heap>" );
getDispatcher()->vkUnregisterCustomBorderColorEXT( static_cast<VkDevice>( m_device ), index );
}
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<std::vector<HostAddressRangeEXT>>::type
Device::getTensorOpaqueCaptureDataARM( ArrayProxy<const VULKAN_HPP_NAMESPACE::TensorARM> const & tensors ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDataARM && "Function <vkGetTensorOpaqueCaptureDataARM> requires <VK_EXT_descriptor_heap>" );
std::vector<HostAddressRangeEXT> datas( tensors.size() );
Result result = static_cast<Result>( getDispatcher()->vkGetTensorOpaqueCaptureDataARM( static_cast<VkDevice>( m_device ),
tensors.size(),
reinterpret_cast<const VkTensorARM *>( tensors.data() ),
reinterpret_cast<VkHostAddressRangeEXT *>( datas.data() ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( datas ) );
}
// wrapper function for command vkGetTensorOpaqueCaptureDataARM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<HostAddressRangeEXT>::type
Device::getTensorOpaqueCaptureDataARM( const VULKAN_HPP_NAMESPACE::TensorARM & tensor ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDataARM && "Function <vkGetTensorOpaqueCaptureDataARM> requires <VK_EXT_descriptor_heap>" );
HostAddressRangeEXT data;
Result result = static_cast<Result>( getDispatcher()->vkGetTensorOpaqueCaptureDataARM(
static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkTensorARM *>( &tensor ), reinterpret_cast<VkHostAddressRangeEXT *>( &data ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) );
}
//=== VK_EXT_sample_locations ===
// wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html

21
third_party/vulkan/vulkan_shared.hpp vendored
View File

@@ -825,6 +825,17 @@ namespace VULKAN_HPP_NAMESPACE
using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
//=== VK_EXT_descriptor_heap ===
template <>
class SharedHandleTraits<TensorARM>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<TensorARM>;
};
using SharedTensorARM = SharedHandle<TensorARM>;
//=== VK_KHR_acceleration_structure ===
template <>
class SharedHandleTraits<AccelerationStructureKHR>
@@ -939,16 +950,6 @@ namespace VULKAN_HPP_NAMESPACE
using SharedMicromapEXT = SharedHandle<MicromapEXT>;
//=== VK_ARM_tensors ===
template <>
class SharedHandleTraits<TensorARM>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<TensorARM>;
};
using SharedTensorARM = SharedHandle<TensorARM>;
template <>
class SharedHandleTraits<TensorViewARM>
{

249
third_party/vulkan/vulkan_static_assertions.hpp vendored
View File

@@ -3603,6 +3603,197 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
"DeviceOrHostAddressConstAMDX is not nothrow_move_constructible!" );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_descriptor_heap ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorARM ) == sizeof( VkTensorARM ), "handle and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible<VULKAN_HPP_NAMESPACE::TensorARM>::value, "TensorARM is not copy_constructible!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TensorARM>::value, "TensorARM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostAddressRangeEXT ) == sizeof( VkHostAddressRangeEXT ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::HostAddressRangeEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::HostAddressRangeEXT>::value,
"HostAddressRangeEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT ) == sizeof( VkHostAddressRangeConstEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT>::value,
"HostAddressRangeConstEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT ) == sizeof( VkDeviceAddressRangeEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT>::value,
"DeviceAddressRangeEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT ) == sizeof( VkTexelBufferDescriptorInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT>::value,
"TexelBufferDescriptorInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT ) == sizeof( VkImageDescriptorInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT>::value,
"ImageDescriptorInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT ) == sizeof( VkResourceDescriptorInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT>::value,
"ResourceDescriptorInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT ) == sizeof( VkResourceDescriptorDataEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT>::value,
"ResourceDescriptorDataEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindHeapInfoEXT ) == sizeof( VkBindHeapInfoEXT ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::BindHeapInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::BindHeapInfoEXT>::value,
"BindHeapInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushDataInfoEXT ) == sizeof( VkPushDataInfoEXT ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PushDataInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PushDataInfoEXT>::value,
"PushDataInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT ) == sizeof( VkDescriptorMappingSourceConstantOffsetEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT>::value,
"DescriptorMappingSourceConstantOffsetEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT ) == sizeof( VkDescriptorMappingSourcePushIndexEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT>::value,
"DescriptorMappingSourcePushIndexEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT ) == sizeof( VkDescriptorMappingSourceIndirectIndexEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT>::value,
"DescriptorMappingSourceIndirectIndexEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT ) == sizeof( VkDescriptorMappingSourceHeapDataEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT>::value,
"DescriptorMappingSourceHeapDataEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT ) == sizeof( VkDescriptorMappingSourceIndirectAddressEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT>::value,
"DescriptorMappingSourceIndirectAddressEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT ) ==
sizeof( VkDescriptorMappingSourceShaderRecordIndexEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT>::value,
"DescriptorMappingSourceShaderRecordIndexEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT ) == sizeof( VkDescriptorMappingSourceDataEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT>::value,
"DescriptorMappingSourceDataEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT ) ==
sizeof( VkDescriptorMappingSourceIndirectIndexArrayEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT>::value,
"DescriptorMappingSourceIndirectIndexArrayEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT ) == sizeof( VkDescriptorSetAndBindingMappingEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT>::value,
"DescriptorSetAndBindingMappingEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT ) ==
sizeof( VkShaderDescriptorSetAndBindingMappingInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT>::value,
"ShaderDescriptorSetAndBindingMappingInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT ) == sizeof( VkOpaqueCaptureDataCreateInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT>::value,
"OpaqueCaptureDataCreateInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorHeapFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT>::value,
"PhysicalDeviceDescriptorHeapFeaturesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorHeapPropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT>::value,
"PhysicalDeviceDescriptorHeapPropertiesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT ) ==
sizeof( VkCommandBufferInheritanceDescriptorHeapInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT>::value,
"CommandBufferInheritanceDescriptorHeapInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT ) == sizeof( VkSamplerCustomBorderColorIndexCreateInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT>::value,
"SamplerCustomBorderColorIndexCreateInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV ) == sizeof( VkIndirectCommandsLayoutPushDataTokenNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV>::value,
"IndirectCommandsLayoutPushDataTokenNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT ) == sizeof( VkSubsampledImageFormatPropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT>::value,
"SubsampledImageFormatPropertiesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM ) == sizeof( VkTensorViewCreateInfoARM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>::value,
"TensorViewCreateInfoARM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM ) ==
sizeof( VkPhysicalDeviceDescriptorHeapTensorPropertiesARM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM>::value,
"PhysicalDeviceDescriptorHeapTensorPropertiesARM is not nothrow_move_constructible!" );
//=== VK_AMD_mixed_attachment_samples ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD ) == sizeof( VkAttachmentSampleCountInfoAMD ),
@@ -4211,6 +4402,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::FilterCu
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>::value,
"FilterCubicImageViewImageFormatPropertiesEXT is not nothrow_move_constructible!" );
//=== VK_QCOM_cooperative_matrix_conversion ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM ) ==
sizeof( VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>::value,
"PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM is not nothrow_move_constructible!" );
//=== VK_EXT_external_memory_host ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ),
@@ -6972,12 +7173,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TensorCr
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TensorCreateInfoARM>::value,
"TensorCreateInfoARM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM ) == sizeof( VkTensorViewCreateInfoARM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM>::value,
"TensorViewCreateInfoARM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM ) == sizeof( VkTensorMemoryRequirementsInfoARM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM>::value, "struct wrapper is not a standard layout!" );
@@ -7699,6 +7894,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>::value,
"PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_KHR_internally_synchronized_queues ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR ) ==
sizeof( VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>::value,
"PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR is not nothrow_move_constructible!" );
//=== VK_NV_low_latency2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV ) == sizeof( VkLatencySleepModeInfoNV ),
@@ -9141,6 +9346,28 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>::value,
"PhysicalDeviceShaderFmaFeaturesKHR is not nothrow_move_constructible!" );
//=== VK_NV_push_constant_bank ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV ) == sizeof( VkPushConstantBankInfoNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV>::value,
"PushConstantBankInfoNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV ) == sizeof( VkPhysicalDevicePushConstantBankFeaturesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV>::value,
"PhysicalDevicePushConstantBankFeaturesNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV ) == sizeof( VkPhysicalDevicePushConstantBankPropertiesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV>::value,
"PhysicalDevicePushConstantBankPropertiesNV is not nothrow_move_constructible!" );
//=== VK_EXT_ray_tracing_invocation_reorder ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT ) ==
@@ -9631,4 +9858,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV>::value,
"PhysicalDeviceComputeOccupancyPriorityFeaturesNV is not nothrow_move_constructible!" );
//=== VK_EXT_shader_subgroup_partitioned ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ) ==
sizeof( VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>::value,
"PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT is not nothrow_move_constructible!" );
#endif

6512
third_party/vulkan/vulkan_structs.hpp vendored
View File

File diff suppressed because it is too large Load Diff

279
third_party/vulkan/vulkan_to_string.hpp vendored
View File

@@ -140,12 +140,12 @@ namespace VULKAN_HPP_NAMESPACE
result += " Disjoint |";
if ( value & ImageCreateFlagBits::eCornerSampledNV )
result += " CornerSampledNV |";
if ( value & ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT )
result += " DescriptorHeapCaptureReplayEXT |";
if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT )
result += " SampleLocationsCompatibleDepthEXT |";
if ( value & ImageCreateFlagBits::eSubsampledEXT )
result += " SubsampledEXT |";
if ( value & ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT )
result += " DescriptorBufferCaptureReplayEXT |";
if ( value & ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT )
result += " MultisampledRenderToSingleSampledEXT |";
if ( value & ImageCreateFlagBits::e2DViewCompatibleEXT )
@@ -346,6 +346,8 @@ namespace VULKAN_HPP_NAMESPACE
std::string result = "{";
if ( value & DeviceQueueCreateFlagBits::eProtected )
result += " Protected |";
if ( value & DeviceQueueCreateFlagBits::eInternallySynchronizedKHR )
result += " InternallySynchronizedKHR |";
if ( result.size() > 1 )
result.back() = '}';
@@ -607,6 +609,8 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & BufferUsageFlagBits::eExecutionGraphScratchAMDX )
result += " ExecutionGraphScratchAMDX |";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & BufferUsageFlagBits::eDescriptorHeapEXT )
result += " DescriptorHeapEXT |";
if ( value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR )
result += " AccelerationStructureBuildInputReadOnlyKHR |";
if ( value & BufferUsageFlagBits::eAccelerationStructureStorageKHR )
@@ -1540,8 +1544,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " Rotate |";
if ( value & SubgroupFeatureFlagBits::eRotateClustered )
result += " RotateClustered |";
if ( value & SubgroupFeatureFlagBits::ePartitionedNV )
result += " PartitionedNV |";
if ( value & SubgroupFeatureFlagBits::ePartitionedEXT )
result += " PartitionedEXT |";
if ( result.size() > 1 )
result.back() = '}';
@@ -1794,6 +1798,10 @@ namespace VULKAN_HPP_NAMESPACE
result += " VideoDecodeReadKHR |";
if ( value & AccessFlagBits2::eVideoDecodeWriteKHR )
result += " VideoDecodeWriteKHR |";
if ( value & AccessFlagBits2::eSamplerHeapReadEXT )
result += " SamplerHeapReadEXT |";
if ( value & AccessFlagBits2::eResourceHeapReadEXT )
result += " ResourceHeapReadEXT |";
if ( value & AccessFlagBits2::eVideoEncodeReadKHR )
result += " VideoEncodeReadKHR |";
if ( value & AccessFlagBits2::eVideoEncodeWriteKHR )
@@ -2074,6 +2082,8 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & BufferUsageFlagBits2::eExecutionGraphScratchAMDX )
result += " ExecutionGraphScratchAMDX |";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & BufferUsageFlagBits2::eDescriptorHeapEXT )
result += " DescriptorHeapEXT |";
if ( value & BufferUsageFlagBits2::eConditionalRenderingEXT )
result += " ConditionalRenderingEXT |";
if ( value & BufferUsageFlagBits2::eShaderBindingTableKHR )
@@ -2162,6 +2172,8 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & PipelineCreateFlagBits2::eExecutionGraphAMDX )
result += " ExecutionGraphAMDX |";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & PipelineCreateFlagBits2::eDescriptorHeapEXT )
result += " DescriptorHeapEXT |";
if ( value & PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV )
result += " RayTracingAllowSpheresAndLinearSweptSpheresNV |";
if ( value & PipelineCreateFlagBits2::eEnableLegacyDitheringEXT )
@@ -3085,6 +3097,52 @@ namespace VULKAN_HPP_NAMESPACE
return "{}";
}
//=== VK_EXT_descriptor_heap ===
VULKAN_HPP_INLINE std::string to_string( SpirvResourceTypeFlagsEXT value )
{
std::string result = "{";
if ( value & SpirvResourceTypeFlagBitsEXT::eSampler )
result += " Sampler |";
if ( value & SpirvResourceTypeFlagBitsEXT::eSampledImage )
result += " SampledImage |";
if ( value & SpirvResourceTypeFlagBitsEXT::eReadOnlyImage )
result += " ReadOnlyImage |";
if ( value & SpirvResourceTypeFlagBitsEXT::eReadWriteImage )
result += " ReadWriteImage |";
if ( value & SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage )
result += " CombinedSampledImage |";
if ( value & SpirvResourceTypeFlagBitsEXT::eUniformBuffer )
result += " UniformBuffer |";
if ( value & SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer )
result += " ReadOnlyStorageBuffer |";
if ( value & SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer )
result += " ReadWriteStorageBuffer |";
if ( value & SpirvResourceTypeFlagBitsEXT::eAccelerationStructure )
result += " AccelerationStructure |";
if ( value & SpirvResourceTypeFlagBitsEXT::eTensorARM )
result += " TensorARM |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
VULKAN_HPP_INLINE std::string to_string( TensorViewCreateFlagsARM value )
{
std::string result = "{";
if ( value & TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay )
result += " DescriptorBufferCaptureReplay |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
//=== VK_NV_fragment_coverage_to_color ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageToColorStateCreateFlagsNV )
@@ -3819,6 +3877,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " MutableFormat |";
if ( value & TensorCreateFlagBitsARM::eProtected )
result += " Protected |";
if ( value & TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay )
result += " DescriptorHeapCaptureReplay |";
if ( value & TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay )
result += " DescriptorBufferCaptureReplay |";
@@ -3829,19 +3889,6 @@ namespace VULKAN_HPP_NAMESPACE
return result;
}
VULKAN_HPP_INLINE std::string to_string( TensorViewCreateFlagsARM value )
{
std::string result = "{";
if ( value & TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay )
result += " DescriptorBufferCaptureReplay |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
VULKAN_HPP_INLINE std::string to_string( TensorUsageFlagsARM value )
{
std::string result = "{";
@@ -3946,6 +3993,8 @@ namespace VULKAN_HPP_NAMESPACE
std::string result = "{";
if ( value & ShaderCreateFlagBitsEXT::eLinkStage )
result += " LinkStage |";
if ( value & ShaderCreateFlagBitsEXT::eDescriptorHeap )
result += " DescriptorHeap |";
if ( value & ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize )
result += " AllowVaryingSubgroupSize |";
if ( value & ShaderCreateFlagBitsEXT::eRequireFullSubgroups )
@@ -4895,6 +4944,21 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eExecutionGraphPipelineCreateInfoAMDX : return "ExecutionGraphPipelineCreateInfoAMDX";
case StructureType::ePipelineShaderStageNodeCreateInfoAMDX : return "PipelineShaderStageNodeCreateInfoAMDX";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case StructureType::eTexelBufferDescriptorInfoEXT : return "TexelBufferDescriptorInfoEXT";
case StructureType::eImageDescriptorInfoEXT : return "ImageDescriptorInfoEXT";
case StructureType::eResourceDescriptorInfoEXT : return "ResourceDescriptorInfoEXT";
case StructureType::eBindHeapInfoEXT : return "BindHeapInfoEXT";
case StructureType::ePushDataInfoEXT : return "PushDataInfoEXT";
case StructureType::eDescriptorSetAndBindingMappingEXT : return "DescriptorSetAndBindingMappingEXT";
case StructureType::eShaderDescriptorSetAndBindingMappingInfoEXT : return "ShaderDescriptorSetAndBindingMappingInfoEXT";
case StructureType::eOpaqueCaptureDataCreateInfoEXT : return "OpaqueCaptureDataCreateInfoEXT";
case StructureType::ePhysicalDeviceDescriptorHeapPropertiesEXT : return "PhysicalDeviceDescriptorHeapPropertiesEXT";
case StructureType::ePhysicalDeviceDescriptorHeapFeaturesEXT : return "PhysicalDeviceDescriptorHeapFeaturesEXT";
case StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT : return "CommandBufferInheritanceDescriptorHeapInfoEXT";
case StructureType::eSamplerCustomBorderColorIndexCreateInfoEXT : return "SamplerCustomBorderColorIndexCreateInfoEXT";
case StructureType::eIndirectCommandsLayoutPushDataTokenNV : return "IndirectCommandsLayoutPushDataTokenNV";
case StructureType::eSubsampledImageFormatPropertiesEXT : return "SubsampledImageFormatPropertiesEXT";
case StructureType::ePhysicalDeviceDescriptorHeapTensorPropertiesARM : return "PhysicalDeviceDescriptorHeapTensorPropertiesARM";
case StructureType::eAttachmentSampleCountInfoAMD : return "AttachmentSampleCountInfoAMD";
case StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR : return "PhysicalDeviceShaderBfloat16FeaturesKHR";
case StructureType::eSampleLocationsInfoEXT : return "SampleLocationsInfoEXT";
@@ -4942,39 +5006,40 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR : return "PhysicalDevicePortabilitySubsetFeaturesKHR";
case StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR: return "PhysicalDevicePortabilitySubsetPropertiesKHR";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV";
case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV";
case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV";
case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV";
case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV";
case StructureType::eGeometryNV : return "GeometryNV";
case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV";
case StructureType::eGeometryAabbNV : return "GeometryAabbNV";
case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV";
case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV";
case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV";
case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV";
case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV";
case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV";
case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT";
case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT";
case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT";
case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
case StructureType::ePhysicalDeviceShaderClockFeaturesKHR : return "PhysicalDeviceShaderClockFeaturesKHR";
case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD";
case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD";
case StructureType::eVideoDecodeH265CapabilitiesKHR : return "VideoDecodeH265CapabilitiesKHR";
case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR : return "VideoDecodeH265SessionParametersCreateInfoKHR";
case StructureType::eVideoDecodeH265SessionParametersAddInfoKHR : return "VideoDecodeH265SessionParametersAddInfoKHR";
case StructureType::eVideoDecodeH265ProfileInfoKHR : return "VideoDecodeH265ProfileInfoKHR";
case StructureType::eVideoDecodeH265PictureInfoKHR : return "VideoDecodeH265PictureInfoKHR";
case StructureType::eVideoDecodeH265DpbSlotInfoKHR : return "VideoDecodeH265DpbSlotInfoKHR";
case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD";
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV";
case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV";
case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV";
case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV";
case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV";
case StructureType::eGeometryNV : return "GeometryNV";
case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV";
case StructureType::eGeometryAabbNV : return "GeometryAabbNV";
case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV";
case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV";
case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV";
case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV";
case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV";
case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV";
case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV : return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT";
case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT";
case StructureType::ePhysicalDeviceCooperativeMatrixConversionFeaturesQCOM: return "PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM";
case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT";
case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT";
case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
case StructureType::ePhysicalDeviceShaderClockFeaturesKHR : return "PhysicalDeviceShaderClockFeaturesKHR";
case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD";
case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD";
case StructureType::eVideoDecodeH265CapabilitiesKHR : return "VideoDecodeH265CapabilitiesKHR";
case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR : return "VideoDecodeH265SessionParametersCreateInfoKHR";
case StructureType::eVideoDecodeH265SessionParametersAddInfoKHR : return "VideoDecodeH265SessionParametersAddInfoKHR";
case StructureType::eVideoDecodeH265ProfileInfoKHR : return "VideoDecodeH265ProfileInfoKHR";
case StructureType::eVideoDecodeH265PictureInfoKHR : return "VideoDecodeH265PictureInfoKHR";
case StructureType::eVideoDecodeH265DpbSlotInfoKHR : return "VideoDecodeH265DpbSlotInfoKHR";
case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD";
case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
#if defined( VK_USE_PLATFORM_GGP )
case StructureType::ePresentFrameTokenGGP: return "PresentFrameTokenGGP";
#endif /*VK_USE_PLATFORM_GGP*/
@@ -5407,6 +5472,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM : return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM";
case StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT : return "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
case StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT : return "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT";
case StructureType::ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR : return "PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR";
case StructureType::eLatencySleepModeInfoNV : return "LatencySleepModeInfoNV";
case StructureType::eLatencySleepInfoNV : return "LatencySleepInfoNV";
case StructureType::eSetLatencyMarkerInfoNV : return "SetLatencyMarkerInfoNV";
@@ -5569,6 +5635,9 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA : return "PhysicalDeviceImageAlignmentControlPropertiesMESA";
case StructureType::eImageAlignmentControlCreateInfoMESA : return "ImageAlignmentControlCreateInfoMESA";
case StructureType::ePhysicalDeviceShaderFmaFeaturesKHR : return "PhysicalDeviceShaderFmaFeaturesKHR";
case StructureType::ePushConstantBankInfoNV : return "PushConstantBankInfoNV";
case StructureType::ePhysicalDevicePushConstantBankFeaturesNV : return "PhysicalDevicePushConstantBankFeaturesNV";
case StructureType::ePhysicalDevicePushConstantBankPropertiesNV : return "PhysicalDevicePushConstantBankPropertiesNV";
case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT : return "PhysicalDeviceRayTracingInvocationReorderFeaturesEXT";
case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT : return "PhysicalDeviceRayTracingInvocationReorderPropertiesEXT";
case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT : return "PhysicalDeviceDepthClampControlFeaturesEXT";
@@ -5633,6 +5702,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT: return "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT";
case StructureType::eComputeOccupancyPriorityParametersNV : return "ComputeOccupancyPriorityParametersNV";
case StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV : return "PhysicalDeviceComputeOccupancyPriorityFeaturesNV";
case StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT : return "PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@@ -6083,9 +6153,9 @@ namespace VULKAN_HPP_NAMESPACE
case ImageCreateFlagBits::eProtected : return "Protected";
case ImageCreateFlagBits::eDisjoint : return "Disjoint";
case ImageCreateFlagBits::eCornerSampledNV : return "CornerSampledNV";
case ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT : return "DescriptorHeapCaptureReplayEXT";
case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT : return "SampleLocationsCompatibleDepthEXT";
case ImageCreateFlagBits::eSubsampledEXT : return "SubsampledEXT";
case ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT : return "DescriptorBufferCaptureReplayEXT";
case ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT: return "MultisampledRenderToSingleSampledEXT";
case ImageCreateFlagBits::e2DViewCompatibleEXT : return "2DViewCompatibleEXT";
case ImageCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR";
@@ -6262,8 +6332,9 @@ namespace VULKAN_HPP_NAMESPACE
{
switch ( value )
{
case DeviceQueueCreateFlagBits::eProtected: return "Protected";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
case DeviceQueueCreateFlagBits::eProtected : return "Protected";
case DeviceQueueCreateFlagBits::eInternallySynchronizedKHR: return "InternallySynchronizedKHR";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@@ -6449,6 +6520,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case BufferUsageFlagBits::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case BufferUsageFlagBits::eDescriptorHeapEXT : return "DescriptorHeapEXT";
case BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR: return "AccelerationStructureBuildInputReadOnlyKHR";
case BufferUsageFlagBits::eAccelerationStructureStorageKHR : return "AccelerationStructureStorageKHR";
case BufferUsageFlagBits::eShaderBindingTableKHR : return "ShaderBindingTableKHR";
@@ -7565,7 +7637,7 @@ namespace VULKAN_HPP_NAMESPACE
case SubgroupFeatureFlagBits::eQuad : return "Quad";
case SubgroupFeatureFlagBits::eRotate : return "Rotate";
case SubgroupFeatureFlagBits::eRotateClustered: return "RotateClustered";
case SubgroupFeatureFlagBits::ePartitionedNV : return "PartitionedNV";
case SubgroupFeatureFlagBits::ePartitionedEXT : return "PartitionedEXT";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@@ -7850,6 +7922,8 @@ namespace VULKAN_HPP_NAMESPACE
case AccessFlagBits2::eShaderStorageWrite : return "ShaderStorageWrite";
case AccessFlagBits2::eVideoDecodeReadKHR : return "VideoDecodeReadKHR";
case AccessFlagBits2::eVideoDecodeWriteKHR : return "VideoDecodeWriteKHR";
case AccessFlagBits2::eSamplerHeapReadEXT : return "SamplerHeapReadEXT";
case AccessFlagBits2::eResourceHeapReadEXT : return "ResourceHeapReadEXT";
case AccessFlagBits2::eVideoEncodeReadKHR : return "VideoEncodeReadKHR";
case AccessFlagBits2::eVideoEncodeWriteKHR : return "VideoEncodeWriteKHR";
case AccessFlagBits2::eShaderTileAttachmentReadQCOM : return "ShaderTileAttachmentReadQCOM";
@@ -8020,6 +8094,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case BufferUsageFlagBits2::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case BufferUsageFlagBits2::eDescriptorHeapEXT : return "DescriptorHeapEXT";
case BufferUsageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT";
case BufferUsageFlagBits2::eShaderBindingTableKHR : return "ShaderBindingTableKHR";
case BufferUsageFlagBits2::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT";
@@ -8071,6 +8146,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case PipelineCreateFlagBits2::eExecutionGraphAMDX: return "ExecutionGraphAMDX";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case PipelineCreateFlagBits2::eDescriptorHeapEXT : return "DescriptorHeapEXT";
case PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV: return "RayTracingAllowSpheresAndLinearSweptSpheresNV";
case PipelineCreateFlagBits2::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT";
case PipelineCreateFlagBits2::eDeferCompileNV : return "DeferCompileNV";
@@ -8996,6 +9072,55 @@ namespace VULKAN_HPP_NAMESPACE
return "(void)";
}
//=== VK_EXT_descriptor_heap ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorMappingSourceEXT value )
{
switch ( value )
{
case DescriptorMappingSourceEXT::eHeapWithConstantOffset : return "HeapWithConstantOffset";
case DescriptorMappingSourceEXT::eHeapWithPushIndex : return "HeapWithPushIndex";
case DescriptorMappingSourceEXT::eHeapWithIndirectIndex : return "HeapWithIndirectIndex";
case DescriptorMappingSourceEXT::eHeapWithIndirectIndexArray: return "HeapWithIndirectIndexArray";
case DescriptorMappingSourceEXT::eResourceHeapData : return "ResourceHeapData";
case DescriptorMappingSourceEXT::ePushData : return "PushData";
case DescriptorMappingSourceEXT::ePushAddress : return "PushAddress";
case DescriptorMappingSourceEXT::eIndirectAddress : return "IndirectAddress";
case DescriptorMappingSourceEXT::eHeapWithShaderRecordIndex : return "HeapWithShaderRecordIndex";
case DescriptorMappingSourceEXT::eShaderRecordData : return "ShaderRecordData";
case DescriptorMappingSourceEXT::eShaderRecordAddress : return "ShaderRecordAddress";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SpirvResourceTypeFlagBitsEXT value )
{
switch ( value )
{
case SpirvResourceTypeFlagBitsEXT::eAll : return "All";
case SpirvResourceTypeFlagBitsEXT::eSampler : return "Sampler";
case SpirvResourceTypeFlagBitsEXT::eSampledImage : return "SampledImage";
case SpirvResourceTypeFlagBitsEXT::eReadOnlyImage : return "ReadOnlyImage";
case SpirvResourceTypeFlagBitsEXT::eReadWriteImage : return "ReadWriteImage";
case SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage : return "CombinedSampledImage";
case SpirvResourceTypeFlagBitsEXT::eUniformBuffer : return "UniformBuffer";
case SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer : return "ReadOnlyStorageBuffer";
case SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer: return "ReadWriteStorageBuffer";
case SpirvResourceTypeFlagBitsEXT::eAccelerationStructure : return "AccelerationStructure";
case SpirvResourceTypeFlagBitsEXT::eTensorARM : return "TensorARM";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorViewCreateFlagBitsARM value )
{
switch ( value )
{
case TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
//=== VK_EXT_blend_operation_advanced ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendOverlapEXT value )
@@ -9519,6 +9644,7 @@ namespace VULKAN_HPP_NAMESPACE
case IndirectCommandsTokenTypeNV::eDrawIndexed : return "DrawIndexed";
case IndirectCommandsTokenTypeNV::eDraw : return "Draw";
case IndirectCommandsTokenTypeNV::eDrawTasks : return "DrawTasks";
case IndirectCommandsTokenTypeNV::ePushData : return "PushData";
case IndirectCommandsTokenTypeNV::eDrawMeshTasks: return "DrawMeshTasks";
case IndirectCommandsTokenTypeNV::ePipeline : return "Pipeline";
case IndirectCommandsTokenTypeNV::eDispatch : return "Dispatch";
@@ -10129,20 +10255,12 @@ namespace VULKAN_HPP_NAMESPACE
{
case TensorCreateFlagBitsARM::eMutableFormat : return "MutableFormat";
case TensorCreateFlagBitsARM::eProtected : return "Protected";
case TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay : return "DescriptorHeapCaptureReplay";
case TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorViewCreateFlagBitsARM value )
{
switch ( value )
{
case TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorUsageFlagBitsARM value )
{
switch ( value )
@@ -10289,6 +10407,7 @@ namespace VULKAN_HPP_NAMESPACE
switch ( value )
{
case ShaderCreateFlagBitsEXT::eLinkStage : return "LinkStage";
case ShaderCreateFlagBitsEXT::eDescriptorHeap : return "DescriptorHeap";
case ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize : return "AllowVaryingSubgroupSize";
case ShaderCreateFlagBitsEXT::eRequireFullSubgroups : return "RequireFullSubgroups";
case ShaderCreateFlagBitsEXT::eNoTaskShader : return "NoTaskShader";
@@ -10814,22 +10933,24 @@ namespace VULKAN_HPP_NAMESPACE
{
switch ( value )
{
case IndirectCommandsTokenTypeEXT::eExecutionSet : return "ExecutionSet";
case IndirectCommandsTokenTypeEXT::ePushConstant : return "PushConstant";
case IndirectCommandsTokenTypeEXT::eSequenceIndex : return "SequenceIndex";
case IndirectCommandsTokenTypeEXT::eIndexBuffer : return "IndexBuffer";
case IndirectCommandsTokenTypeEXT::eVertexBuffer : return "VertexBuffer";
case IndirectCommandsTokenTypeEXT::eDrawIndexed : return "DrawIndexed";
case IndirectCommandsTokenTypeEXT::eDraw : return "Draw";
case IndirectCommandsTokenTypeEXT::eDrawIndexedCount : return "DrawIndexedCount";
case IndirectCommandsTokenTypeEXT::eDrawCount : return "DrawCount";
case IndirectCommandsTokenTypeEXT::eDispatch : return "Dispatch";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasksNV : return "DrawMeshTasksNV";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCountNV: return "DrawMeshTasksCountNV";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasks : return "DrawMeshTasks";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCount : return "DrawMeshTasksCount";
case IndirectCommandsTokenTypeEXT::eTraceRays2 : return "TraceRays2";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
case IndirectCommandsTokenTypeEXT::eExecutionSet : return "ExecutionSet";
case IndirectCommandsTokenTypeEXT::ePushConstant : return "PushConstant";
case IndirectCommandsTokenTypeEXT::eSequenceIndex : return "SequenceIndex";
case IndirectCommandsTokenTypeEXT::eIndexBuffer : return "IndexBuffer";
case IndirectCommandsTokenTypeEXT::eVertexBuffer : return "VertexBuffer";
case IndirectCommandsTokenTypeEXT::eDrawIndexed : return "DrawIndexed";
case IndirectCommandsTokenTypeEXT::eDraw : return "Draw";
case IndirectCommandsTokenTypeEXT::eDrawIndexedCount : return "DrawIndexedCount";
case IndirectCommandsTokenTypeEXT::eDrawCount : return "DrawCount";
case IndirectCommandsTokenTypeEXT::eDispatch : return "Dispatch";
case IndirectCommandsTokenTypeEXT::ePushData : return "PushData";
case IndirectCommandsTokenTypeEXT::ePushDataSequenceIndex: return "PushDataSequenceIndex";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasksNV : return "DrawMeshTasksNV";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCountNV : return "DrawMeshTasksCountNV";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasks : return "DrawMeshTasks";
case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCount : return "DrawMeshTasksCount";
case IndirectCommandsTokenTypeEXT::eTraceRays2 : return "TraceRays2";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}

2
third_party/vulkan/vulkan_video.cppm vendored
View File

@@ -25,7 +25,6 @@ export module vulkan:video;
export namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE
{
//=================
//=== CONSTANTs ===
//=================
@@ -320,5 +319,4 @@ export namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
#endif
} // namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE

1056
third_party/vulkan/vulkan_video.hpp vendored
View File

File diff suppressed because it is too large Load Diff