From d1f5b7c68e0a7fe77996582979fafefbf76d9688 Mon Sep 17 00:00:00 2001 From: kbJeff-8 Date: Sun, 10 May 2026 01:42:11 +0000 Subject: [PATCH] [BOT] update dependencies --- third_party/vulkan/vulkan.cppm | 16 +- third_party/vulkan/vulkan.hpp | 442 +- third_party/vulkan/vulkan_core.h | 608 ++- third_party/vulkan/vulkan_enums.hpp | 507 ++- .../vulkan/vulkan_extension_inspection.hpp | 90 +- third_party/vulkan/vulkan_funcs.hpp | 429 +- third_party/vulkan/vulkan_handles.hpp | 342 +- third_party/vulkan/vulkan_hash.hpp | 432 +- third_party/vulkan/vulkan_hpp_macros.hpp | 2 +- third_party/vulkan/vulkan_raii.hpp | 381 +- third_party/vulkan/vulkan_shared.hpp | 11 + .../vulkan/vulkan_static_assertions.hpp | 219 +- third_party/vulkan/vulkan_structs.hpp | 4002 ++++++++++++++++- third_party/vulkan/vulkan_to_string.hpp | 416 +- third_party/vulkan/vulkan_video.hpp | 1054 ++--- 15 files changed, 7875 insertions(+), 1076 deletions(-) diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index 1a82fbb..bb780fc 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -27,7 +27,7 @@ export module vulkan; export import std; -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 349, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 351, "Wrong VK_HEADER_VERSION!" ); #if defined( _MSC_VER ) # pragma warning( push ) @@ -603,6 +603,20 @@ export using ::PFN_vkGetMemoryAndroidHardwareBufferANDROID; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + using ::PFN_vkCmdBeginGpaSampleAMD; + using ::PFN_vkCmdBeginGpaSessionAMD; + using ::PFN_vkCmdCopyGpaSessionResultsAMD; + using ::PFN_vkCmdEndGpaSampleAMD; + using ::PFN_vkCmdEndGpaSessionAMD; + using ::PFN_vkCreateGpaSessionAMD; + using ::PFN_vkDestroyGpaSessionAMD; + using ::PFN_vkGetGpaDeviceClockInfoAMD; + using ::PFN_vkGetGpaSessionResultsAMD; + using ::PFN_vkGetGpaSessionStatusAMD; + using ::PFN_vkResetGpaSessionAMD; + using ::PFN_vkSetGpaDeviceClockModeAMD; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === using ::PFN_vkCmdDispatchGraphAMDX; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index aff7b4c..09ed33c 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -37,7 +37,7 @@ # endif #endif -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 349, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 351, "Wrong VK_HEADER_VERSION!" ); VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { @@ -1106,6 +1106,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdBeginConditionalRenderingEXT ) DECLARE_IS_DISPATCHED( vkCmdBeginCustomResolveEXT ) DECLARE_IS_DISPATCHED( vkCmdBeginDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkCmdBeginGpaSampleAMD ) + DECLARE_IS_DISPATCHED( vkCmdBeginGpaSessionAMD ) DECLARE_IS_DISPATCHED( vkCmdBeginPerTileExecutionQCOM ) DECLARE_IS_DISPATCHED( vkCmdBeginQuery ) DECLARE_IS_DISPATCHED( vkCmdBeginQueryIndexedEXT ) @@ -1165,6 +1167,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage ) DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage2 ) DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage2KHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyGpaSessionResultsAMD ) DECLARE_IS_DISPATCHED( vkCmdCopyImage ) DECLARE_IS_DISPATCHED( vkCmdCopyImage2 ) DECLARE_IS_DISPATCHED( vkCmdCopyImage2KHR ) @@ -1236,6 +1239,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdEncodeVideoKHR ) DECLARE_IS_DISPATCHED( vkCmdEndConditionalRenderingEXT ) DECLARE_IS_DISPATCHED( vkCmdEndDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkCmdEndGpaSampleAMD ) + DECLARE_IS_DISPATCHED( vkCmdEndGpaSessionAMD ) DECLARE_IS_DISPATCHED( vkCmdEndPerTileExecutionQCOM ) DECLARE_IS_DISPATCHED( vkCmdEndQuery ) DECLARE_IS_DISPATCHED( vkCmdEndQueryIndexedEXT ) @@ -1459,6 +1464,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCreateExternalComputeQueueNV ) DECLARE_IS_DISPATCHED( vkCreateFence ) DECLARE_IS_DISPATCHED( vkCreateFramebuffer ) + DECLARE_IS_DISPATCHED( vkCreateGpaSessionAMD ) DECLARE_IS_DISPATCHED( vkCreateGraphicsPipelines ) DECLARE_IS_DISPATCHED( vkCreateHeadlessSurfaceEXT ) DECLARE_IS_DISPATCHED( vkCreateIOSSurfaceMVK ) @@ -1535,6 +1541,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkDestroyExternalComputeQueueNV ) DECLARE_IS_DISPATCHED( vkDestroyFence ) DECLARE_IS_DISPATCHED( vkDestroyFramebuffer ) + DECLARE_IS_DISPATCHED( vkDestroyGpaSessionAMD ) DECLARE_IS_DISPATCHED( vkDestroyImage ) DECLARE_IS_DISPATCHED( vkDestroyImageView ) DECLARE_IS_DISPATCHED( vkDestroyIndirectCommandsLayoutEXT ) @@ -1667,6 +1674,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkGetFramebufferTilePropertiesQCOM ) DECLARE_IS_DISPATCHED( vkGetGeneratedCommandsMemoryRequirementsEXT ) DECLARE_IS_DISPATCHED( vkGetGeneratedCommandsMemoryRequirementsNV ) + DECLARE_IS_DISPATCHED( vkGetGpaDeviceClockInfoAMD ) + DECLARE_IS_DISPATCHED( vkGetGpaSessionResultsAMD ) + DECLARE_IS_DISPATCHED( vkGetGpaSessionStatusAMD ) DECLARE_IS_DISPATCHED( vkGetImageDrmFormatModifierPropertiesEXT ) DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements ) DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements2 ) @@ -1876,6 +1886,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkResetDescriptorPool ) DECLARE_IS_DISPATCHED( vkResetEvent ) DECLARE_IS_DISPATCHED( vkResetFences ) + DECLARE_IS_DISPATCHED( vkResetGpaSessionAMD ) DECLARE_IS_DISPATCHED( vkResetQueryPool ) DECLARE_IS_DISPATCHED( vkResetQueryPoolEXT ) DECLARE_IS_DISPATCHED( vkSetBufferCollectionBufferConstraintsFUCHSIA ) @@ -1884,6 +1895,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkSetDebugUtilsObjectTagEXT ) DECLARE_IS_DISPATCHED( vkSetDeviceMemoryPriorityEXT ) DECLARE_IS_DISPATCHED( vkSetEvent ) + DECLARE_IS_DISPATCHED( vkSetGpaDeviceClockModeAMD ) DECLARE_IS_DISPATCHED( vkSetHdrMetadataEXT ) DECLARE_IS_DISPATCHED( vkSetLatencyMarkerNV ) DECLARE_IS_DISPATCHED( vkSetLatencySleepModeNV ) @@ -4801,6 +4813,76 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + + VULKAN_HPP_INLINE VkResult vkCreateGpaSessionAMD( VkDevice device, + VkGpaSessionCreateInfoAMD const * pCreateInfo, + VkAllocationCallbacks const * pAllocator, + VkGpaSessionAMD * pGpaSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateGpaSessionAMD( device, pCreateInfo, pAllocator, pGpaSession ); + } + + VULKAN_HPP_INLINE void + vkDestroyGpaSessionAMD( VkDevice device, VkGpaSessionAMD gpaSession, VkAllocationCallbacks const * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyGpaSessionAMD( device, gpaSession, pAllocator ); + } + + VULKAN_HPP_INLINE VkResult vkSetGpaDeviceClockModeAMD( VkDevice device, VkGpaDeviceClockModeInfoAMD * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetGpaDeviceClockModeAMD( device, pInfo ); + } + + VULKAN_HPP_INLINE VkResult vkGetGpaDeviceClockInfoAMD( VkDevice device, VkGpaDeviceGetClockInfoAMD * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetGpaDeviceClockInfoAMD( device, pInfo ); + } + + VULKAN_HPP_INLINE VkResult vkCmdBeginGpaSessionAMD( VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginGpaSessionAMD( commandBuffer, gpaSession ); + } + + VULKAN_HPP_INLINE VkResult vkCmdEndGpaSessionAMD( VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndGpaSessionAMD( commandBuffer, gpaSession ); + } + + VULKAN_HPP_INLINE VkResult vkCmdBeginGpaSampleAMD( VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession, + VkGpaSampleBeginInfoAMD const * pGpaSampleBeginInfo, + uint32_t * pSampleID ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginGpaSampleAMD( commandBuffer, gpaSession, pGpaSampleBeginInfo, pSampleID ); + } + + VULKAN_HPP_INLINE void vkCmdEndGpaSampleAMD( VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndGpaSampleAMD( commandBuffer, gpaSession, sampleID ); + } + + VULKAN_HPP_INLINE VkResult vkGetGpaSessionStatusAMD( VkDevice device, VkGpaSessionAMD gpaSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetGpaSessionStatusAMD( device, gpaSession ); + } + + VULKAN_HPP_INLINE VkResult vkGetGpaSessionResultsAMD( + VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t * pSizeInBytes, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetGpaSessionResultsAMD( device, gpaSession, sampleID, pSizeInBytes, pData ); + } + + VULKAN_HPP_INLINE VkResult vkResetGpaSessionAMD( VkDevice device, VkGpaSessionAMD gpaSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetGpaSessionAMD( device, gpaSession ); + } + + VULKAN_HPP_INLINE void vkCmdCopyGpaSessionResultsAMD( VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyGpaSessionResultsAMD( commandBuffer, gpaSession ); + } + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === @@ -9761,6 +9843,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." ) VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16ExtensionName = VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME; + //=== VK_AMD_gpa_interface === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpaInterfaceSpecVersion = VK_AMD_GPA_INTERFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpaInterfaceExtensionName = VK_AMD_GPA_INTERFACE_EXTENSION_NAME; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueSpecVersion = VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION; @@ -9907,6 +9993,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE 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_QCOM_elapsed_timer_query === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMElapsedTimerQuerySpecVersion = VK_QCOM_ELAPSED_TIMER_QUERY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMElapsedTimerQueryExtensionName = VK_QCOM_ELAPSED_TIMER_QUERY_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; @@ -10343,6 +10433,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto QCOMQueuePerfHintSpecVersion = VK_QCOM_QUEUE_PERF_HINT_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto QCOMQueuePerfHintExtensionName = VK_QCOM_QUEUE_PERF_HINT_EXTENSION_NAME; + //=== VK_QCOM_image_processing3 === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing3SpecVersion = VK_QCOM_IMAGE_PROCESSING_3_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing3ExtensionName = VK_QCOM_IMAGE_PROCESSING_3_EXTENSION_NAME; + + //=== VK_QCOM_shader_multiple_wait_queues === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMShaderMultipleWaitQueuesSpecVersion = VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMShaderMultipleWaitQueuesExtensionName = VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_EXTENSION_NAME; + + //=== VK_EXT_shader_split_barrier === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSplitBarrierSpecVersion = VK_EXT_SHADER_SPLIT_BARRIER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSplitBarrierExtensionName = VK_EXT_SHADER_SPLIT_BARRIER_EXTENSION_NAME; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_cuda_kernel_launch === VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION; @@ -11143,6 +11245,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadySpecVersion = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadyExtensionName = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME; + //=== VK_KHR_opacity_micromap === + VULKAN_HPP_CONSTEXPR_INLINE auto KHROpacityMicromapSpecVersion = VK_KHR_OPACITY_MICROMAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHROpacityMicromapExtensionName = VK_KHR_OPACITY_MICROMAP_EXTENSION_NAME; + //=== VK_EXT_shader_64bit_indexing === VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingSpecVersion = VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingExtensionName = VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME; @@ -11179,6 +11285,10 @@ VULKAN_HPP_EXPORT 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_KHR_maintenance11 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance11SpecVersion = VK_KHR_MAINTENANCE_11_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance11ExtensionName = VK_KHR_MAINTENANCE_11_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; @@ -11193,6 +11303,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto VALVEShaderMixedFloatDotProductSpecVersion = VK_VALVE_SHADER_MIXED_FLOAT_DOT_PRODUCT_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto VALVEShaderMixedFloatDotProductExtensionName = VK_VALVE_SHADER_MIXED_FLOAT_DOT_PRODUCT_EXTENSION_NAME; + //=== VK_SEC_throttle_hint === + VULKAN_HPP_CONSTEXPR_INLINE auto SECThrottleHintSpecVersion = VK_SEC_THROTTLE_HINT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto SECThrottleHintExtensionName = VK_SEC_THROTTLE_HINT_EXTENSION_NAME; + + //=== VK_ARM_data_graph_neural_accelerator_statistics === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphNeuralAcceleratorStatisticsSpecVersion = VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphNeuralAcceleratorStatisticsExtensionName = VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_EXTENSION_NAME; + //=== VK_EXT_primitive_restart_index === VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveRestartIndexSpecVersion = VK_EXT_PRIMITIVE_RESTART_INDEX_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveRestartIndexExtensionName = VK_EXT_PRIMITIVE_RESTART_INDEX_EXTENSION_NAME; @@ -14394,6 +14512,43 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === template <> @@ -15021,6 +15176,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_QCOM_elapsed_timer_query === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_external_memory_host === template <> struct StructExtends @@ -16487,6 +16661,81 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_QCOM_image_processing3 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_shader_multiple_wait_queues === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_split_barrier === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_cuda_kernel_launch === template <> @@ -21823,6 +22072,62 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_opacity_micromap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_EXT_shader_64bit_indexing === template <> struct StructExtends @@ -22120,6 +22425,34 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_maintenance11 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_shader_subgroup_partitioned === template <> struct StructExtends @@ -22158,6 +22491,71 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_SEC_throttle_hint === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_data_graph_neural_accelerator_statistics === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_primitive_restart_index === template <> struct StructExtends @@ -22898,6 +23296,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + PFN_vkCreateGpaSessionAMD vkCreateGpaSessionAMD = 0; + PFN_vkDestroyGpaSessionAMD vkDestroyGpaSessionAMD = 0; + PFN_vkSetGpaDeviceClockModeAMD vkSetGpaDeviceClockModeAMD = 0; + PFN_vkGetGpaDeviceClockInfoAMD vkGetGpaDeviceClockInfoAMD = 0; + PFN_vkCmdBeginGpaSessionAMD vkCmdBeginGpaSessionAMD = 0; + PFN_vkCmdEndGpaSessionAMD vkCmdEndGpaSessionAMD = 0; + PFN_vkCmdBeginGpaSampleAMD vkCmdBeginGpaSampleAMD = 0; + PFN_vkCmdEndGpaSampleAMD vkCmdEndGpaSampleAMD = 0; + PFN_vkGetGpaSessionStatusAMD vkGetGpaSessionStatusAMD = 0; + PFN_vkGetGpaSessionResultsAMD vkGetGpaSessionResultsAMD = 0; + PFN_vkResetGpaSessionAMD vkResetGpaSessionAMD = 0; + PFN_vkCmdCopyGpaSessionResultsAMD vkCmdCopyGpaSessionResultsAMD = 0; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0; @@ -24404,6 +24816,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + vkCreateGpaSessionAMD = PFN_vkCreateGpaSessionAMD( vkGetInstanceProcAddr( instance, "vkCreateGpaSessionAMD" ) ); + vkDestroyGpaSessionAMD = PFN_vkDestroyGpaSessionAMD( vkGetInstanceProcAddr( instance, "vkDestroyGpaSessionAMD" ) ); + vkSetGpaDeviceClockModeAMD = PFN_vkSetGpaDeviceClockModeAMD( vkGetInstanceProcAddr( instance, "vkSetGpaDeviceClockModeAMD" ) ); + vkGetGpaDeviceClockInfoAMD = PFN_vkGetGpaDeviceClockInfoAMD( vkGetInstanceProcAddr( instance, "vkGetGpaDeviceClockInfoAMD" ) ); + vkCmdBeginGpaSessionAMD = PFN_vkCmdBeginGpaSessionAMD( vkGetInstanceProcAddr( instance, "vkCmdBeginGpaSessionAMD" ) ); + vkCmdEndGpaSessionAMD = PFN_vkCmdEndGpaSessionAMD( vkGetInstanceProcAddr( instance, "vkCmdEndGpaSessionAMD" ) ); + vkCmdBeginGpaSampleAMD = PFN_vkCmdBeginGpaSampleAMD( vkGetInstanceProcAddr( instance, "vkCmdBeginGpaSampleAMD" ) ); + vkCmdEndGpaSampleAMD = PFN_vkCmdEndGpaSampleAMD( vkGetInstanceProcAddr( instance, "vkCmdEndGpaSampleAMD" ) ); + vkGetGpaSessionStatusAMD = PFN_vkGetGpaSessionStatusAMD( vkGetInstanceProcAddr( instance, "vkGetGpaSessionStatusAMD" ) ); + vkGetGpaSessionResultsAMD = PFN_vkGetGpaSessionResultsAMD( vkGetInstanceProcAddr( instance, "vkGetGpaSessionResultsAMD" ) ); + vkResetGpaSessionAMD = PFN_vkResetGpaSessionAMD( vkGetInstanceProcAddr( instance, "vkResetGpaSessionAMD" ) ); + vkCmdCopyGpaSessionResultsAMD = PFN_vkCmdCopyGpaSessionResultsAMD( vkGetInstanceProcAddr( instance, "vkCmdCopyGpaSessionResultsAMD" ) ); + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === vkCreateExecutionGraphPipelinesAMDX = @@ -25850,6 +26276,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + vkCreateGpaSessionAMD = PFN_vkCreateGpaSessionAMD( vkGetDeviceProcAddr( device, "vkCreateGpaSessionAMD" ) ); + vkDestroyGpaSessionAMD = PFN_vkDestroyGpaSessionAMD( vkGetDeviceProcAddr( device, "vkDestroyGpaSessionAMD" ) ); + vkSetGpaDeviceClockModeAMD = PFN_vkSetGpaDeviceClockModeAMD( vkGetDeviceProcAddr( device, "vkSetGpaDeviceClockModeAMD" ) ); + vkGetGpaDeviceClockInfoAMD = PFN_vkGetGpaDeviceClockInfoAMD( vkGetDeviceProcAddr( device, "vkGetGpaDeviceClockInfoAMD" ) ); + vkCmdBeginGpaSessionAMD = PFN_vkCmdBeginGpaSessionAMD( vkGetDeviceProcAddr( device, "vkCmdBeginGpaSessionAMD" ) ); + vkCmdEndGpaSessionAMD = PFN_vkCmdEndGpaSessionAMD( vkGetDeviceProcAddr( device, "vkCmdEndGpaSessionAMD" ) ); + vkCmdBeginGpaSampleAMD = PFN_vkCmdBeginGpaSampleAMD( vkGetDeviceProcAddr( device, "vkCmdBeginGpaSampleAMD" ) ); + vkCmdEndGpaSampleAMD = PFN_vkCmdEndGpaSampleAMD( vkGetDeviceProcAddr( device, "vkCmdEndGpaSampleAMD" ) ); + vkGetGpaSessionStatusAMD = PFN_vkGetGpaSessionStatusAMD( vkGetDeviceProcAddr( device, "vkGetGpaSessionStatusAMD" ) ); + vkGetGpaSessionResultsAMD = PFN_vkGetGpaSessionResultsAMD( vkGetDeviceProcAddr( device, "vkGetGpaSessionResultsAMD" ) ); + vkResetGpaSessionAMD = PFN_vkResetGpaSessionAMD( vkGetDeviceProcAddr( device, "vkResetGpaSessionAMD" ) ); + vkCmdCopyGpaSessionResultsAMD = PFN_vkCmdCopyGpaSessionResultsAMD( vkGetDeviceProcAddr( device, "vkCmdCopyGpaSessionResultsAMD" ) ); + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index 419c382..042cf48 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -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 349 +#define VK_HEADER_VERSION 351 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -640,6 +640,13 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD = 1000133000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD = 1000133001, + VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD = 1000133002, + VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD = 1000133003, + VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD = 1000133004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD = 1000133005, + VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD = 1000133006, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX = 1000134000, #endif @@ -739,6 +746,7 @@ typedef enum VkStructureType { 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_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM = 1000173000, 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, @@ -884,6 +892,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM = 1000302000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM = 1000302001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM = 1000302002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM = 1000303000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM = 1000304000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM = 1000304001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT = 1000305000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT = 1000305001, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, #endif @@ -1418,6 +1431,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR = 1000623000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR = 1000623001, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR = 1000623002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR = 1000623003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT = 1000628000, VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT = 1000628001, @@ -1444,9 +1461,16 @@ 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_MAINTENANCE_11_FEATURES_KHR = 1000657000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR = 1000657001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000, VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC = 1000664000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE = 1000673000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC = 1000674000, + VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC = 1000674001, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM = 1000676000, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM = 1000676001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM = 1000676002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT = 1000678000, 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, @@ -1746,6 +1770,7 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_GPA_SESSION_AMD = 1000133000, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, @@ -2195,6 +2220,7 @@ typedef enum VkQueryType { VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + VK_QUERY_TYPE_TIME_ELAPSED_QCOM = 1000173000, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, @@ -2725,6 +2751,7 @@ typedef enum VkImageCreateFlagBits { VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000, VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000, + VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR = 0x00400000, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, @@ -3179,10 +3206,10 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, - VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000, #endif + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR = 0x01000000, // VK_PIPELINE_CREATE_DISPATCH_BASE is a legacy alias VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, @@ -3195,6 +3222,7 @@ typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -3203,6 +3231,7 @@ typedef VkFlags VkPipelineCreateFlags; typedef enum VkPipelineLayoutCreateFlagBits { VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, + VK_PIPELINE_LAYOUT_CREATE_NO_TASK_SHADER_BIT_KHR = 0x00000004, VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkPipelineLayoutCreateFlagBits; typedef VkFlags VkPipelineLayoutCreateFlags; @@ -7289,6 +7318,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM = 0x100000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; @@ -8206,6 +8236,8 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT 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_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; 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; @@ -8230,8 +8262,6 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STO static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; #ifdef VK_ENABLE_BETA_EXTENSIONS static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX = 0x200000000ULL; #endif @@ -8269,6 +8299,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_ #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_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; 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; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; @@ -8295,7 +8326,6 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BI static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; @@ -8309,6 +8339,8 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_B static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR = 0x01000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR = 0x20000000000ULL; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT = 0x80000000000ULL; typedef struct VkPhysicalDeviceVulkan14Features { @@ -12420,6 +12452,7 @@ typedef enum VkAccelerationStructureTypeKHR { VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR = 1000623000, VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF @@ -14579,6 +14612,86 @@ typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR { +// VK_KHR_opacity_micromap is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_opacity_micromap 1 +#define VK_KHR_OPACITY_MICROMAP_SPEC_VERSION 1 +#define VK_KHR_OPACITY_MICROMAP_EXTENSION_NAME "VK_KHR_opacity_micromap" + +typedef enum VkOpacityMicromapFormatKHR { + VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR = 1, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR = 2, + VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR, + VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkOpacityMicromapFormatKHR; + +typedef enum VkOpacityMicromapSpecialIndexKHR { + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR = -1, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR = -2, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR = -3, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR = -4, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_KHR = 0x7FFFFFFF +} VkOpacityMicromapSpecialIndexKHR; + +typedef enum VkAccelerationStructureSerializedBlockTypeKHR { + VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR = 0, + VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureSerializedBlockTypeKHR; +typedef struct VkMicromapUsageKHR { + uint32_t count; + uint32_t subdivisionLevel; + VkOpacityMicromapFormatKHR format; +} VkMicromapUsageKHR; + +typedef struct VkAccelerationStructureGeometryMicromapDataKHR { + VkStructureType sType; + const void* pNext; + uint32_t usageCountsCount; + const VkMicromapUsageKHR* pUsageCounts; + const VkMicromapUsageKHR* const* ppUsageCounts; + VkDeviceAddress data; + VkDeviceAddress triangleArray; + VkDeviceSize triangleArrayStride; +} VkAccelerationStructureGeometryMicromapDataKHR; + +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 micromap; +} VkPhysicalDeviceOpacityMicromapFeaturesKHR; + +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; + uint32_t maxOpacityLossy4StateSubdivisionLevel; + uint64_t maxMicromapTriangles; +} VkPhysicalDeviceOpacityMicromapPropertiesKHR; + +typedef struct VkMicromapTriangleKHR { + uint32_t dataOffset; + uint16_t subdivisionLevel; + uint16_t format; +} VkMicromapTriangleKHR; + +typedef struct VkAccelerationStructureTrianglesOpacityMicromapKHR { + VkStructureType sType; + void* pNext; + VkIndexType indexType; + VkDeviceAddress indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + VkAccelerationStructureKHR micromap; +} VkAccelerationStructureTrianglesOpacityMicromapKHR; + + + // VK_KHR_maintenance10 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_maintenance10 1 #define VK_KHR_MAINTENANCE_10_SPEC_VERSION 1 @@ -14642,6 +14755,24 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR( #endif +// VK_KHR_maintenance11 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance11 1 +#define VK_KHR_MAINTENANCE_11_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_11_EXTENSION_NAME "VK_KHR_maintenance11" +typedef struct VkPhysicalDeviceMaintenance11FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance11; +} VkPhysicalDeviceMaintenance11FeaturesKHR; + +typedef struct VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent3D optimalImageTransferGranularity; +} VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR; + + + // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) @@ -16107,6 +16238,285 @@ typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFil #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" +// VK_AMD_gpa_interface is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_gpa_interface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkGpaSessionAMD) +#define VK_AMD_GPA_INTERFACE_SPEC_VERSION 1 +#define VK_AMD_GPA_INTERFACE_EXTENSION_NAME "VK_AMD_gpa_interface" + +typedef enum VkGpaPerfBlockAMD { + VK_GPA_PERF_BLOCK_CPF_AMD = 0, + VK_GPA_PERF_BLOCK_IA_AMD = 1, + VK_GPA_PERF_BLOCK_VGT_AMD = 2, + VK_GPA_PERF_BLOCK_PA_AMD = 3, + VK_GPA_PERF_BLOCK_SC_AMD = 4, + VK_GPA_PERF_BLOCK_SPI_AMD = 5, + VK_GPA_PERF_BLOCK_SQ_AMD = 6, + VK_GPA_PERF_BLOCK_SX_AMD = 7, + VK_GPA_PERF_BLOCK_TA_AMD = 8, + VK_GPA_PERF_BLOCK_TD_AMD = 9, + VK_GPA_PERF_BLOCK_TCP_AMD = 10, + VK_GPA_PERF_BLOCK_TCC_AMD = 11, + VK_GPA_PERF_BLOCK_TCA_AMD = 12, + VK_GPA_PERF_BLOCK_DB_AMD = 13, + VK_GPA_PERF_BLOCK_CB_AMD = 14, + VK_GPA_PERF_BLOCK_GDS_AMD = 15, + VK_GPA_PERF_BLOCK_SRBM_AMD = 16, + VK_GPA_PERF_BLOCK_GRBM_AMD = 17, + VK_GPA_PERF_BLOCK_GRBM_SE_AMD = 18, + VK_GPA_PERF_BLOCK_RLC_AMD = 19, + VK_GPA_PERF_BLOCK_DMA_AMD = 20, + VK_GPA_PERF_BLOCK_MC_AMD = 21, + VK_GPA_PERF_BLOCK_CPG_AMD = 22, + VK_GPA_PERF_BLOCK_CPC_AMD = 23, + VK_GPA_PERF_BLOCK_WD_AMD = 24, + VK_GPA_PERF_BLOCK_TCS_AMD = 25, + VK_GPA_PERF_BLOCK_ATC_AMD = 26, + VK_GPA_PERF_BLOCK_ATC_L2_AMD = 27, + VK_GPA_PERF_BLOCK_MC_VM_L2_AMD = 28, + VK_GPA_PERF_BLOCK_EA_AMD = 29, + VK_GPA_PERF_BLOCK_RPB_AMD = 30, + VK_GPA_PERF_BLOCK_RMI_AMD = 31, + VK_GPA_PERF_BLOCK_UMCCH_AMD = 32, + VK_GPA_PERF_BLOCK_GE_AMD = 33, + VK_GPA_PERF_BLOCK_GL1A_AMD = 34, + VK_GPA_PERF_BLOCK_GL1C_AMD = 35, + VK_GPA_PERF_BLOCK_GL1CG_AMD = 36, + VK_GPA_PERF_BLOCK_GL2A_AMD = 37, + VK_GPA_PERF_BLOCK_GL2C_AMD = 38, + VK_GPA_PERF_BLOCK_CHA_AMD = 39, + VK_GPA_PERF_BLOCK_CHC_AMD = 40, + VK_GPA_PERF_BLOCK_CHCG_AMD = 41, + VK_GPA_PERF_BLOCK_GUS_AMD = 42, + VK_GPA_PERF_BLOCK_GCR_AMD = 43, + VK_GPA_PERF_BLOCK_PH_AMD = 44, + VK_GPA_PERF_BLOCK_UTCL1_AMD = 45, + VK_GPA_PERF_BLOCK_GE_DIST_AMD = 46, + VK_GPA_PERF_BLOCK_GE_SE_AMD = 47, + VK_GPA_PERF_BLOCK_DF_MALL_AMD = 48, + VK_GPA_PERF_BLOCK_SQ_WGP_AMD = 49, + VK_GPA_PERF_BLOCK_PC_AMD = 50, + VK_GPA_PERF_BLOCK_GL1XA_AMD = 51, + VK_GPA_PERF_BLOCK_GL1XC_AMD = 52, + VK_GPA_PERF_BLOCK_WGS_AMD = 53, + VK_GPA_PERF_BLOCK_EACPWD_AMD = 54, + VK_GPA_PERF_BLOCK_EASE_AMD = 55, + VK_GPA_PERF_BLOCK_RLCUSER_AMD = 56, + VK_GPA_PERF_BLOCK_GE1_AMD = VK_GPA_PERF_BLOCK_GE_AMD, + VK_GPA_PERF_BLOCK_RLCLOCAL_AMD = VK_GPA_PERF_BLOCK_RLCUSER_AMD, + VK_GPA_PERF_BLOCK_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaPerfBlockAMD; + +typedef enum VkGpaSampleTypeAMD { + VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD = 0, + VK_GPA_SAMPLE_TYPE_TRACE_AMD = 1, + VK_GPA_SAMPLE_TYPE_TIMING_AMD = 2, + VK_GPA_SAMPLE_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaSampleTypeAMD; + +typedef enum VkGpaDeviceClockModeAMD { + VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD = 0, + VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD = 1, + VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD = 2, + VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD = 3, + VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD = 4, + VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD = 5, + VK_GPA_DEVICE_CLOCK_MODE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaDeviceClockModeAMD; + +typedef enum VkGpaSqShaderStageFlagBitsAMD { + VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD = 0x00000001, + VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD = 0x00000002, + VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD = 0x00000004, + VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD = 0x00000008, + VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD = 0x00000010, + VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD = 0x00000020, + VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD = 0x00000040, + VK_GPA_SQ_SHADER_STAGE_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkGpaSqShaderStageFlagBitsAMD; +typedef VkFlags VkGpaSqShaderStageFlagsAMD; +typedef VkFlags VkGpaPerfBlockPropertiesFlagsAMD; +typedef VkFlags VkPhysicalDeviceGpaPropertiesFlagsAMD; +typedef struct VkGpaPerfBlockPropertiesAMD { + VkGpaPerfBlockAMD blockType; + VkGpaPerfBlockPropertiesFlagsAMD flags; + uint32_t instanceCount; + uint32_t maxEventID; + uint32_t maxGlobalOnlyCounters; + uint32_t maxGlobalSharedCounters; + uint32_t maxStreamingCounters; +} VkGpaPerfBlockPropertiesAMD; + +typedef struct VkPhysicalDeviceGpaFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 perfCounters; + VkBool32 streamingPerfCounters; + VkBool32 sqThreadTracing; + VkBool32 clockModes; +} VkPhysicalDeviceGpaFeaturesAMD; + +typedef struct VkPhysicalDeviceGpaPropertiesAMD { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceGpaPropertiesFlagsAMD flags; + VkDeviceSize maxSqttSeBufferSize; + uint32_t shaderEngineCount; + uint32_t perfBlockCount; + VkGpaPerfBlockPropertiesAMD* pPerfBlocks; +} VkPhysicalDeviceGpaPropertiesAMD; + +typedef struct VkPhysicalDeviceGpaProperties2AMD { + VkStructureType sType; + void* pNext; + uint32_t revisionId; +} VkPhysicalDeviceGpaProperties2AMD; + +typedef struct VkGpaPerfCounterAMD { + VkGpaPerfBlockAMD blockType; + uint32_t blockInstance; + uint32_t eventID; +} VkGpaPerfCounterAMD; + +typedef struct VkGpaSampleBeginInfoAMD { + VkStructureType sType; + const void* pNext; + VkGpaSampleTypeAMD sampleType; + VkBool32 sampleInternalOperations; + VkBool32 cacheFlushOnCounterCollection; + VkBool32 sqShaderMaskEnable; + VkGpaSqShaderStageFlagsAMD sqShaderMask; + uint32_t perfCounterCount; + const VkGpaPerfCounterAMD* pPerfCounters; + uint32_t streamingPerfTraceSampleInterval; + VkDeviceSize perfCounterDeviceMemoryLimit; + VkBool32 sqThreadTraceEnable; + VkBool32 sqThreadTraceSuppressInstructionTokens; + VkDeviceSize sqThreadTraceDeviceMemoryLimit; + VkPipelineStageFlags timingPreSample; + VkPipelineStageFlags timingPostSample; +} VkGpaSampleBeginInfoAMD; + +typedef struct VkGpaDeviceClockModeInfoAMD { + VkStructureType sType; + const void* pNext; + VkGpaDeviceClockModeAMD clockMode; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; +} VkGpaDeviceClockModeInfoAMD; + +typedef struct VkGpaDeviceGetClockInfoAMD { + VkStructureType sType; + void* pNext; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; + uint32_t memoryClockFrequency; + uint32_t engineClockFrequency; +} VkGpaDeviceGetClockInfoAMD; + +typedef struct VkGpaSessionCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkGpaSessionAMD secondaryCopySource; +} VkGpaSessionCreateInfoAMD; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateGpaSessionAMD)(VkDevice device, const VkGpaSessionCreateInfoAMD* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkGpaSessionAMD* pGpaSession); +typedef void (VKAPI_PTR *PFN_vkDestroyGpaSessionAMD)(VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkSetGpaDeviceClockModeAMD)(VkDevice device, VkGpaDeviceClockModeInfoAMD* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaDeviceClockInfoAMD)(VkDevice device, VkGpaDeviceGetClockInfoAMD* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCmdBeginGpaSessionAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); +typedef VkResult (VKAPI_PTR *PFN_vkCmdEndGpaSessionAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); +typedef VkResult (VKAPI_PTR *PFN_vkCmdBeginGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD* pGpaSampleBeginInfo, uint32_t* pSampleID); +typedef void (VKAPI_PTR *PFN_vkCmdEndGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionStatusAMD)(VkDevice device, VkGpaSessionAMD gpaSession); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionResultsAMD)(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t* pSizeInBytes, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkResetGpaSessionAMD)(VkDevice device, VkGpaSessionAMD gpaSession); +typedef void (VKAPI_PTR *PFN_vkCmdCopyGpaSessionResultsAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGpaSessionAMD( + VkDevice device, + const VkGpaSessionCreateInfoAMD* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkGpaSessionAMD* pGpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyGpaSessionAMD( + VkDevice device, + VkGpaSessionAMD gpaSession, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetGpaDeviceClockModeAMD( + VkDevice device, + VkGpaDeviceClockModeInfoAMD* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetGpaDeviceClockInfoAMD( + VkDevice device, + VkGpaDeviceGetClockInfoAMD* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdBeginGpaSessionAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdEndGpaSessionAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdBeginGpaSampleAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession, + const VkGpaSampleBeginInfoAMD* pGpaSampleBeginInfo, + uint32_t* pSampleID); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndGpaSampleAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession, + uint32_t sampleID); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetGpaSessionStatusAMD( + VkDevice device, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetGpaSessionResultsAMD( + VkDevice device, + VkGpaSessionAMD gpaSession, + uint32_t sampleID, + size_t* pSizeInBytes, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkResetGpaSessionAMD( + VkDevice device, + VkGpaSessionAMD gpaSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyGpaSessionResultsAMD( + VkCommandBuffer commandBuffer, + VkGpaSessionAMD gpaSession); +#endif +#endif + + // 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) @@ -17006,6 +17416,7 @@ typedef enum VkGeometryTypeKHR { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX = 1000478000, #endif + VK_GEOMETRY_TYPE_MICROMAP_KHR = 1000623000, VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF @@ -17052,15 +17463,17 @@ typedef enum VkGeometryInstanceFlagBitsKHR { VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, - VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 0x00000010, - VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000020, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR = 0x00000020, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR, // VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT is a legacy alias VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR, // VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF @@ -17078,21 +17491,24 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR { VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = 0x00000040, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000080, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 0x00000100, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 0x00000200, #endif VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR = 0x00000400, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR, // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR, // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT is a legacy alias @@ -17450,6 +17866,18 @@ typedef struct VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM { +// VK_QCOM_elapsed_timer_query is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_elapsed_timer_query 1 +#define VK_QCOM_ELAPSED_TIMER_QUERY_SPEC_VERSION 1 +#define VK_QCOM_ELAPSED_TIMER_QUERY_EXTENSION_NAME "VK_QCOM_elapsed_timer_query" +typedef struct VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 elapsedTimerQuery; +} VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM; + + + // 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 @@ -19588,6 +20016,56 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerfHintQCOM( #endif +// VK_QCOM_image_processing3 is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_image_processing3 1 +#define VK_QCOM_IMAGE_PROCESSING_3_SPEC_VERSION 1 +#define VK_QCOM_IMAGE_PROCESSING_3_EXTENSION_NAME "VK_QCOM_image_processing3" +typedef struct VkPhysicalDeviceImageProcessing3FeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 imageGatherLinear; + VkBool32 imageGatherExtendedModes; + VkBool32 blockMatchExtendedClampToEdge; +} VkPhysicalDeviceImageProcessing3FeaturesQCOM; + + + +// VK_QCOM_shader_multiple_wait_queues is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_shader_multiple_wait_queues 1 +#define VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_SPEC_VERSION 1 +#define VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_EXTENSION_NAME "VK_QCOM_shader_multiple_wait_queues" +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 shaderMultipleWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxShaderWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + + + +// VK_EXT_shader_split_barrier is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_split_barrier 1 +#define VK_EXT_SHADER_SPLIT_BARRIER_SPEC_VERSION 1 +#define VK_EXT_SHADER_SPLIT_BARRIER_EXTENSION_NAME "VK_EXT_shader_split_barrier" +typedef struct VkPhysicalDeviceShaderSplitBarrierFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderSplitBarrier; +} VkPhysicalDeviceShaderSplitBarrierFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderSplitBarrierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t splitBarrierReservedSharedMemory; +} VkPhysicalDeviceShaderSplitBarrierPropertiesEXT; + + + // VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_tile_shading 1 #define VK_QCOM_TILE_SHADING_SPEC_VERSION 2 @@ -20978,21 +21456,10 @@ typedef enum VkCopyMicromapModeEXT { VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF } VkCopyMicromapModeEXT; +typedef VkOpacityMicromapFormatKHR VkOpacityMicromapFormatEXT; -typedef enum VkOpacityMicromapFormatEXT { - VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, - VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, - VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapFormatEXT; +typedef VkOpacityMicromapSpecialIndexKHR VkOpacityMicromapSpecialIndexEXT; -typedef enum VkOpacityMicromapSpecialIndexEXT { - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapSpecialIndexEXT; typedef enum VkAccelerationStructureCompatibilityKHR { VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, @@ -21124,26 +21591,22 @@ typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { VkMicromapEXT micromap; } VkAccelerationStructureTrianglesOpacityMicromapEXT; -typedef struct VkMicromapTriangleEXT { - uint32_t dataOffset; - uint16_t subdivisionLevel; - uint16_t format; -} VkMicromapTriangleEXT; +typedef VkMicromapTriangleKHR VkMicromapTriangleEXT; -typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); -typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); -typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); #ifndef VK_NO_PROTOTYPES #ifndef VK_ONLY_EXPORTED_PROTOTYPES @@ -22905,7 +23368,9 @@ typedef enum VkShaderCreateFlagBitsEXT { VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, + VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT = 0x00001000, VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT = 0x00008000, + VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR = 0x00040000, VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkShaderCreateFlagBitsEXT; typedef VkFlags VkShaderCreateFlagsEXT; @@ -23448,6 +23913,7 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM) typedef enum VkDataGraphPipelineSessionBindPointARM { VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM = 1000631001, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_NEURAL_ACCELERATOR_STATISTICS_ARM = 1000676000, VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_MAX_ENUM_ARM = 0x7FFFFFFF } VkDataGraphPipelineSessionBindPointARM; @@ -23459,6 +23925,8 @@ typedef enum VkDataGraphPipelineSessionBindPointTypeARM { typedef enum VkDataGraphPipelinePropertyARM { VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0, VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1, + VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_DEBUG_DATABASE_ARM = 1000676000, + VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_STATISTICS_INFO_ARM = 1000676001, VK_DATA_GRAPH_PIPELINE_PROPERTY_MAX_ENUM_ARM = 0x7FFFFFFF } VkDataGraphPipelinePropertyARM; @@ -24944,7 +25412,7 @@ typedef struct 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 +#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 2 #define VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_EXT_ray_tracing_invocation_reorder" typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT { VkStructureType sType; @@ -25646,6 +26114,62 @@ typedef struct VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE { +// VK_SEC_throttle_hint is a preprocessor guard. Do not pass it to API calls. +#define VK_SEC_throttle_hint 1 +#define VK_SEC_THROTTLE_HINT_SPEC_VERSION 1 +#define VK_SEC_THROTTLE_HINT_EXTENSION_NAME "VK_SEC_throttle_hint" + +typedef enum VkThrottleHintTypeSEC { + VK_THROTTLE_HINT_TYPE_DEFAULT_SEC = 0, + VK_THROTTLE_HINT_TYPE_LOW_SEC = 1, + VK_THROTTLE_HINT_TYPE_HIGH_SEC = 2, + VK_THROTTLE_HINT_TYPE_MAX_ENUM_SEC = 0x7FFFFFFF +} VkThrottleHintTypeSEC; +typedef struct VkThrottleHintSubmitInfoSEC { + VkStructureType sType; + const void* pNext; + VkThrottleHintTypeSEC throttleHint; +} VkThrottleHintSubmitInfoSEC; + +typedef struct VkPhysicalDeviceThrottleHintFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 throttleHint; +} VkPhysicalDeviceThrottleHintFeaturesSEC; + + + +// VK_ARM_data_graph_neural_accelerator_statistics is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_data_graph_neural_accelerator_statistics 1 +#define VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_EXTENSION_NAME "VK_ARM_data_graph_neural_accelerator_statistics" + +typedef enum VkNeuralAcceleratorStatisticsModeARM { + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_DISABLED_ARM = 0, + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS0_ARM = 1, + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS1_ARM = 2, + VK_NEURAL_ACCELERATOR_STATISTICS_MODE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkNeuralAcceleratorStatisticsModeARM; +typedef struct VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 dataGraphNeuralAcceleratorStatistics; +} VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + +typedef struct VkDataGraphPipelineNeuralStatisticsCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkBool32 allowNeuralStatistics; +} VkDataGraphPipelineNeuralStatisticsCreateInfoARM; + +typedef struct VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkNeuralAcceleratorStatisticsModeARM mode; +} VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + + + // VK_EXT_primitive_restart_index is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_primitive_restart_index 1 #define VK_EXT_PRIMITIVE_RESTART_INDEX_SPEC_VERSION 1 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index 9c19b99..99f6da0 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -986,6 +986,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, eAndroidHardwareBufferFormatProperties2ANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID, #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + ePhysicalDeviceGpaFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD, + ePhysicalDeviceGpaPropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD, + eGpaSampleBeginInfoAMD = VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD, + eGpaSessionCreateInfoAMD = VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD, + eGpaDeviceClockModeInfoAMD = VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD, + ePhysicalDeviceGpaProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD, + eGpaDeviceGetClockInfoAMD = VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD, #if defined( VK_ENABLE_BETA_EXTENSIONS ) ePhysicalDeviceShaderEnqueueFeaturesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, ePhysicalDeviceShaderEnqueuePropertiesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX, @@ -1076,6 +1083,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE 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, + ePhysicalDeviceElapsedTimerQueryFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_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, @@ -1232,6 +1240,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ePerfHintInfoQCOM = VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM, ePhysicalDeviceQueuePerfHintFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM, ePhysicalDeviceQueuePerfHintPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM, + ePhysicalDeviceImageProcessing3FeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM, + ePhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM, + ePhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM, + ePhysicalDeviceShaderSplitBarrierFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT, + ePhysicalDeviceShaderSplitBarrierPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) eCudaModuleCreateInfoNV = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV, eCudaFunctionCreateInfoNV = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV, @@ -1795,6 +1808,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT, ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, ePhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT, + ePhysicalDeviceOpacityMicromapFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR, + ePhysicalDeviceOpacityMicromapPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR, + eAccelerationStructureGeometryMicromapDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR, + eAccelerationStructureTrianglesOpacityMicromapKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR, ePhysicalDeviceShader64BitIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT, ePhysicalDeviceCustomResolveFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT, eBeginCustomResolveInfoEXT = VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT, @@ -1822,12 +1839,19 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE 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, + ePhysicalDeviceMaintenance11FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR, + eQueueFamilyOptimalImageTransferGranularityPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR, ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT, #if defined( VK_USE_PLATFORM_UBM_SEC ) eUbmSurfaceCreateInfoSEC = VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC, #endif /*VK_USE_PLATFORM_UBM_SEC*/ - ePhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE, - ePhysicalDevicePrimitiveRestartIndexFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT + ePhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE, + ePhysicalDeviceThrottleHintFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC, + eThrottleHintSubmitInfoSEC = VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC, + eDataGraphPipelineNeuralStatisticsCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM, + eDataGraphPipelineSessionNeuralStatisticsCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM, + ePhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM, + ePhysicalDevicePrimitiveRestartIndexFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT }; // wrapper class for enum VkObjectType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkObjectType.html @@ -1875,6 +1899,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eCuModuleNVX = VK_OBJECT_TYPE_CU_MODULE_NVX, eCuFunctionNVX = VK_OBJECT_TYPE_CU_FUNCTION_NVX, eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, + eGpaSessionAMD = VK_OBJECT_TYPE_GPA_SESSION_AMD, eAccelerationStructureKHR = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, @@ -2377,7 +2402,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE e2DViewCompatibleEXT = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT, eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, eFragmentDensityMapOffsetEXT = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, - eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM + eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, + eAliasSingleLayerDescriptorKHR = VK_IMAGE_CREATE_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR }; // wrapper using for bitmask VkImageCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlags.html @@ -2395,7 +2421,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV | ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT | ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT | - ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT; + ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT | + ImageCreateFlagBits::eAliasSingleLayerDescriptorKHR; }; // wrapper class for enum VkImageTiling, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageTiling.html @@ -2959,6 +2986,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eAccelerationStructureCompactedSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR, eAccelerationStructureSerializationSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR, eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV, + eTimeElapsedQCOM = VK_QUERY_TYPE_TIME_ELAPSED_QCOM, ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL, eVideoEncodeFeedbackKHR = VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, eMeshPrimitivesGeneratedEXT = VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT, @@ -3474,47 +3502,46 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper class for enum VkPipelineCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits.html enum class PipelineCreateFlagBits : VkPipelineCreateFlags { - eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, - eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, - eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, - eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR, - eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, - eFailOnPipelineCompileRequired = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, - eFailOnPipelineCompileRequiredEXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT, - eEarlyReturnOnFailure = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, - eEarlyReturnOnFailureEXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT, - eNoProtectedAccess = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, - eNoProtectedAccessEXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT, - eProtectedAccessOnly = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, - eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT, - eRayTracingNoNullAnyHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, - eRayTracingNoNullClosestHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, - eRayTracingNoNullMissShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, - eRayTracingNoNullIntersectionShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, - eRayTracingSkipTrianglesKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, - eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR, - eRayTracingShaderGroupHandleCaptureReplayKHR = VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, - eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, - eRenderingFragmentDensityMapAttachmentEXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eVkPipelineRasterizationStateCreateFragmentDensityMapAttachmentEXT = VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eRenderingFragmentShadingRateAttachmentKHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eVkPipelineRasterizationStateCreateFragmentShadingRateAttachmentKHR = VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, - eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, - eIndirectBindableNV = VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV, - eLibraryKHR = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, - eDescriptorBufferEXT = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, - eRetainLinkTimeOptimizationInfoEXT = VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, - eLinkTimeOptimizationEXT = VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT, - eRayTracingAllowMotionNV = VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV, - eColorAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, - eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, - eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, + eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, + eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, + eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, + eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR, + eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, + eFailOnPipelineCompileRequired = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + eFailOnPipelineCompileRequiredEXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT, + eEarlyReturnOnFailure = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + eEarlyReturnOnFailureEXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT, + eNoProtectedAccess = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, + eNoProtectedAccessEXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT, + eProtectedAccessOnly = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, + eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT, + eRayTracingNoNullAnyHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, + eRayTracingNoNullClosestHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, + eRayTracingNoNullMissShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, + eRayTracingNoNullIntersectionShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, + eRayTracingSkipTrianglesKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, + eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR, + eRayTracingShaderGroupHandleCaptureReplayKHR = VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, + eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, + eRenderingFragmentDensityMapAttachmentEXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + eRenderingFragmentShadingRateAttachmentKHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, + eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, + eIndirectBindableNV = VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV, + eLibraryKHR = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, + eDescriptorBufferEXT = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, + eRetainLinkTimeOptimizationInfoEXT = VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, + eLinkTimeOptimizationEXT = VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT, + eRayTracingAllowMotionNV = VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV, + eColorAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, + eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) - eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV + eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eRayTracingOpacityMicromapKHR = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR, + eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT }; // wrapper using for bitmask VkPipelineCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlags.html @@ -3537,18 +3564,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PipelineCreateFlagBits::eCaptureStatisticsKHR | PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR | PipelineCreateFlagBits::eIndirectBindableNV | PipelineCreateFlagBits::eLibraryKHR | PipelineCreateFlagBits::eDescriptorBufferEXT | PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT | PipelineCreateFlagBits::eLinkTimeOptimizationEXT | PipelineCreateFlagBits::eRayTracingAllowMotionNV | - PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT | - PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT + PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT #if defined( VK_ENABLE_BETA_EXTENSIONS ) | PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - ; + | PipelineCreateFlagBits::eRayTracingOpacityMicromapKHR; }; // wrapper class for enum VkPipelineLayoutCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlagBits.html enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags { - eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT + eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT, + eNoTaskShaderKHR = VK_PIPELINE_LAYOUT_CREATE_NO_TASK_SHADER_BIT_KHR }; // wrapper using for bitmask VkPipelineLayoutCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlags.html @@ -3559,7 +3586,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { using WrappedType = VkPipelineLayoutCreateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = + PipelineLayoutCreateFlagBits::eIndependentSetsEXT | PipelineLayoutCreateFlagBits::eNoTaskShaderKHR; }; // wrapper class for enum VkPipelineShaderStageCreateFlagBits, see @@ -4329,10 +4357,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper class for enum VkStencilFaceFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlagBits.html enum class StencilFaceFlagBits : VkStencilFaceFlags { - eFront = VK_STENCIL_FACE_FRONT_BIT, - eBack = VK_STENCIL_FACE_BACK_BIT, - eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK, - eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK + eFront = VK_STENCIL_FACE_FRONT_BIT, + eBack = VK_STENCIL_FACE_BACK_BIT, + eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK }; // wrapper using for bitmask VkStencilFaceFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlags.html @@ -5359,6 +5386,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eFragmentShadingRateAttachmentKHR = VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, eVideoEncodeInputKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, eVideoEncodeDpbKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, + eBlockMatchingSxdQCOM = VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM, eAccelerationStructureRadiusBufferNV = VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV, eLinearColorAttachmentNV = VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, eWeightImageQCOM = VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM, @@ -5409,11 +5437,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE FormatFeatureFlagBits2::eVideoDecodeOutputKHR | FormatFeatureFlagBits2::eVideoDecodeDpbKHR | FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR | FormatFeatureFlagBits2::eFragmentDensityMapEXT | FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR | FormatFeatureFlagBits2::eVideoEncodeInputKHR | FormatFeatureFlagBits2::eVideoEncodeDpbKHR | - FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV | FormatFeatureFlagBits2::eLinearColorAttachmentNV | - FormatFeatureFlagBits2::eWeightImageQCOM | FormatFeatureFlagBits2::eWeightSampledImageQCOM | FormatFeatureFlagBits2::eBlockMatchingQCOM | - FormatFeatureFlagBits2::eBoxFilterSampledQCOM | FormatFeatureFlagBits2::eTensorShaderARM | FormatFeatureFlagBits2::eTensorImageAliasingARM | - FormatFeatureFlagBits2::eOpticalFlowImageNV | FormatFeatureFlagBits2::eOpticalFlowVectorNV | FormatFeatureFlagBits2::eOpticalFlowCostNV | - FormatFeatureFlagBits2::eTensorDataGraphARM | FormatFeatureFlagBits2::eCopyImageIndirectDstKHR | + FormatFeatureFlagBits2::eBlockMatchingSxdQCOM | FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV | + FormatFeatureFlagBits2::eLinearColorAttachmentNV | FormatFeatureFlagBits2::eWeightImageQCOM | FormatFeatureFlagBits2::eWeightSampledImageQCOM | + FormatFeatureFlagBits2::eBlockMatchingQCOM | FormatFeatureFlagBits2::eBoxFilterSampledQCOM | FormatFeatureFlagBits2::eTensorShaderARM | + FormatFeatureFlagBits2::eTensorImageAliasingARM | FormatFeatureFlagBits2::eOpticalFlowImageNV | FormatFeatureFlagBits2::eOpticalFlowVectorNV | + FormatFeatureFlagBits2::eOpticalFlowCostNV | FormatFeatureFlagBits2::eTensorDataGraphARM | FormatFeatureFlagBits2::eCopyImageIndirectDstKHR | FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR | FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR | FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR | FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR | @@ -5586,6 +5614,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ eDescriptorHeapEXT = VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT, + eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, + eMicromapStorageEXT = VK_BUFFER_USAGE_2_MICROMAP_STORAGE_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, @@ -5600,8 +5630,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eSamplerDescriptorBufferEXT = VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, eResourceDescriptorBufferEXT = VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, - eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, - eMicromapStorageEXT = VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) eCompressedDataDgf1AMDX = VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -5630,13 +5658,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) | BufferUsageFlagBits2::eExecutionGraphScratchAMDX #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | 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 + | BufferUsageFlagBits2::eDescriptorHeapEXT | BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits2::eMicromapStorageEXT | + 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 #if defined( VK_ENABLE_BETA_EXTENSIONS ) | BufferUsageFlagBits2::eCompressedDataDgf1AMDX #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -5711,19 +5738,21 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eRayTracingAllowMotionNV = VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV, eRenderingFragmentShadingRateAttachmentKHR = VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, eRenderingFragmentDensityMapAttachmentEXT = VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, eColorAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT, - eDisallowOpacityMicromapARM = VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM, - eInstrumentShadersARM = VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM, - eCaptureDataKHR = VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR, - eIndirectBindableEXT = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT, - ePerLayerFragmentDensityVALVE = VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, - e64BitIndexingEXT = VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT + eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT, + eDisallowOpacityMicromapARM = VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM, + eInstrumentShadersARM = VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM, + eCaptureDataKHR = VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR, + eIndirectBindableEXT = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT, + ePerLayerFragmentDensityVALVE = VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, + eRayTracingOpacityMicromapKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR, + eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, + eOpacityMicromapDisallowMixedSpecialIndexKHR = VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR, + e64BitIndexingEXT = VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT }; using PipelineCreateFlagBits2KHR = PipelineCreateFlagBits2; @@ -5753,13 +5782,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR | PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR | PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR | PipelineCreateFlagBits2::eIndirectBindableNV | PipelineCreateFlagBits2::eRayTracingAllowMotionNV | PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR | - PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT | - PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT + PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT | + PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT #if defined( VK_ENABLE_BETA_EXTENSIONS ) | PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV #endif /*VK_ENABLE_BETA_EXTENSIONS*/ | PipelineCreateFlagBits2::eDescriptorBufferEXT | PipelineCreateFlagBits2::eDisallowOpacityMicromapARM | PipelineCreateFlagBits2::eInstrumentShadersARM | PipelineCreateFlagBits2::eCaptureDataKHR | PipelineCreateFlagBits2::eIndirectBindableEXT | PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE | + PipelineCreateFlagBits2::eRayTracingOpacityMicromapKHR | PipelineCreateFlagBits2::eOpacityMicromapDisallowMixedSpecialIndexKHR | PipelineCreateFlagBits2::e64BitIndexingEXT; }; @@ -5829,17 +5859,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper class for enum VkColorSpaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorSpaceKHR.html enum class ColorSpaceKHR { - eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR, - eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, - eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, - eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, - eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, - eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, - eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, - eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, - eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, - eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, + eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, + eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, + eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, + eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, + eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, + eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, + eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, + eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, + eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, eDolbyvisionEXT VULKAN_HPP_DEPRECATED_17( "eDolbyvisionEXT is deprecated, but no reason was given in the API XML" ) = VK_COLOR_SPACE_DOLBYVISION_EXT, eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, @@ -7006,12 +7035,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper class for enum VkPerformanceCounterScopeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterScopeKHR.html enum class PerformanceCounterScopeKHR { - eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, - eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, - eRenderPass = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, - eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR, - eCommand = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, - eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR + eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + eRenderPass = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + eCommand = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR }; // wrapper class for enum VkPerformanceCounterStorageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterStorageKHR.html @@ -7171,6 +7197,146 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCreateFlagsEXT allFlags = {}; }; + //=== VK_AMD_gpa_interface === + + // wrapper class for enum VkGpaSqShaderStageFlagBitsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaSqShaderStageFlagBitsAMD.html + enum class GpaSqShaderStageFlagBitsAMD : VkGpaSqShaderStageFlagsAMD + { + ePs = VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD, + eVs = VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD, + eGs = VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD, + eEs = VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD, + eHs = VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD, + eLs = VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD, + eCs = VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD + }; + + // wrapper using for bitmask VkGpaSqShaderStageFlagsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaSqShaderStageFlagsAMD.html + using GpaSqShaderStageFlagsAMD = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkGpaSqShaderStageFlagBitsAMD; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GpaSqShaderStageFlagsAMD allFlags = + GpaSqShaderStageFlagBitsAMD::ePs | GpaSqShaderStageFlagBitsAMD::eVs | GpaSqShaderStageFlagBitsAMD::eGs | GpaSqShaderStageFlagBitsAMD::eEs | + GpaSqShaderStageFlagBitsAMD::eHs | GpaSqShaderStageFlagBitsAMD::eLs | GpaSqShaderStageFlagBitsAMD::eCs; + }; + + // wrapper class for enum VkGpaPerfBlockAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaPerfBlockAMD.html + enum class GpaPerfBlockAMD + { + eCpf = VK_GPA_PERF_BLOCK_CPF_AMD, + eIa = VK_GPA_PERF_BLOCK_IA_AMD, + eVgt = VK_GPA_PERF_BLOCK_VGT_AMD, + ePa = VK_GPA_PERF_BLOCK_PA_AMD, + eSc = VK_GPA_PERF_BLOCK_SC_AMD, + eSpi = VK_GPA_PERF_BLOCK_SPI_AMD, + eSq = VK_GPA_PERF_BLOCK_SQ_AMD, + eSx = VK_GPA_PERF_BLOCK_SX_AMD, + eTa = VK_GPA_PERF_BLOCK_TA_AMD, + eTd = VK_GPA_PERF_BLOCK_TD_AMD, + eTcp = VK_GPA_PERF_BLOCK_TCP_AMD, + eTcc = VK_GPA_PERF_BLOCK_TCC_AMD, + eTca = VK_GPA_PERF_BLOCK_TCA_AMD, + eDb = VK_GPA_PERF_BLOCK_DB_AMD, + eCb = VK_GPA_PERF_BLOCK_CB_AMD, + eGds = VK_GPA_PERF_BLOCK_GDS_AMD, + eSrbm = VK_GPA_PERF_BLOCK_SRBM_AMD, + eGrbm = VK_GPA_PERF_BLOCK_GRBM_AMD, + eGrbmSe = VK_GPA_PERF_BLOCK_GRBM_SE_AMD, + eRlc = VK_GPA_PERF_BLOCK_RLC_AMD, + eDma = VK_GPA_PERF_BLOCK_DMA_AMD, + eMc = VK_GPA_PERF_BLOCK_MC_AMD, + eCpg = VK_GPA_PERF_BLOCK_CPG_AMD, + eCpc = VK_GPA_PERF_BLOCK_CPC_AMD, + eWd = VK_GPA_PERF_BLOCK_WD_AMD, + eTcs = VK_GPA_PERF_BLOCK_TCS_AMD, + eAtc = VK_GPA_PERF_BLOCK_ATC_AMD, + eAtcL2 = VK_GPA_PERF_BLOCK_ATC_L2_AMD, + eMcVmL2 = VK_GPA_PERF_BLOCK_MC_VM_L2_AMD, + eEa = VK_GPA_PERF_BLOCK_EA_AMD, + eRpb = VK_GPA_PERF_BLOCK_RPB_AMD, + eRmi = VK_GPA_PERF_BLOCK_RMI_AMD, + eUmcch = VK_GPA_PERF_BLOCK_UMCCH_AMD, + eGe = VK_GPA_PERF_BLOCK_GE_AMD, + eGe1 = VK_GPA_PERF_BLOCK_GE1_AMD, + eGl1A = VK_GPA_PERF_BLOCK_GL1A_AMD, + eGl1C = VK_GPA_PERF_BLOCK_GL1C_AMD, + eGl1Cg = VK_GPA_PERF_BLOCK_GL1CG_AMD, + eGl2A = VK_GPA_PERF_BLOCK_GL2A_AMD, + eGl2C = VK_GPA_PERF_BLOCK_GL2C_AMD, + eCha = VK_GPA_PERF_BLOCK_CHA_AMD, + eChc = VK_GPA_PERF_BLOCK_CHC_AMD, + eChcg = VK_GPA_PERF_BLOCK_CHCG_AMD, + eGus = VK_GPA_PERF_BLOCK_GUS_AMD, + eGcr = VK_GPA_PERF_BLOCK_GCR_AMD, + ePh = VK_GPA_PERF_BLOCK_PH_AMD, + eUtcl1 = VK_GPA_PERF_BLOCK_UTCL1_AMD, + eGeDist = VK_GPA_PERF_BLOCK_GE_DIST_AMD, + eGeSe = VK_GPA_PERF_BLOCK_GE_SE_AMD, + eDfMall = VK_GPA_PERF_BLOCK_DF_MALL_AMD, + eSqWgp = VK_GPA_PERF_BLOCK_SQ_WGP_AMD, + ePc = VK_GPA_PERF_BLOCK_PC_AMD, + eGl1Xa = VK_GPA_PERF_BLOCK_GL1XA_AMD, + eGl1Xc = VK_GPA_PERF_BLOCK_GL1XC_AMD, + eWgs = VK_GPA_PERF_BLOCK_WGS_AMD, + eEacpwd = VK_GPA_PERF_BLOCK_EACPWD_AMD, + eEase = VK_GPA_PERF_BLOCK_EASE_AMD, + eRlcuser = VK_GPA_PERF_BLOCK_RLCUSER_AMD, + eRlclocal = VK_GPA_PERF_BLOCK_RLCLOCAL_AMD + }; + + // wrapper class for enum VkGpaSampleTypeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaSampleTypeAMD.html + enum class GpaSampleTypeAMD + { + eCumulative = VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD, + eTrace = VK_GPA_SAMPLE_TYPE_TRACE_AMD, + eTiming = VK_GPA_SAMPLE_TYPE_TIMING_AMD + }; + + // wrapper class for enum VkGpaDeviceClockModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaDeviceClockModeAMD.html + enum class GpaDeviceClockModeAMD + { + eDefault = VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD, + eQuery = VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD, + eProfiling = VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD, + eMinMemory = VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD, + eMinEngine = VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD, + ePeak = VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD + }; + + enum class GpaPerfBlockPropertiesFlagBitsAMD : VkGpaPerfBlockPropertiesFlagsAMD + { + }; + + // wrapper using for bitmask VkGpaPerfBlockPropertiesFlagsAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaPerfBlockPropertiesFlagsAMD.html + using GpaPerfBlockPropertiesFlagsAMD = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GpaPerfBlockPropertiesFlagsAMD allFlags = {}; + }; + + enum class PhysicalDeviceGpaPropertiesFlagBitsAMD : VkPhysicalDeviceGpaPropertiesFlagsAMD + { + }; + + // wrapper using for bitmask VkPhysicalDeviceGpaPropertiesFlagsAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGpaPropertiesFlagsAMD.html + using PhysicalDeviceGpaPropertiesFlagsAMD = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PhysicalDeviceGpaPropertiesFlagsAMD allFlags = {}; + }; + //=== VK_EXT_descriptor_heap === // wrapper class for enum VkDescriptorMappingSourceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceEXT.html @@ -7269,11 +7435,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper class for enum VkAccelerationStructureTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTypeKHR.html enum class AccelerationStructureTypeKHR { - eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, - eTopLevelNV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, - eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, - eBottomLevelNV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV, - eGeneric = VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR + eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + eTopLevelNV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, + eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + eBottomLevelNV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV, + eGeneric = VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR, + eOpacityMicromap = VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR }; using AccelerationStructureTypeNV = AccelerationStructureTypeKHR; @@ -7323,7 +7490,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eForceOpaqueNV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV, eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, eForceNoOpaqueNV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV, + eForceOpacityMicromap2State = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR, eForceOpacityMicromap2StateEXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + eDisableOpacityMicromaps = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR, eDisableOpacityMicromapsEXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT }; @@ -7340,8 +7509,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryInstanceFlagsKHR allFlags = GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable | GeometryInstanceFlagBitsKHR::eTriangleFlipFacing | GeometryInstanceFlagBitsKHR::eForceOpaque | - GeometryInstanceFlagBitsKHR::eForceNoOpaque | GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT | - GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT; + GeometryInstanceFlagBitsKHR::eForceNoOpaque | GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2State | + GeometryInstanceFlagBitsKHR::eDisableOpacityMicromaps; }; // wrapper class for enum VkBuildAccelerationStructureFlagBitsKHR, see @@ -7359,15 +7528,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, eLowMemoryNV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV, eMotionNV = VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV, - eAllowOpacityMicromapUpdateEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, - eAllowDisableOpacityMicromapsEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, eAllowOpacityMicromapDataUpdateEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) eAllowDisplacementMicromapUpdateNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, eAllowDisplacementMicromapUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eAllowDataAccess = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, - eAllowClusterOpacityMicromapsNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV + eAllowDataAccess = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, + eAllowClusterOpacityMicromapsNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV, + eAllowOpacityMicromapUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR, + eAllowOpacityMicromapUpdateEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + eAllowDisableOpacityMicromaps = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR, + eAllowDisableOpacityMicromapsEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, + eMicromapLossy = VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR }; using BuildAccelerationStructureFlagBitsNV = BuildAccelerationStructureFlagBitsKHR; @@ -7386,12 +7558,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE BuildAccelerationStructureFlagBitsKHR::eAllowUpdate | BuildAccelerationStructureFlagBitsKHR::eAllowCompaction | BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace | BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild | BuildAccelerationStructureFlagBitsKHR::eLowMemory | BuildAccelerationStructureFlagBitsKHR::eMotionNV | - BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT | BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT | BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT #if defined( VK_ENABLE_BETA_EXTENSIONS ) | BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess | BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV; + | BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess | BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV | + BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdate | BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromaps | + BuildAccelerationStructureFlagBitsKHR::eMicromapLossy; }; // wrapper class for enum VkCopyAccelerationStructureModeKHR, see @@ -7419,8 +7592,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eSpheresNV = VK_GEOMETRY_TYPE_SPHERES_NV, eLinearSweptSpheresNV = VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV, #if defined( VK_ENABLE_BETA_EXTENSIONS ) - eDenseGeometryFormatTrianglesAMDX = VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX + eDenseGeometryFormatTrianglesAMDX = VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eMicromap = VK_GEOMETRY_TYPE_MICROMAP_KHR }; using GeometryTypeNV = GeometryTypeKHR; @@ -8680,24 +8854,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eBuild = VK_BUILD_MICROMAP_MODE_BUILD_EXT }; - // wrapper class for enum VkOpacityMicromapFormatEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapFormatEXT.html - enum class OpacityMicromapFormatEXT - { - e2State = VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT, - e4State = VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT - }; - - // wrapper class for enum VkOpacityMicromapSpecialIndexEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapSpecialIndexEXT.html - enum class OpacityMicromapSpecialIndexEXT - { - eFullyTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT, - eFullyOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT, - eFullyUnknownTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT, - eFullyUnknownOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT, - eClusterGeometryDisableOpacityMicromapNV = VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV - }; - #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_displacement_micromap === @@ -8999,17 +9155,19 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper class for enum VkShaderCreateFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagBitsEXT.html enum class ShaderCreateFlagBitsEXT : VkShaderCreateFlagsEXT { - eLinkStage = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, - eDescriptorHeap = VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT, - eInstrumentShaderARM = VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM, - 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, - eDispatchBase = VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT, - eFragmentShadingRateAttachment = VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT, - eFragmentDensityMapAttachment = VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eIndirectBindable = VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT, - e64BitIndexing = VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT + eLinkStage = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, + eDescriptorHeap = VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT, + eInstrumentShaderARM = VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM, + 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, + eDispatchBase = VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT, + eFragmentShadingRateAttachment = VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT, + eFragmentDensityMapAttachment = VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + eIndirectBindable = VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT, + eOpacityMicromapDisallowMixedSpecialIndex = VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT, + e64BitIndexing = VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT, + eIndependentSetsKHR = VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR }; // wrapper using for bitmask VkShaderCreateFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagsEXT.html @@ -9024,7 +9182,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ShaderCreateFlagBitsEXT::eLinkStage | ShaderCreateFlagBitsEXT::eDescriptorHeap | ShaderCreateFlagBitsEXT::eInstrumentShaderARM | ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize | ShaderCreateFlagBitsEXT::eRequireFullSubgroups | ShaderCreateFlagBitsEXT::eNoTaskShader | ShaderCreateFlagBitsEXT::eDispatchBase | ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment | - ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment | ShaderCreateFlagBitsEXT::eIndirectBindable | ShaderCreateFlagBitsEXT::e64BitIndexing; + ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment | ShaderCreateFlagBitsEXT::eIndirectBindable | + ShaderCreateFlagBitsEXT::eOpacityMicromapDisallowMixedSpecialIndex | ShaderCreateFlagBitsEXT::e64BitIndexing | + ShaderCreateFlagBitsEXT::eIndependentSetsKHR; }; // wrapper class for enum VkShaderCodeTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCodeTypeEXT.html @@ -9271,8 +9431,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointARM.html enum class DataGraphPipelineSessionBindPointARM { - eTransient = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM, - eOpticalFlowCache = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM + eTransient = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM, + eOpticalFlowCache = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM, + eNeuralAcceleratorStatistics = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_NEURAL_ACCELERATOR_STATISTICS_ARM }; // wrapper class for enum VkDataGraphPipelineSessionBindPointTypeARM, see @@ -9306,8 +9467,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper class for enum VkDataGraphPipelinePropertyARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyARM.html enum class DataGraphPipelinePropertyARM { - eCreationLog = VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM, - eIdentifier = VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM + eCreationLog = VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM, + eIdentifier = VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM, + eNeuralAcceleratorDebugDatabase = VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_DEBUG_DATABASE_ARM, + eNeuralAcceleratorStatisticsInfo = VK_DATA_GRAPH_PIPELINE_PROPERTY_NEURAL_ACCELERATOR_STATISTICS_INFO_ARM }; enum class DataGraphPipelineDispatchFlagBitsARM : VkDataGraphPipelineDispatchFlagsARM @@ -10041,6 +10204,43 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderInstrumentationValuesFlagsARM allFlags = {}; }; + //=== VK_KHR_opacity_micromap === + + // wrapper class for enum VkOpacityMicromapFormatKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapFormatKHR.html + enum class OpacityMicromapFormatKHR + { + e2State = VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR, + e2StateEXT = VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT, + e4State = VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR, + e4StateEXT = VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT + }; + + using OpacityMicromapFormatEXT = OpacityMicromapFormatKHR; + + // wrapper class for enum VkOpacityMicromapSpecialIndexKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapSpecialIndexKHR.html + enum class OpacityMicromapSpecialIndexKHR + { + eFullyTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR, + eFullyTransparentEXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT, + eFullyOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR, + eFullyOpaqueEXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT, + eFullyUnknownTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR, + eFullyUnknownTransparentEXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT, + eFullyUnknownOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR, + eFullyUnknownOpaqueEXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT, + eClusterGeometryDisableOpacityMicromapNV = VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV + }; + + using OpacityMicromapSpecialIndexEXT = OpacityMicromapSpecialIndexKHR; + + // wrapper class for enum VkAccelerationStructureSerializedBlockTypeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureSerializedBlockTypeKHR.html + enum class AccelerationStructureSerializedBlockTypeKHR + { + eOpacityMicromap = VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR + }; + //=== VK_QCOM_data_graph_model === // wrapper class for enum VkDataGraphModelCacheTypeQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphModelCacheTypeQCOM.html @@ -10238,6 +10438,27 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_USE_PLATFORM_UBM_SEC*/ + //=== VK_SEC_throttle_hint === + + // wrapper class for enum VkThrottleHintTypeSEC, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkThrottleHintTypeSEC.html + enum class ThrottleHintTypeSEC + { + eDefault = VK_THROTTLE_HINT_TYPE_DEFAULT_SEC, + eLow = VK_THROTTLE_HINT_TYPE_LOW_SEC, + eHigh = VK_THROTTLE_HINT_TYPE_HIGH_SEC + }; + + //=== VK_ARM_data_graph_neural_accelerator_statistics === + + // wrapper class for enum VkNeuralAcceleratorStatisticsModeARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkNeuralAcceleratorStatisticsModeARM.html + enum class NeuralAcceleratorStatisticsModeARM + { + eDisabled = VK_NEURAL_ACCELERATOR_STATISTICS_MODE_DISABLED_ARM, + eStatistics0 = VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS0_ARM, + eStatistics1 = VK_NEURAL_ACCELERATOR_STATISTICS_MODE_STATISTICS1_ARM + }; + //=========================================================== //=== Mapping from ObjectType to DebugReportObjectTypeEXT === //=========================================================== @@ -10314,6 +10535,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case ObjectType::eDebugUtilsMessengerEXT: return DebugReportObjectTypeEXT::eUnknown; + //=== VK_AMD_gpa_interface === + case ObjectType::eGpaSessionAMD: + return DebugReportObjectTypeEXT::eUnknown; + //=== VK_EXT_descriptor_heap === case ObjectType::eTensorARM: return DebugReportObjectTypeEXT::eUnknown; diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 97973e2..791d1af 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -179,6 +179,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_EXT_sampler_filter_minmax", "VK_KHR_storage_buffer_storage_class", "VK_AMD_gpu_shader_int16", + "VK_AMD_gpa_interface", #if defined( VK_ENABLE_BETA_EXTENSIONS ) "VK_AMDX_shader_enqueue", #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -218,6 +219,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_EXT_filter_cubic", "VK_QCOM_render_pass_shader_resolve", "VK_QCOM_cooperative_matrix_conversion", + "VK_QCOM_elapsed_timer_query", "VK_EXT_global_priority", "VK_KHR_shader_subgroup_extended_types", "VK_KHR_8bit_storage", @@ -321,6 +323,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_NV_device_diagnostics_config", "VK_QCOM_render_pass_store_ops", "VK_QCOM_queue_perf_hint", + "VK_QCOM_image_processing3", + "VK_QCOM_shader_multiple_wait_queues", + "VK_EXT_shader_split_barrier", #if defined( VK_ENABLE_BETA_EXTENSIONS ) "VK_NV_cuda_kernel_launch", #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -523,6 +528,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_EXT_fragment_density_map_offset", "VK_EXT_zero_initialize_device_memory", "VK_KHR_present_mode_fifo_latest_ready", + "VK_KHR_opacity_micromap", "VK_EXT_shader_64bit_indexing", "VK_EXT_custom_resolve", "VK_QCOM_data_graph_model", @@ -532,8 +538,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_SEC_pipeline_cache_incremental_mode", "VK_EXT_shader_uniform_buffer_unsized_array", "VK_NV_compute_occupancy_priority", + "VK_KHR_maintenance11", "VK_EXT_shader_subgroup_partitioned", "VK_VALVE_shader_mixed_float_dot_product", + "VK_SEC_throttle_hint", + "VK_ARM_data_graph_neural_accelerator_statistics", "VK_EXT_primitive_restart_index" }; return deviceExtensions; } @@ -1105,6 +1114,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ , { "VK_EXT_sampler_filter_minmax", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_AMD_gpa_interface", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", @@ -1264,6 +1279,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { { "VK_KHR_cooperative_matrix", } } } } }, + { "VK_QCOM_elapsed_timer_query", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, { "VK_KHR_shader_subgroup_extended_types", { { "VK_VERSION_1_1", { {} } } } }, { "VK_KHR_8bit_storage", { { "VK_VERSION_1_0", @@ -1503,6 +1524,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_constant_data", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, { "VK_KHR_dynamic_rendering_local_read", { { "VK_VERSION_1_0", { { @@ -1513,7 +1540,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { { "VK_VERSION_1_0", { { "VK_KHR_device_fault", - "VK_KHR_get_physical_device_properties2", "VK_KHR_shader_constant_data", } } } } }, { "VK_EXT_shader_image_atomic_int64", @@ -1850,6 +1876,24 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } }, { "VK_VERSION_1_1", { {} } } } }, { "VK_QCOM_queue_perf_hint", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_image_processing3", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_shader_multiple_wait_queues", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_split_barrier", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", @@ -2921,7 +2965,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", - } } } } }, + } } }, + { "VK_VERSION_1_1", { {} } } } }, { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } }, { "VK_MESA_image_alignment_control", { { "VK_VERSION_1_0", @@ -3084,6 +3129,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { { "VK_KHR_swapchain", } } } } }, + { "VK_KHR_opacity_micromap", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_device_address_commands", + } } } } }, { "VK_EXT_shader_64bit_indexing", { { "VK_VERSION_1_0", { { @@ -3131,6 +3182,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_maintenance11", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, { "VK_EXT_shader_subgroup_partitioned", { { "VK_VERSION_1_0", { { @@ -3307,6 +3364,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { "VK_EXT_present_mode_fifo_latest_ready", "VK_KHR_present_mode_fifo_latest_ready" }, { "VK_EXT_extended_dynamic_state2", "VK_VERSION_1_3" }, { "VK_EXT_global_priority_query", "VK_KHR_global_priority" }, + { "VK_EXT_opacity_micromap", "VK_KHR_opacity_micromap" }, { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" }, { "VK_KHR_maintenance4", "VK_VERSION_1_3" }, { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" }, @@ -3814,6 +3872,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { return "VK_KHR_global_priority"; } + if ( extension == "VK_EXT_opacity_micromap" ) + { + return "VK_KHR_opacity_micromap"; + } if ( extension == "VK_EXT_load_store_op_none" ) { return "VK_KHR_load_store_op_none"; @@ -3964,7 +4026,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE || ( extension == "VK_ANDROID_external_memory_android_hardware_buffer" ) #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ || ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) || - ( extension == "VK_AMD_gpu_shader_int16" ) + ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_AMD_gpa_interface" ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) || ( extension == "VK_AMDX_shader_enqueue" ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -3984,7 +4046,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE || ( 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_QCOM_cooperative_matrix_conversion" ) || - ( extension == "VK_EXT_global_priority" ) || ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) || + ( extension == "VK_QCOM_elapsed_timer_query" ) || ( 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" ) || @@ -4029,7 +4092,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( extension == "VK_KHR_pipeline_library" ) || ( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_KHR_present_id" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_video_encode_queue" ) || ( extension == "VK_NV_device_diagnostics_config" ) || - ( extension == "VK_QCOM_render_pass_store_ops" ) || ( extension == "VK_QCOM_queue_perf_hint" ) + ( extension == "VK_QCOM_render_pass_store_ops" ) || ( extension == "VK_QCOM_queue_perf_hint" ) || ( extension == "VK_QCOM_image_processing3" ) || + ( extension == "VK_QCOM_shader_multiple_wait_queues" ) || ( extension == "VK_EXT_shader_split_barrier" ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) || ( extension == "VK_NV_cuda_kernel_launch" ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -4134,12 +4198,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( extension == "VK_ARM_shader_instrumentation" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_ARM_format_pack" ) || ( extension == "VK_VALVE_fragment_density_map_layered" ) || ( extension == "VK_KHR_robustness2" ) || ( extension == "VK_NV_present_metering" ) || ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) || - ( 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_ARM_data_graph_optical_flow" ) || ( extension == "VK_EXT_shader_long_vector" ) || + ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_KHR_opacity_micromap" ) || + ( extension == "VK_EXT_shader_64bit_indexing" ) || ( extension == "VK_EXT_custom_resolve" ) || ( extension == "VK_QCOM_data_graph_model" ) || + ( extension == "VK_KHR_maintenance10" ) || ( extension == "VK_ARM_data_graph_optical_flow" ) || ( 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_subgroup_partitioned" ) || - ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) || ( extension == "VK_EXT_primitive_restart_index" ); + ( extension == "VK_NV_compute_occupancy_priority" ) || ( extension == "VK_KHR_maintenance11" ) || + ( extension == "VK_EXT_shader_subgroup_partitioned" ) || ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) || + ( extension == "VK_SEC_throttle_hint" ) || ( extension == "VK_ARM_data_graph_neural_accelerator_statistics" ) || + ( extension == "VK_EXT_primitive_restart_index" ); } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) @@ -4259,8 +4325,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_device_fault" ) || ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) || ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) || - ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) || - ( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) || + ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_opacity_micromap" ) || ( extension == "VK_EXT_load_store_op_none" ) || + ( extension == "VK_KHR_maintenance4" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index 8a32c11..bb6a499 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -5336,6 +5336,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE d.vkCmdSetBlendConstants( static_cast( m_commandBuffer ), blendConstants ); } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( std::array const & blendConstants, 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.vkCmdSetBlendConstants && "Function requires " ); +# endif + + d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants.data() ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html template ::type> VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT @@ -16322,6 +16336,396 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createGpaSessionAMD( + GpaSessionCreateInfoAMD const * pCreateInfo, AllocationCallbacks const * pAllocator, GpaSessionAMD * pGpaSession, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateGpaSessionAMD( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pGpaSession ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createGpaSessionAMD( + GpaSessionCreateInfoAMD const & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGpaSessionAMD && "Function requires " ); +# endif + + GpaSessionAMD gpaSession; + Result result = static_cast( d.vkCreateGpaSessionAMD( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &gpaSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGpaSessionAMD" ); + + return detail::createResultValueType( result, std::move( gpaSession ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createGpaSessionAMDUnique( + GpaSessionCreateInfoAMD const & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGpaSessionAMD && "Function requires " ); +# endif + + GpaSessionAMD gpaSession; + Result result = static_cast( d.vkCreateGpaSessionAMD( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &gpaSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGpaSessionAMDUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( gpaSession, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyGpaSessionAMD( GpaSessionAMD gpaSession, AllocationCallbacks const * pAllocator, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyGpaSessionAMD( + static_cast( m_device ), static_cast( gpaSession ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyGpaSessionAMD( GpaSessionAMD gpaSession, Optional allocator, 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.vkDestroyGpaSessionAMD && "Function requires " ); +# endif + + d.vkDestroyGpaSessionAMD( m_device, static_cast( gpaSession ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( GpaSessionAMD gpaSession, AllocationCallbacks const * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyGpaSessionAMD( + static_cast( m_device ), static_cast( gpaSession ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( GpaSessionAMD gpaSession, Optional allocator, 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.vkDestroyGpaSessionAMD && "Function requires " ); +# endif + + d.vkDestroyGpaSessionAMD( m_device, static_cast( gpaSession ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetGpaDeviceClockModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetGpaDeviceClockModeAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setGpaClockModeAMD( GpaDeviceClockModeInfoAMD * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkSetGpaDeviceClockModeAMD( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetGpaDeviceClockModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetGpaDeviceClockModeAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::setGpaClockModeAMD( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetGpaDeviceClockModeAMD && "Function requires " ); +# endif + + GpaDeviceClockModeInfoAMD info; + Result result = static_cast( d.vkSetGpaDeviceClockModeAMD( m_device, reinterpret_cast( &info ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setGpaClockModeAMD" ); + + return detail::createResultValueType( result, std::move( info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetGpaDeviceClockInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaDeviceClockInfoAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGpaClockInfoAMD( GpaDeviceGetClockInfoAMD * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetGpaDeviceClockInfoAMD( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGpaDeviceClockInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaDeviceClockInfoAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getGpaClockInfoAMD( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGpaDeviceClockInfoAMD && "Function requires " ); +# endif + + GpaDeviceGetClockInfoAMD info; + Result result = static_cast( d.vkGetGpaDeviceClockInfoAMD( m_device, reinterpret_cast( &info ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGpaClockInfoAMD" ); + + return detail::createResultValueType( result, std::move( info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::beginGpaSessionAMD( GpaSessionAMD gpaSession, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCmdBeginGpaSessionAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ) ) ); + } +#else + // wrapper function for command vkCmdBeginGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::beginGpaSessionAMD( GpaSessionAMD gpaSession, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginGpaSessionAMD && "Function requires " ); +# endif + + Result result = static_cast( d.vkCmdBeginGpaSessionAMD( m_commandBuffer, static_cast( gpaSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginGpaSessionAMD" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::endGpaSessionAMD( GpaSessionAMD gpaSession, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCmdEndGpaSessionAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ) ) ); + } +#else + // wrapper function for command vkCmdEndGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::endGpaSessionAMD( GpaSessionAMD gpaSession, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndGpaSessionAMD && "Function requires " ); +# endif + + Result result = static_cast( d.vkCmdEndGpaSessionAMD( m_commandBuffer, static_cast( gpaSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endGpaSessionAMD" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCmdBeginGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSampleAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::beginGpaSampleAMD( + GpaSessionAMD gpaSession, GpaSampleBeginInfoAMD const * pGpaSampleBeginInfo, uint32_t * pSampleID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCmdBeginGpaSampleAMD( static_cast( m_commandBuffer ), + static_cast( gpaSession ), + reinterpret_cast( pGpaSampleBeginInfo ), + pSampleID ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSampleAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::beginGpaSampleAMD( + GpaSessionAMD gpaSession, GpaSampleBeginInfoAMD const & gpaSampleBeginInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginGpaSampleAMD && "Function requires " ); +# endif + + uint32_t sampleID; + Result result = static_cast( d.vkCmdBeginGpaSampleAMD( + m_commandBuffer, static_cast( gpaSession ), reinterpret_cast( &gpaSampleBeginInfo ), &sampleID ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginGpaSampleAMD" ); + + return detail::createResultValueType( result, std::move( sampleID ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSampleAMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endGpaSampleAMD( GpaSessionAMD gpaSession, uint32_t sampleID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndGpaSampleAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ), sampleID ); + } + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGpaSessionStatusAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionStatusAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGpaSessionStatusAMD( GpaSessionAMD gpaSession, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetGpaSessionStatusAMD( static_cast( m_device ), static_cast( gpaSession ) ) ); + } +#else + // wrapper function for command vkGetGpaSessionStatusAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionStatusAMD.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::getGpaSessionStatusAMD( GpaSessionAMD gpaSession, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGpaSessionStatusAMD && "Function requires " ); +# endif + + Result result = static_cast( d.vkGetGpaSessionStatusAMD( m_device, static_cast( gpaSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGpaSessionStatusAMD" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGpaSessionResultsAMD( + GpaSessionAMD gpaSession, uint32_t sampleID, size_t * pSizeInBytes, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetGpaSessionResultsAMD( static_cast( m_device ), static_cast( gpaSession ), sampleID, pSizeInBytes, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::getGpaSessionResultsAMD( + GpaSessionAMD gpaSession, uint32_t sampleID, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGpaSessionResultsAMD && "Function requires " ); +# endif + + std::vector data; + size_t sizeInBytes; + Result result = static_cast( d.vkGetGpaSessionResultsAMD( m_device, static_cast( gpaSession ), sampleID, &sizeInBytes, nullptr ) ); + if ( result == Result::eSuccess ) + { + data.resize( sizeInBytes ); + result = static_cast( + d.vkGetGpaSessionResultsAMD( m_device, static_cast( gpaSession ), sampleID, &sizeInBytes, reinterpret_cast( data.data() ) ) ); + } + + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGpaSessionResultsAMD" ); + VULKAN_HPP_ASSERT( sizeInBytes <= data.size() ); + if ( sizeInBytes < data.size() ) + { + data.resize( sizeInBytes ); + } + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::getGpaSessionResultsAMD( + GpaSessionAMD gpaSession, uint32_t sampleID, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGpaSessionResultsAMD && "Function requires " ); +# endif + + std::vector data( uint8_tAllocator ); + size_t sizeInBytes; + Result result = static_cast( d.vkGetGpaSessionResultsAMD( m_device, static_cast( gpaSession ), sampleID, &sizeInBytes, nullptr ) ); + if ( result == Result::eSuccess ) + { + data.resize( sizeInBytes ); + result = static_cast( + d.vkGetGpaSessionResultsAMD( m_device, static_cast( gpaSession ), sampleID, &sizeInBytes, reinterpret_cast( data.data() ) ) ); + } + + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGpaSessionResultsAMD" ); + VULKAN_HPP_ASSERT( sizeInBytes <= data.size() ); + if ( sizeInBytes < data.size() ) + { + data.resize( sizeInBytes ); + } + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetGpaSessionAMD( GpaSessionAMD gpaSession, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkResetGpaSessionAMD( static_cast( m_device ), static_cast( gpaSession ) ) ); + } +#else + // wrapper function for command vkResetGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetGpaSessionAMD.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::resetGpaSessionAMD( GpaSessionAMD gpaSession, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkResetGpaSessionAMD && "Function requires " ); +# endif + + Result result = static_cast( d.vkResetGpaSessionAMD( m_device, static_cast( gpaSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetGpaSessionAMD" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCmdCopyGpaSessionResultsAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyGpaSessionResultsAMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyGpaSessionResultsAMD( GpaSessionAMD gpaSession, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyGpaSessionResultsAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ) ); + } + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === @@ -20943,15 +21347,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html template ::type> VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( - Extent2D const & fragmentSize, FragmentShadingRateCombinerOpKHR const combinerOps[2], Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + Extent2D const & fragmentSize, std::array const & combinerOps, 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.vkCmdSetFragmentShadingRateKHR && "Function requires " ); # endif - d.vkCmdSetFragmentShadingRateKHR( - m_commandBuffer, reinterpret_cast( &fragmentSize ), reinterpret_cast( combinerOps ) ); + d.vkCmdSetFragmentShadingRateKHR( m_commandBuffer, + reinterpret_cast( &fragmentSize ), + reinterpret_cast( combinerOps.data() ) ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -24939,6 +25344,24 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE reinterpret_cast( combinerOps ) ); } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( + FragmentShadingRateNV shadingRate, std::array const & combinerOps, 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.vkCmdSetFragmentShadingRateEnumNV && "Function requires " ); +# endif + + d.vkCmdSetFragmentShadingRateEnumNV( m_commandBuffer, + static_cast( shadingRate ), + reinterpret_cast( combinerOps.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_EXT_mesh_shader === // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index e978161..a6f812a 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -932,6 +932,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct AndroidHardwareBufferFormatProperties2ANDROID; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + struct GpaPerfBlockPropertiesAMD; + struct PhysicalDeviceGpaFeaturesAMD; + struct PhysicalDeviceGpaPropertiesAMD; + struct PhysicalDeviceGpaProperties2AMD; + struct GpaPerfCounterAMD; + struct GpaSampleBeginInfoAMD; + struct GpaDeviceClockModeInfoAMD; + struct GpaDeviceGetClockInfoAMD; + struct GpaSessionCreateInfoAMD; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === struct PhysicalDeviceShaderEnqueueFeaturesAMDX; @@ -1098,6 +1109,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_QCOM_cooperative_matrix_conversion === struct PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM; + //=== VK_QCOM_elapsed_timer_query === + struct PhysicalDeviceElapsedTimerQueryFeaturesQCOM; + //=== VK_EXT_external_memory_host === struct ImportMemoryHostPointerInfoEXT; struct MemoryHostPointerPropertiesEXT; @@ -1384,6 +1398,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceQueuePerfHintFeaturesQCOM; struct PhysicalDeviceQueuePerfHintPropertiesQCOM; + //=== VK_QCOM_image_processing3 === + struct PhysicalDeviceImageProcessing3FeaturesQCOM; + + //=== VK_QCOM_shader_multiple_wait_queues === + struct PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + struct PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + + //=== VK_EXT_shader_split_barrier === + struct PhysicalDeviceShaderSplitBarrierFeaturesEXT; + struct PhysicalDeviceShaderSplitBarrierPropertiesEXT; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_cuda_kernel_launch === struct CudaModuleCreateInfoNV; @@ -1658,7 +1683,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct CopyMicromapInfoEXT; struct MicromapBuildSizesInfoEXT; struct AccelerationStructureTrianglesOpacityMicromapEXT; - struct MicromapTriangleEXT; #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_displacement_micromap === @@ -2348,6 +2372,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + //=== VK_KHR_opacity_micromap === + struct AccelerationStructureGeometryMicromapDataKHR; + struct MicromapUsageKHR; + struct PhysicalDeviceOpacityMicromapFeaturesKHR; + struct PhysicalDeviceOpacityMicromapPropertiesKHR; + struct MicromapTriangleKHR; + using MicromapTriangleEXT = MicromapTriangleKHR; + struct AccelerationStructureTrianglesOpacityMicromapKHR; + //=== VK_EXT_shader_64bit_indexing === struct PhysicalDeviceShader64BitIndexingFeaturesEXT; @@ -2394,6 +2427,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct ComputeOccupancyPriorityParametersNV; struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV; + //=== VK_KHR_maintenance11 === + struct PhysicalDeviceMaintenance11FeaturesKHR; + struct QueueFamilyOptimalImageTransferGranularityPropertiesKHR; + //=== VK_EXT_shader_subgroup_partitioned === struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; @@ -2405,6 +2442,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_VALVE_shader_mixed_float_dot_product === struct PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE; + //=== VK_SEC_throttle_hint === + struct ThrottleHintSubmitInfoSEC; + struct PhysicalDeviceThrottleHintFeaturesSEC; + + //=== VK_ARM_data_graph_neural_accelerator_statistics === + struct PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + struct DataGraphPipelineNeuralStatisticsCreateInfoARM; + struct DataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + //=== VK_EXT_primitive_restart_index === struct PhysicalDevicePrimitiveRestartIndexFeaturesEXT; @@ -2470,6 +2516,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_debug_utils === class DebugUtilsMessengerEXT; + //=== VK_AMD_gpa_interface === + class GpaSessionAMD; + //=== VK_EXT_descriptor_heap === class TensorARM; @@ -2893,6 +2942,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using UniqueDebugUtilsMessengerEXT = UniqueHandle; + //=== VK_AMD_gpa_interface === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueGpaSessionAMD = UniqueHandle; + //=== VK_EXT_descriptor_heap === template class UniqueHandleTraits @@ -3843,6 +3902,92 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; + // wrapper class for handle VkGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaSessionAMD.html + class GpaSessionAMD + { + public: + using CType = VkGpaSessionAMD; + using NativeType = VkGpaSessionAMD; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eGpaSessionAMD; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + GpaSessionAMD() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + GpaSessionAMD( GpaSessionAMD const & rhs ) = default; + GpaSessionAMD & operator=( GpaSessionAMD const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + GpaSessionAMD( GpaSessionAMD && rhs ) = default; + GpaSessionAMD & operator=( GpaSessionAMD && rhs ) = default; +#else + GpaSessionAMD( GpaSessionAMD && rhs ) VULKAN_HPP_NOEXCEPT : m_gpaSessionAMD( exchange( rhs.m_gpaSessionAMD, {} ) ) {} + + GpaSessionAMD & operator=( GpaSessionAMD && rhs ) VULKAN_HPP_NOEXCEPT + { + m_gpaSessionAMD = exchange( rhs.m_gpaSessionAMD, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR GpaSessionAMD( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT GpaSessionAMD( VkGpaSessionAMD gpaSessionAMD ) VULKAN_HPP_NOEXCEPT : m_gpaSessionAMD( gpaSessionAMD ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + GpaSessionAMD & operator=( VkGpaSessionAMD gpaSessionAMD ) VULKAN_HPP_NOEXCEPT + { + m_gpaSessionAMD = gpaSessionAMD; + return *this; + } +#endif + + GpaSessionAMD & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_gpaSessionAMD = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkGpaSessionAMD() const VULKAN_HPP_NOEXCEPT + { + return m_gpaSessionAMD; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_gpaSessionAMD != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_gpaSessionAMD == VK_NULL_HANDLE; + } + + private: + VkGpaSessionAMD m_gpaSessionAMD = {}; + }; + + template <> + struct CppType + { + using Type = GpaSessionAMD; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = GpaSessionAMD; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html class QueryPool { @@ -5716,6 +5861,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html template ::type = true> void setBlendConstants( float const blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html + template ::type = true> + void setBlendConstants( std::array const & blendConstants, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html template ::type = true> @@ -6721,6 +6872,56 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_AMD_gpa_interface === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result beginGpaSessionAMD( GpaSessionAMD gpaSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkCmdBeginGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + beginGpaSessionAMD( GpaSessionAMD gpaSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result endGpaSessionAMD( GpaSessionAMD gpaSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkCmdEndGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + endGpaSessionAMD( GpaSessionAMD gpaSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCmdBeginGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSampleAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result beginGpaSampleAMD( GpaSessionAMD gpaSession, + GpaSampleBeginInfoAMD const * pGpaSampleBeginInfo, + uint32_t * pSampleID, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSampleAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type beginGpaSampleAMD( GpaSessionAMD gpaSession, + GpaSampleBeginInfoAMD const & gpaSampleBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSampleAMD.html + template ::type = true> + void endGpaSampleAMD( GpaSessionAMD gpaSession, uint32_t sampleID, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyGpaSessionResultsAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyGpaSessionResultsAMD.html + template ::type = true> + void copyGpaSessionResultsAMD( GpaSessionAMD gpaSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === @@ -7276,9 +7477,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html template ::type = true> - void setFragmentShadingRateKHR( Extent2D const & fragmentSize, - FragmentShadingRateCombinerOpKHR const combinerOps[2], - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + void setFragmentShadingRateKHR( Extent2D const & fragmentSize, + std::array const & combinerOps, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ //=== VK_KHR_dynamic_rendering_local_read === @@ -7940,6 +8141,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, FragmentShadingRateCombinerOpKHR const combinerOps[2], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html + template ::type = true> + void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, + std::array const & combinerOps, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ //=== VK_EXT_mesh_shader === @@ -15446,6 +15656,130 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createGpaSessionAMD( GpaSessionCreateInfoAMD const * pCreateInfo, + AllocationCallbacks const * pAllocator, + GpaSessionAMD * pGpaSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createGpaSessionAMD( GpaSessionCreateInfoAMD const & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createGpaSessionAMDUnique( GpaSessionCreateInfoAMD const & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type = true> + void destroyGpaSessionAMD( GpaSessionAMD gpaSession, + AllocationCallbacks const * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type = true> + void destroyGpaSessionAMD( GpaSessionAMD gpaSession VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type = true> + void destroy( GpaSessionAMD gpaSession, + AllocationCallbacks const * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyGpaSessionAMD.html + template ::type = true> + void destroy( GpaSessionAMD gpaSession, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetGpaDeviceClockModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetGpaDeviceClockModeAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setGpaClockModeAMD( GpaDeviceClockModeInfoAMD * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetGpaDeviceClockModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetGpaDeviceClockModeAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + setGpaClockModeAMD( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetGpaDeviceClockInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaDeviceClockInfoAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getGpaClockInfoAMD( GpaDeviceGetClockInfoAMD * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGpaDeviceClockInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaDeviceClockInfoAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getGpaClockInfoAMD( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGpaSessionStatusAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionStatusAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getGpaSessionStatusAMD( GpaSessionAMD gpaSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkGetGpaSessionStatusAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionStatusAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getGpaSessionStatusAMD( GpaSessionAMD gpaSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getGpaSessionResultsAMD( GpaSessionAMD gpaSession, + uint32_t sampleID, + size_t * pSizeInBytes, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getGpaSessionResultsAMD( GpaSessionAMD gpaSession, uint32_t sampleID, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getGpaSessionResultsAMD( GpaSessionAMD gpaSession, + uint32_t sampleID, + Uint8_tAllocator const & uint8_tAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result resetGpaSessionAMD( GpaSessionAMD gpaSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkResetGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetGpaSessionAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + resetGpaSessionAMD( GpaSessionAMD gpaSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 892c415..6218966 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -393,6 +393,17 @@ VULKAN_HPP_EXPORT namespace std } }; + //=== VK_AMD_gpa_interface === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GpaSessionAMD const & gpaSessionAMD ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( gpaSessionAMD ) ); + } + }; + //=== VK_EXT_descriptor_heap === template <> @@ -842,6 +853,38 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageKHR const & micromapUsageKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, micromapUsageKHR.count ); + VULKAN_HPP_HASH_COMBINE( seed, micromapUsageKHR.subdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, micromapUsageKHR.format ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMicromapDataKHR const & accelerationStructureGeometryMicromapDataKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.usageCountsCount ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.pUsageCounts ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.ppUsageCounts ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.data ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.triangleArray ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureGeometryMicromapDataKHR.triangleArrayStride ); + return seed; + } + }; + template <> struct hash { @@ -979,6 +1022,24 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapKHR const & accelerationStructureTrianglesOpacityMicromapKHR ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureTrianglesOpacityMicromapKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureTrianglesOpacityMicromapKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureTrianglesOpacityMicromapKHR.indexType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureTrianglesOpacityMicromapKHR.indexBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureTrianglesOpacityMicromapKHR.indexStride ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureTrianglesOpacityMicromapKHR.baseTriangle ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureTrianglesOpacityMicromapKHR.micromap ); + return seed; + } + }; + template <> struct hash { @@ -3860,6 +3921,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineNeuralStatisticsCreateInfoARM const & dataGraphPipelineNeuralStatisticsCreateInfoARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineNeuralStatisticsCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineNeuralStatisticsCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineNeuralStatisticsCreateInfoARM.allowNeuralStatistics ); + return seed; + } + }; + template <> struct hash { @@ -3989,6 +4064,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & + dataGraphPipelineSessionNeuralStatisticsCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionNeuralStatisticsCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionNeuralStatisticsCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionNeuralStatisticsCreateInfoARM.mode ); + return seed; + } + }; + template <> struct hash { @@ -7034,6 +7123,106 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GpaDeviceClockModeInfoAMD const & gpaDeviceClockModeInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceClockModeInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceClockModeInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceClockModeInfoAMD.clockMode ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceClockModeInfoAMD.memoryClockRatioToPeak ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceClockModeInfoAMD.engineClockRatioToPeak ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GpaDeviceGetClockInfoAMD const & gpaDeviceGetClockInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceGetClockInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceGetClockInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceGetClockInfoAMD.memoryClockRatioToPeak ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceGetClockInfoAMD.engineClockRatioToPeak ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceGetClockInfoAMD.memoryClockFrequency ); + VULKAN_HPP_HASH_COMBINE( seed, gpaDeviceGetClockInfoAMD.engineClockFrequency ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GpaPerfBlockPropertiesAMD const & gpaPerfBlockPropertiesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfBlockPropertiesAMD.blockType ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfBlockPropertiesAMD.flags ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfBlockPropertiesAMD.instanceCount ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfBlockPropertiesAMD.maxEventID ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfBlockPropertiesAMD.maxGlobalOnlyCounters ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfBlockPropertiesAMD.maxGlobalSharedCounters ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfBlockPropertiesAMD.maxStreamingCounters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GpaPerfCounterAMD const & gpaPerfCounterAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfCounterAMD.blockType ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfCounterAMD.blockInstance ); + VULKAN_HPP_HASH_COMBINE( seed, gpaPerfCounterAMD.eventID ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GpaSampleBeginInfoAMD const & gpaSampleBeginInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sampleType ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sampleInternalOperations ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.cacheFlushOnCounterCollection ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sqShaderMaskEnable ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sqShaderMask ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.perfCounterCount ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.pPerfCounters ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.streamingPerfTraceSampleInterval ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.perfCounterDeviceMemoryLimit ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sqThreadTraceEnable ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sqThreadTraceSuppressInstructionTokens ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.sqThreadTraceDeviceMemoryLimit ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.timingPreSample ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSampleBeginInfoAMD.timingPostSample ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GpaSessionCreateInfoAMD const & gpaSessionCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, gpaSessionCreateInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSessionCreateInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, gpaSessionCreateInfoAMD.secondaryCopySource ); + return seed; + } + }; + template <> struct hash { @@ -9132,14 +9321,14 @@ VULKAN_HPP_EXPORT namespace std }; template <> - struct hash + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleKHR const & micromapTriangleKHR ) const VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset ); - VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel ); - VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format ); + VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleKHR.dataOffset ); + VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleKHR.subdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleKHR.format ); return seed; } }; @@ -10564,6 +10753,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & + physicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM.dataGraphNeuralAcceleratorStatistics ); + return seed; + } + }; + template <> struct hash { @@ -11229,6 +11432,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceElapsedTimerQueryFeaturesQCOM const & physicalDeviceElapsedTimerQueryFeaturesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceElapsedTimerQueryFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceElapsedTimerQueryFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceElapsedTimerQueryFeaturesQCOM.elapsedTimerQuery ); + return seed; + } + }; + template <> struct hash { @@ -11910,6 +12127,52 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGpaFeaturesAMD const & physicalDeviceGpaFeaturesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaFeaturesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaFeaturesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaFeaturesAMD.perfCounters ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaFeaturesAMD.streamingPerfCounters ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaFeaturesAMD.sqThreadTracing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaFeaturesAMD.clockModes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGpaProperties2AMD const & physicalDeviceGpaProperties2AMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaProperties2AMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaProperties2AMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaProperties2AMD.revisionId ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGpaPropertiesAMD const & physicalDeviceGpaPropertiesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaPropertiesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaPropertiesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaPropertiesAMD.flags ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaPropertiesAMD.maxSqttSeBufferSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaPropertiesAMD.shaderEngineCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaPropertiesAMD.perfBlockCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGpaPropertiesAMD.pPerfBlocks ); + return seed; + } + }; + template <> struct hash { @@ -12178,6 +12441,22 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing3FeaturesQCOM const & physicalDeviceImageProcessing3FeaturesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing3FeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing3FeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing3FeaturesQCOM.imageGatherLinear ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing3FeaturesQCOM.imageGatherExtendedModes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing3FeaturesQCOM.blockMatchExtendedClampToEdge ); + return seed; + } + }; + template <> struct hash { @@ -12738,6 +13017,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance11FeaturesKHR const & physicalDeviceMaintenance11FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance11FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance11FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance11FeaturesKHR.maintenance11 ); + return seed; + } + }; + template <> struct hash { @@ -13343,6 +13636,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesKHR const & physicalDeviceOpacityMicromapFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesKHR.micromap ); + return seed; + } + }; + template <> struct hash { @@ -13358,6 +13665,23 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesKHR const & physicalDeviceOpacityMicromapPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesKHR.maxOpacity2StateSubdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesKHR.maxOpacity4StateSubdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesKHR.maxOpacityLossy4StateSubdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesKHR.maxMicromapTriangles ); + return seed; + } + }; + template <> struct hash { @@ -15157,6 +15481,35 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & physicalDeviceShaderMultipleWaitQueuesFeaturesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMultipleWaitQueuesFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMultipleWaitQueuesFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMultipleWaitQueuesFeaturesQCOM.shaderMultipleWaitQueues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & + physicalDeviceShaderMultipleWaitQueuesPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMultipleWaitQueuesPropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMultipleWaitQueuesPropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMultipleWaitQueuesPropertiesQCOM.maxShaderWaitQueues ); + return seed; + } + }; + template <> struct hash { @@ -15261,6 +15614,34 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSplitBarrierFeaturesEXT const & physicalDeviceShaderSplitBarrierFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSplitBarrierFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSplitBarrierFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSplitBarrierFeaturesEXT.shaderSplitBarrier ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSplitBarrierPropertiesEXT const & physicalDeviceShaderSplitBarrierPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSplitBarrierPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSplitBarrierPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSplitBarrierPropertiesEXT.splitBarrierReservedSharedMemory ); + return seed; + } + }; + template <> struct hash { @@ -15674,6 +16055,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceThrottleHintFeaturesSEC const & physicalDeviceThrottleHintFeaturesSEC ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceThrottleHintFeaturesSEC.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceThrottleHintFeaturesSEC.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceThrottleHintFeaturesSEC.throttleHint ); + return seed; + } + }; + template <> struct hash { @@ -17935,6 +18330,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyOptimalImageTransferGranularityPropertiesKHR const & + queueFamilyOptimalImageTransferGranularityPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOptimalImageTransferGranularityPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOptimalImageTransferGranularityPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOptimalImageTransferGranularityPropertiesKHR.optimalImageTransferGranularity ); + return seed; + } + }; + template <> struct hash { @@ -20031,6 +20440,19 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ThrottleHintSubmitInfoSEC const & throttleHintSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, throttleHintSubmitInfoSEC.sType ); + VULKAN_HPP_HASH_COMBINE( seed, throttleHintSubmitInfoSEC.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, throttleHintSubmitInfoSEC.throttleHint ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_hpp_macros.hpp b/third_party/vulkan/vulkan_hpp_macros.hpp index af154ae..5cb6e98 100644 --- a/third_party/vulkan/vulkan_hpp_macros.hpp +++ b/third_party/vulkan/vulkan_hpp_macros.hpp @@ -198,7 +198,7 @@ VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ name # else # define VULKAN_HPP_CONSTEXPR_17 # endif -# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) ) +# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 120000 <= GCC_VERSION ) ) # define VULKAN_HPP_CONSTEXPR_20 constexpr # else # define VULKAN_HPP_CONSTEXPR_20 diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index 674b3bd..3c13501 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -1188,6 +1188,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + vkCreateGpaSessionAMD = PFN_vkCreateGpaSessionAMD( vkGetDeviceProcAddr( device, "vkCreateGpaSessionAMD" ) ); + vkDestroyGpaSessionAMD = PFN_vkDestroyGpaSessionAMD( vkGetDeviceProcAddr( device, "vkDestroyGpaSessionAMD" ) ); + vkSetGpaDeviceClockModeAMD = PFN_vkSetGpaDeviceClockModeAMD( vkGetDeviceProcAddr( device, "vkSetGpaDeviceClockModeAMD" ) ); + vkGetGpaDeviceClockInfoAMD = PFN_vkGetGpaDeviceClockInfoAMD( vkGetDeviceProcAddr( device, "vkGetGpaDeviceClockInfoAMD" ) ); + vkCmdBeginGpaSessionAMD = PFN_vkCmdBeginGpaSessionAMD( vkGetDeviceProcAddr( device, "vkCmdBeginGpaSessionAMD" ) ); + vkCmdEndGpaSessionAMD = PFN_vkCmdEndGpaSessionAMD( vkGetDeviceProcAddr( device, "vkCmdEndGpaSessionAMD" ) ); + vkCmdBeginGpaSampleAMD = PFN_vkCmdBeginGpaSampleAMD( vkGetDeviceProcAddr( device, "vkCmdBeginGpaSampleAMD" ) ); + vkCmdEndGpaSampleAMD = PFN_vkCmdEndGpaSampleAMD( vkGetDeviceProcAddr( device, "vkCmdEndGpaSampleAMD" ) ); + vkGetGpaSessionStatusAMD = PFN_vkGetGpaSessionStatusAMD( vkGetDeviceProcAddr( device, "vkGetGpaSessionStatusAMD" ) ); + vkGetGpaSessionResultsAMD = PFN_vkGetGpaSessionResultsAMD( vkGetDeviceProcAddr( device, "vkGetGpaSessionResultsAMD" ) ); + vkResetGpaSessionAMD = PFN_vkResetGpaSessionAMD( vkGetDeviceProcAddr( device, "vkResetGpaSessionAMD" ) ); + vkCmdCopyGpaSessionResultsAMD = PFN_vkCmdCopyGpaSessionResultsAMD( vkGetDeviceProcAddr( device, "vkCmdCopyGpaSessionResultsAMD" ) ); + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) ); @@ -2467,6 +2481,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + PFN_vkCreateGpaSessionAMD vkCreateGpaSessionAMD = 0; + PFN_vkDestroyGpaSessionAMD vkDestroyGpaSessionAMD = 0; + PFN_vkSetGpaDeviceClockModeAMD vkSetGpaDeviceClockModeAMD = 0; + PFN_vkGetGpaDeviceClockInfoAMD vkGetGpaDeviceClockInfoAMD = 0; + PFN_vkCmdBeginGpaSessionAMD vkCmdBeginGpaSessionAMD = 0; + PFN_vkCmdEndGpaSessionAMD vkCmdEndGpaSessionAMD = 0; + PFN_vkCmdBeginGpaSampleAMD vkCmdBeginGpaSampleAMD = 0; + PFN_vkCmdEndGpaSampleAMD vkCmdEndGpaSampleAMD = 0; + PFN_vkGetGpaSessionStatusAMD vkGetGpaSessionStatusAMD = 0; + PFN_vkGetGpaSessionResultsAMD vkGetGpaSessionResultsAMD = 0; + PFN_vkResetGpaSessionAMD vkResetGpaSessionAMD = 0; + PFN_vkCmdCopyGpaSessionResultsAMD vkCmdCopyGpaSessionResultsAMD = 0; + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0; @@ -3212,6 +3240,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_debug_utils === class DebugUtilsMessengerEXT; + //=== VK_AMD_gpa_interface === + class GpaSessionAMD; + //=== VK_EXT_descriptor_heap === class TensorARM; @@ -5052,6 +5083,19 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE getMemoryAndroidHardwareBufferANDROID( MemoryGetAndroidHardwareBufferInfoANDROID const & info ) const; # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createGpaSessionAMD( GpaSessionCreateInfoAMD const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkSetGpaDeviceClockModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetGpaDeviceClockModeAMD.html + VULKAN_HPP_NODISCARD typename ResultValueType::type setGpaClockModeAMD() const; + + // wrapper function for command vkGetGpaDeviceClockInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaDeviceClockInfoAMD.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getGpaClockInfoAMD() const; + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === @@ -7116,7 +7160,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT; // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html - void setBlendConstants( float const blendConstants[4] ) const VULKAN_HPP_NOEXCEPT; + void setBlendConstants( std::array const & blendConstants ) const VULKAN_HPP_NOEXCEPT; // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT; @@ -7531,6 +7575,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html void insertDebugUtilsLabelEXT( DebugUtilsLabelEXT const & labelInfo ) const VULKAN_HPP_NOEXCEPT; + //=== VK_AMD_gpa_interface === + + // wrapper function for command vkCmdBeginGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSessionAMD.html + typename ResultValueType::type beginGpaSessionAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession ) const; + + // wrapper function for command vkCmdEndGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSessionAMD.html + typename ResultValueType::type endGpaSessionAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession ) const; + + // wrapper function for command vkCmdBeginGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSampleAMD.html + VULKAN_HPP_NODISCARD typename ResultValueType::type beginGpaSampleAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession, + GpaSampleBeginInfoAMD const & gpaSampleBeginInfo ) const; + + // wrapper function for command vkCmdEndGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSampleAMD.html + void endGpaSampleAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession, uint32_t sampleID ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyGpaSessionResultsAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyGpaSessionResultsAMD.html + void copyGpaSessionResultsAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession ) const VULKAN_HPP_NOEXCEPT; + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === @@ -7765,7 +7828,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper function for command vkCmdSetFragmentShadingRateKHR, see // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - void setFragmentShadingRateKHR( Extent2D const & fragmentSize, FragmentShadingRateCombinerOpKHR const combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; + void setFragmentShadingRateKHR( Extent2D const & fragmentSize, + std::array const & combinerOps ) const VULKAN_HPP_NOEXCEPT; //=== VK_KHR_dynamic_rendering_local_read === @@ -8020,7 +8084,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html - void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, FragmentShadingRateCombinerOpKHR const combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; + void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, + std::array const & combinerOps ) const VULKAN_HPP_NOEXCEPT; //=== VK_EXT_mesh_shader === @@ -11116,6 +11181,144 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; + // wrapper class for handle VkGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaSessionAMD.html + class GpaSessionAMD + { + public: + using CType = VkGpaSessionAMD; + using CppType = VULKAN_HPP_NAMESPACE::GpaSessionAMD; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eGpaSessionAMD; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + GpaSessionAMD( Device const & device, GpaSessionCreateInfoAMD const & createInfo, Optional allocator = nullptr ) + { + *this = device.createGpaSessionAMD( createInfo, allocator ); + } +# endif + + GpaSessionAMD( Device const & device, VkGpaSessionAMD gpaSession, Optional allocator = nullptr ) + : m_device( device ) + , m_gpaSessionAMD( gpaSession ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + GpaSessionAMD( std::nullptr_t ) {} + + ~GpaSessionAMD() + { + clear(); + } + + GpaSessionAMD() = delete; + GpaSessionAMD( GpaSessionAMD const & ) = delete; + + GpaSessionAMD( GpaSessionAMD && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_gpaSessionAMD( exchange( rhs.m_gpaSessionAMD, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + GpaSessionAMD & operator=( GpaSessionAMD const & ) = delete; + + GpaSessionAMD & operator=( GpaSessionAMD && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_gpaSessionAMD, rhs.m_gpaSessionAMD ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::GpaSessionAMD const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_gpaSessionAMD; + } + + VULKAN_HPP_NAMESPACE::GpaSessionAMD const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_gpaSessionAMD ); + } + + operator VULKAN_HPP_NAMESPACE::GpaSessionAMD() const VULKAN_HPP_NOEXCEPT + { + return m_gpaSessionAMD; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_gpaSessionAMD ) + { + getDispatcher()->vkDestroyGpaSessionAMD( static_cast( m_device ), + static_cast( m_gpaSessionAMD ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_gpaSessionAMD = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::GpaSessionAMD release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_gpaSessionAMD, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( GpaSessionAMD & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_gpaSessionAMD, rhs.m_gpaSessionAMD ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_AMD_gpa_interface === + + // wrapper function for command vkGetGpaSessionStatusAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionStatusAMD.html + typename ResultValueType::type getStatus() const; + + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getResults( uint32_t sampleID ) const; + + // wrapper function for command vkResetGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetGpaSessionAMD.html + typename ResultValueType::type reset() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::GpaSessionAMD m_gpaSessionAMD = {}; + AllocationCallbacks const * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html class Image { @@ -17272,11 +17475,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html - VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( float const blendConstants[4] ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( std::array const & blendConstants ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetBlendConstants && "Function requires " ); - getDispatcher()->vkCmdSetBlendConstants( static_cast( m_commandBuffer ), blendConstants ); + getDispatcher()->vkCmdSetBlendConstants( static_cast( m_commandBuffer ), blendConstants.data() ); } // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html @@ -22156,6 +22359,160 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + //=== VK_AMD_gpa_interface === + + // wrapper function for command vkCreateGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGpaSessionAMD.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createGpaSessionAMD( GpaSessionCreateInfoAMD const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateGpaSessionAMD && "Function requires " ); + + VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession; + Result result = static_cast( getDispatcher()->vkCreateGpaSessionAMD( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &gpaSession ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createGpaSessionAMD" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, + GpaSessionAMD( *this, *reinterpret_cast( &gpaSession ), allocator ) ); + } + + // wrapper function for command vkSetGpaDeviceClockModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetGpaDeviceClockModeAMD.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::setGpaClockModeAMD() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetGpaDeviceClockModeAMD && "Function requires " ); + + GpaDeviceClockModeInfoAMD info; + Result result = static_cast( + getDispatcher()->vkSetGpaDeviceClockModeAMD( static_cast( m_device ), reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setGpaClockModeAMD" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( info ) ); + } + + // wrapper function for command vkGetGpaDeviceClockInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaDeviceClockInfoAMD.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getGpaClockInfoAMD() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetGpaDeviceClockInfoAMD && "Function requires " ); + + GpaDeviceGetClockInfoAMD info; + Result result = static_cast( + getDispatcher()->vkGetGpaDeviceClockInfoAMD( static_cast( m_device ), reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getGpaClockInfoAMD" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( info ) ); + } + + // wrapper function for command vkCmdBeginGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSessionAMD.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::beginGpaSessionAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginGpaSessionAMD && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkCmdBeginGpaSessionAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::beginGpaSessionAMD" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdEndGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSessionAMD.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::endGpaSessionAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndGpaSessionAMD && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkCmdEndGpaSessionAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::endGpaSessionAMD" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdBeginGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginGpaSampleAMD.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + CommandBuffer::beginGpaSampleAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession, GpaSampleBeginInfoAMD const & gpaSampleBeginInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginGpaSampleAMD && "Function requires " ); + + uint32_t sampleID; + Result result = static_cast( getDispatcher()->vkCmdBeginGpaSampleAMD( static_cast( m_commandBuffer ), + static_cast( gpaSession ), + reinterpret_cast( &gpaSampleBeginInfo ), + &sampleID ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::beginGpaSampleAMD" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( sampleID ) ); + } + + // wrapper function for command vkCmdEndGpaSampleAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndGpaSampleAMD.html + VULKAN_HPP_INLINE void CommandBuffer::endGpaSampleAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession, uint32_t sampleID ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndGpaSampleAMD && "Function requires " ); + + getDispatcher()->vkCmdEndGpaSampleAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ), sampleID ); + } + + // wrapper function for command vkGetGpaSessionStatusAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionStatusAMD.html + VULKAN_HPP_INLINE typename ResultValueType::type GpaSessionAMD::getStatus() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetGpaSessionStatusAMD && "Function requires " ); + + Result result = + static_cast( getDispatcher()->vkGetGpaSessionStatusAMD( static_cast( m_device ), static_cast( m_gpaSessionAMD ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::GpaSessionAMD::getStatus" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetGpaSessionResultsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGpaSessionResultsAMD.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type GpaSessionAMD::getResults( uint32_t sampleID ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetGpaSessionResultsAMD && "Function requires " ); + + std::vector data; + size_t sizeInBytes; + Result result = static_cast( getDispatcher()->vkGetGpaSessionResultsAMD( + static_cast( m_device ), static_cast( m_gpaSessionAMD ), sampleID, &sizeInBytes, nullptr ) ); + if ( result == Result::eSuccess ) + { + data.resize( sizeInBytes ); + result = static_cast( getDispatcher()->vkGetGpaSessionResultsAMD( static_cast( m_device ), + static_cast( m_gpaSessionAMD ), + sampleID, + &sizeInBytes, + reinterpret_cast( data.data() ) ) ); + } + + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::GpaSessionAMD::getResults" ); + VULKAN_HPP_ASSERT( sizeInBytes <= data.size() ); + if ( sizeInBytes < data.size() ) + { + data.resize( sizeInBytes ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkResetGpaSessionAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetGpaSessionAMD.html + VULKAN_HPP_INLINE typename ResultValueType::type GpaSessionAMD::reset() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetGpaSessionAMD && "Function requires " ); + + Result result = + static_cast( getDispatcher()->vkResetGpaSessionAMD( static_cast( m_device ), static_cast( m_gpaSessionAMD ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::GpaSessionAMD::reset" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdCopyGpaSessionResultsAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyGpaSessionResultsAMD.html + VULKAN_HPP_INLINE void CommandBuffer::copyGpaSessionResultsAMD( VULKAN_HPP_NAMESPACE::GpaSessionAMD gpaSession ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyGpaSessionResultsAMD && "Function requires " ); + + getDispatcher()->vkCmdCopyGpaSessionResultsAMD( static_cast( m_commandBuffer ), static_cast( gpaSession ) ); + } + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === @@ -24317,15 +24674,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper function for command vkCmdSetFragmentShadingRateKHR, see // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( Extent2D const & fragmentSize, - FragmentShadingRateCombinerOpKHR const combinerOps[2] ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void + CommandBuffer::setFragmentShadingRateKHR( Extent2D const & fragmentSize, + std::array const & combinerOps ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateKHR && "Function requires " ); getDispatcher()->vkCmdSetFragmentShadingRateKHR( static_cast( m_commandBuffer ), reinterpret_cast( &fragmentSize ), - reinterpret_cast( combinerOps ) ); + reinterpret_cast( combinerOps.data() ) ); } //=== VK_KHR_dynamic_rendering_local_read === @@ -26096,15 +26454,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html - VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, - FragmentShadingRateCombinerOpKHR const combinerOps[2] ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void + CommandBuffer::setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, + std::array const & combinerOps ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateEnumNV && "Function requires " ); getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( static_cast( m_commandBuffer ), static_cast( shadingRate ), - reinterpret_cast( combinerOps ) ); + reinterpret_cast( combinerOps.data() ) ); } //=== VK_EXT_mesh_shader === diff --git a/third_party/vulkan/vulkan_shared.hpp b/third_party/vulkan/vulkan_shared.hpp index 19c957c..926f99a 100644 --- a/third_party/vulkan/vulkan_shared.hpp +++ b/third_party/vulkan/vulkan_shared.hpp @@ -824,6 +824,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using SharedDebugUtilsMessengerEXT = SharedHandle; + //=== VK_AMD_gpa_interface === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedGpaSessionAMD = SharedHandle; + //=== VK_EXT_descriptor_heap === template <> class SharedHandleTraits diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index 87a41e5..c53ae2c 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -3546,6 +3546,65 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "GpaSessionAMD is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "GpaSessionAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GpaPerfBlockPropertiesAMD ) == sizeof( VkGpaPerfBlockPropertiesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GpaPerfBlockPropertiesAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGpaFeaturesAMD ) == sizeof( VkPhysicalDeviceGpaFeaturesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceGpaFeaturesAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGpaPropertiesAMD ) == sizeof( VkPhysicalDeviceGpaPropertiesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceGpaPropertiesAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGpaProperties2AMD ) == sizeof( VkPhysicalDeviceGpaProperties2AMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceGpaProperties2AMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GpaPerfCounterAMD ) == sizeof( VkGpaPerfCounterAMD ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GpaPerfCounterAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GpaSampleBeginInfoAMD ) == sizeof( VkGpaSampleBeginInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GpaSampleBeginInfoAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GpaDeviceClockModeInfoAMD ) == sizeof( VkGpaDeviceClockModeInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GpaDeviceClockModeInfoAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GpaDeviceGetClockInfoAMD ) == sizeof( VkGpaDeviceGetClockInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GpaDeviceGetClockInfoAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GpaSessionCreateInfoAMD ) == sizeof( VkGpaSessionCreateInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GpaSessionCreateInfoAMD is not nothrow_move_constructible!" ); + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_AMDX_shader_enqueue === @@ -4406,6 +4465,16 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM is not nothrow_move_constructible!" ); +//=== VK_QCOM_elapsed_timer_query === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceElapsedTimerQueryFeaturesQCOM ) == + sizeof( VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceElapsedTimerQueryFeaturesQCOM is not nothrow_move_constructible!" ); + //=== VK_EXT_external_memory_host === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), @@ -5607,6 +5676,51 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceQueuePerfHintPropertiesQCOM is not nothrow_move_constructible!" ); +//=== VK_QCOM_image_processing3 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing3FeaturesQCOM ) == sizeof( VkPhysicalDeviceImageProcessing3FeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageProcessing3FeaturesQCOM is not nothrow_move_constructible!" ); + +//=== VK_QCOM_shader_multiple_wait_queues === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM ) == + sizeof( VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM ) == + sizeof( VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_split_barrier === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSplitBarrierFeaturesEXT ) == + sizeof( VkPhysicalDeviceShaderSplitBarrierFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSplitBarrierFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSplitBarrierPropertiesEXT ) == + sizeof( VkPhysicalDeviceShaderSplitBarrierPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSplitBarrierPropertiesEXT is not nothrow_move_constructible!" ); + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_cuda_kernel_launch === @@ -6809,11 +6923,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "AccelerationStructureTrianglesOpacityMicromapEXT is not nothrow_move_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT ) == sizeof( VkMicromapTriangleEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MicromapTriangleEXT is not nothrow_move_constructible!" ); - #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_displacement_micromap === @@ -9967,6 +10076,48 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR is not nothrow_move_constructible!" ); +//=== VK_KHR_opacity_micromap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMicromapDataKHR ) == + sizeof( VkAccelerationStructureGeometryMicromapDataKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryMicromapDataKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapUsageKHR ) == sizeof( VkMicromapUsageKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapUsageKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesKHR ) == sizeof( VkPhysicalDeviceOpacityMicromapFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceOpacityMicromapFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesKHR ) == sizeof( VkPhysicalDeviceOpacityMicromapPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceOpacityMicromapPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapTriangleKHR ) == sizeof( VkMicromapTriangleKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapTriangleKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapKHR ) == + sizeof( VkAccelerationStructureTrianglesOpacityMicromapKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureTrianglesOpacityMicromapKHR is not nothrow_move_constructible!" ); + //=== VK_EXT_shader_64bit_indexing === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT ) == @@ -10179,6 +10330,23 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceComputeOccupancyPriorityFeaturesNV is not nothrow_move_constructible!" ); +//=== VK_KHR_maintenance11 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance11FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance11FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance11FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyOptimalImageTransferGranularityPropertiesKHR ) == + sizeof( VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyOptimalImageTransferGranularityPropertiesKHR is not nothrow_move_constructible!" ); + //=== VK_EXT_shader_subgroup_partitioned === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ) == @@ -10209,6 +10377,47 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE is not nothrow_move_constructible!" ); +//=== VK_SEC_throttle_hint === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ThrottleHintSubmitInfoSEC ) == sizeof( VkThrottleHintSubmitInfoSEC ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ThrottleHintSubmitInfoSEC is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceThrottleHintFeaturesSEC ) == sizeof( VkPhysicalDeviceThrottleHintFeaturesSEC ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceThrottleHintFeaturesSEC is not nothrow_move_constructible!" ); + +//=== VK_ARM_data_graph_neural_accelerator_statistics === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM ) == + sizeof( VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineNeuralStatisticsCreateInfoARM ) == + sizeof( VkDataGraphPipelineNeuralStatisticsCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineNeuralStatisticsCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionNeuralStatisticsCreateInfoARM ) == + sizeof( VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSessionNeuralStatisticsCreateInfoARM is not nothrow_move_constructible!" ); + //=== VK_EXT_primitive_restart_index === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveRestartIndexFeaturesEXT ) == diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index 4dde26d..66e0ccd 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -3902,6 +3902,389 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureGeometryLinearSweptSpheresDataNV; }; + // wrapper struct for struct VkMicromapUsageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapUsageKHR.html + struct MicromapUsageKHR + { + using NativeType = VkMicromapUsageKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MicromapUsageKHR( uint32_t count_ = {}, + uint32_t subdivisionLevel_ = {}, + OpacityMicromapFormatKHR format_ = OpacityMicromapFormatKHR::e2State ) VULKAN_HPP_NOEXCEPT + : count{ count_ } + , subdivisionLevel{ subdivisionLevel_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR MicromapUsageKHR( MicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MicromapUsageKHR( VkMicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapUsageKHR( *reinterpret_cast( &rhs ) ) {} + + MicromapUsageKHR & operator=( MicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MicromapUsageKHR & operator=( VkMicromapUsageKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR & setCount( uint32_t count_ ) & VULKAN_HPP_NOEXCEPT + { + count = count_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR && setCount( uint32_t count_ ) && VULKAN_HPP_NOEXCEPT + { + count = count_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR & setSubdivisionLevel( uint32_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT + { + subdivisionLevel = subdivisionLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR && setSubdivisionLevel( uint32_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT + { + subdivisionLevel = subdivisionLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR & setFormat( OpacityMicromapFormatKHR format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageKHR && setFormat( OpacityMicromapFormatKHR format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMicromapUsageKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapUsageKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapUsageKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMicromapUsageKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( count, subdivisionLevel, format ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MicromapUsageKHR const & ) const = default; +#else + bool operator==( MicromapUsageKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( count == rhs.count ) && ( subdivisionLevel == rhs.subdivisionLevel ) && ( format == rhs.format ); +# endif + } + + bool operator!=( MicromapUsageKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t count = {}; + uint32_t subdivisionLevel = {}; + OpacityMicromapFormatKHR format = OpacityMicromapFormatKHR::e2State; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MicromapUsageKHR; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureGeometryMicromapDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryMicromapDataKHR.html + struct AccelerationStructureGeometryMicromapDataKHR + { + using NativeType = VkAccelerationStructureGeometryMicromapDataKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryMicromapDataKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureGeometryMicromapDataKHR( uint32_t usageCountsCount_ = {}, + MicromapUsageKHR const * pUsageCounts_ = {}, + MicromapUsageKHR const * const * ppUsageCounts_ = {}, + DeviceAddress data_ = {}, + DeviceAddress triangleArray_ = {}, + DeviceSize triangleArrayStride_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , usageCountsCount{ usageCountsCount_ } + , pUsageCounts{ pUsageCounts_ } + , ppUsageCounts{ ppUsageCounts_ } + , data{ data_ } + , triangleArray{ triangleArray_ } + , triangleArrayStride{ triangleArrayStride_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureGeometryMicromapDataKHR( AccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometryMicromapDataKHR( VkAccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometryMicromapDataKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureGeometryMicromapDataKHR( ArrayProxyNoTemporaries const & usageCounts_, + ArrayProxyNoTemporaries const & pUsageCounts_ = {}, + DeviceAddress data_ = {}, + DeviceAddress triangleArray_ = {}, + DeviceSize triangleArrayStride_ = {}, + void const * pNext_ = nullptr ) + : pNext( pNext_ ) + , usageCountsCount( static_cast( usageCounts_.size() ) ) + , pUsageCounts( usageCounts_.data() ) + , ppUsageCounts( pUsageCounts_.data() ) + , data( data_ ) + , triangleArray( triangleArray_ ) + , triangleArrayStride( triangleArrayStride_ ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( usageCounts_.empty() || pUsageCounts_.empty() || ( usageCounts_.size() == pUsageCounts_.size() ) ); +# else + if ( !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::AccelerationStructureGeometryMicromapDataKHR::AccelerationStructureGeometryMicromapDataKHR: !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + AccelerationStructureGeometryMicromapDataKHR & operator=( AccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometryMicromapDataKHR & operator=( VkAccelerationStructureGeometryMicromapDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setPUsageCounts( MicromapUsageKHR const * pUsageCounts_ ) & VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setPUsageCounts( MicromapUsageKHR const * pUsageCounts_ ) && VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureGeometryMicromapDataKHR & setUsageCounts( ArrayProxyNoTemporaries const & usageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( usageCounts_.size() ); + pUsageCounts = usageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setPpUsageCounts( MicromapUsageKHR const * const * ppUsageCounts_ ) & + VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setPpUsageCounts( MicromapUsageKHR const * const * ppUsageCounts_ ) && + VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureGeometryMicromapDataKHR & + setPUsageCounts( ArrayProxyNoTemporaries const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( pUsageCounts_.size() ); + ppUsageCounts = pUsageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setData( DeviceAddress data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setData( DeviceAddress data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setTriangleArray( DeviceAddress triangleArray_ ) & VULKAN_HPP_NOEXCEPT + { + triangleArray = triangleArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setTriangleArray( DeviceAddress triangleArray_ ) && VULKAN_HPP_NOEXCEPT + { + triangleArray = triangleArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR & setTriangleArrayStride( DeviceSize triangleArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + triangleArrayStride = triangleArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMicromapDataKHR && setTriangleArrayStride( DeviceSize triangleArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + triangleArrayStride = triangleArrayStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryMicromapDataKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryMicromapDataKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryMicromapDataKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryMicromapDataKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, usageCountsCount, pUsageCounts, ppUsageCounts, data, triangleArray, triangleArrayStride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureGeometryMicromapDataKHR const & ) const = default; +#else + bool operator==( AccelerationStructureGeometryMicromapDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usageCountsCount == rhs.usageCountsCount ) && ( pUsageCounts == rhs.pUsageCounts ) && + ( ppUsageCounts == rhs.ppUsageCounts ) && ( data == rhs.data ) && ( triangleArray == rhs.triangleArray ) && + ( triangleArrayStride == rhs.triangleArrayStride ); +# endif + } + + bool operator!=( AccelerationStructureGeometryMicromapDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometryMicromapDataKHR; + void const * pNext = {}; + uint32_t usageCountsCount = {}; + MicromapUsageKHR const * pUsageCounts = {}; + MicromapUsageKHR const * const * ppUsageCounts = {}; + DeviceAddress data = {}; + DeviceAddress triangleArray = {}; + DeviceSize triangleArrayStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryMicromapDataKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryMicromapDataKHR; + }; + // wrapper struct for struct VkAccelerationStructureGeometryMotionTrianglesDataNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html struct AccelerationStructureGeometryMotionTrianglesDataNV @@ -6637,6 +7020,199 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureTrianglesOpacityMicromapEXT; }; + // wrapper struct for struct VkAccelerationStructureTrianglesOpacityMicromapKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesOpacityMicromapKHR.html + struct AccelerationStructureTrianglesOpacityMicromapKHR + { + using NativeType = VkAccelerationStructureTrianglesOpacityMicromapKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureTrianglesOpacityMicromapKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureTrianglesOpacityMicromapKHR( IndexType indexType_ = IndexType::eUint16, + DeviceAddress indexBuffer_ = {}, + DeviceSize indexStride_ = {}, + uint32_t baseTriangle_ = {}, + AccelerationStructureKHR micromap_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , indexType{ indexType_ } + , indexBuffer{ indexBuffer_ } + , indexStride{ indexStride_ } + , baseTriangle{ baseTriangle_ } + , micromap{ micromap_ } + { + } + + VULKAN_HPP_CONSTEXPR + AccelerationStructureTrianglesOpacityMicromapKHR( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureTrianglesOpacityMicromapKHR( VkAccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureTrianglesOpacityMicromapKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureTrianglesOpacityMicromapKHR & operator=( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureTrianglesOpacityMicromapKHR & operator=( VkAccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setIndexBuffer( DeviceAddress indexBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT + { + baseTriangle = baseTriangle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT + { + baseTriangle = baseTriangle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR & setMicromap( AccelerationStructureKHR micromap_ ) & VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapKHR && setMicromap( AccelerationStructureKHR micromap_ ) && VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureTrianglesOpacityMicromapKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesOpacityMicromapKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesOpacityMicromapKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesOpacityMicromapKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indexType, indexBuffer, indexStride, baseTriangle, micromap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureTrianglesOpacityMicromapKHR const & ) const = default; +#else + bool operator==( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexType == rhs.indexType ) && ( indexBuffer == rhs.indexBuffer ) && + ( indexStride == rhs.indexStride ) && ( baseTriangle == rhs.baseTriangle ) && ( micromap == rhs.micromap ); +# endif + } + + bool operator!=( AccelerationStructureTrianglesOpacityMicromapKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureTrianglesOpacityMicromapKHR; + void * pNext = {}; + IndexType indexType = IndexType::eUint16; + DeviceAddress indexBuffer = {}; + DeviceSize indexStride = {}; + uint32_t baseTriangle = {}; + AccelerationStructureKHR micromap = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureTrianglesOpacityMicromapKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureTrianglesOpacityMicromapKHR; + }; + // wrapper struct for struct VkAccelerationStructureVersionInfoKHR, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureVersionInfoKHR.html struct AccelerationStructureVersionInfoKHR @@ -38091,6 +38667,130 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DataGraphPipelineInfoARM; }; + // wrapper struct for struct VkDataGraphPipelineNeuralStatisticsCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineNeuralStatisticsCreateInfoARM.html + struct DataGraphPipelineNeuralStatisticsCreateInfoARM + { + using NativeType = VkDataGraphPipelineNeuralStatisticsCreateInfoARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineNeuralStatisticsCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineNeuralStatisticsCreateInfoARM( Bool32 allowNeuralStatistics_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , allowNeuralStatistics{ allowNeuralStatistics_ } + { + } + + VULKAN_HPP_CONSTEXPR + DataGraphPipelineNeuralStatisticsCreateInfoARM( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineNeuralStatisticsCreateInfoARM( VkDataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineNeuralStatisticsCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineNeuralStatisticsCreateInfoARM & operator=( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineNeuralStatisticsCreateInfoARM & operator=( VkDataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM & setAllowNeuralStatistics( Bool32 allowNeuralStatistics_ ) & VULKAN_HPP_NOEXCEPT + { + allowNeuralStatistics = allowNeuralStatistics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineNeuralStatisticsCreateInfoARM && setAllowNeuralStatistics( Bool32 allowNeuralStatistics_ ) && VULKAN_HPP_NOEXCEPT + { + allowNeuralStatistics = allowNeuralStatistics_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineNeuralStatisticsCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allowNeuralStatistics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineNeuralStatisticsCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allowNeuralStatistics == rhs.allowNeuralStatistics ); +# endif + } + + bool operator!=( DataGraphPipelineNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineNeuralStatisticsCreateInfoARM; + void const * pNext = {}; + Bool32 allowNeuralStatistics = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineNeuralStatisticsCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineNeuralStatisticsCreateInfoARM; + }; + // wrapper struct for struct VkDataGraphPipelineOpticalFlowCreateInfoARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineOpticalFlowCreateInfoARM.html struct DataGraphPipelineOpticalFlowCreateInfoARM @@ -39349,6 +40049,133 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DataGraphPipelineSessionMemoryRequirementsInfoARM; }; + // wrapper struct for struct VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM.html + struct DataGraphPipelineSessionNeuralStatisticsCreateInfoARM + { + using NativeType = VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( NeuralAcceleratorStatisticsModeARM mode_ = NeuralAcceleratorStatisticsModeARM::eDisabled, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR + DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineSessionNeuralStatisticsCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineSessionNeuralStatisticsCreateInfoARM & + operator=( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineSessionNeuralStatisticsCreateInfoARM & operator=( VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM & setMode( NeuralAcceleratorStatisticsModeARM mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionNeuralStatisticsCreateInfoARM && setMode( NeuralAcceleratorStatisticsModeARM mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionNeuralStatisticsCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ); +# endif + } + + bool operator!=( DataGraphPipelineSessionNeuralStatisticsCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + void const * pNext = {}; + NeuralAcceleratorStatisticsModeARM mode = NeuralAcceleratorStatisticsModeARM::eDisabled; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineSessionNeuralStatisticsCreateInfoARM; + }; + // wrapper struct for struct VkDataGraphPipelineShaderModuleCreateInfoARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineShaderModuleCreateInfoARM.html struct DataGraphPipelineShaderModuleCreateInfoARM @@ -70806,6 +71633,1174 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = GetLatencyMarkerInfoNV; }; + // wrapper struct for struct VkGpaDeviceClockModeInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaDeviceClockModeInfoAMD.html + struct GpaDeviceClockModeInfoAMD + { + using NativeType = VkGpaDeviceClockModeInfoAMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGpaDeviceClockModeInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GpaDeviceClockModeInfoAMD( GpaDeviceClockModeAMD clockMode_ = GpaDeviceClockModeAMD::eDefault, + float memoryClockRatioToPeak_ = {}, + float engineClockRatioToPeak_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , clockMode{ clockMode_ } + , memoryClockRatioToPeak{ memoryClockRatioToPeak_ } + , engineClockRatioToPeak{ engineClockRatioToPeak_ } + { + } + + VULKAN_HPP_CONSTEXPR GpaDeviceClockModeInfoAMD( GpaDeviceClockModeInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GpaDeviceClockModeInfoAMD( VkGpaDeviceClockModeInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : GpaDeviceClockModeInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + GpaDeviceClockModeInfoAMD & operator=( GpaDeviceClockModeInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GpaDeviceClockModeInfoAMD & operator=( VkGpaDeviceClockModeInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD & setClockMode( GpaDeviceClockModeAMD clockMode_ ) & VULKAN_HPP_NOEXCEPT + { + clockMode = clockMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD && setClockMode( GpaDeviceClockModeAMD clockMode_ ) && VULKAN_HPP_NOEXCEPT + { + clockMode = clockMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD & setMemoryClockRatioToPeak( float memoryClockRatioToPeak_ ) & VULKAN_HPP_NOEXCEPT + { + memoryClockRatioToPeak = memoryClockRatioToPeak_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD && setMemoryClockRatioToPeak( float memoryClockRatioToPeak_ ) && VULKAN_HPP_NOEXCEPT + { + memoryClockRatioToPeak = memoryClockRatioToPeak_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD & setEngineClockRatioToPeak( float engineClockRatioToPeak_ ) & VULKAN_HPP_NOEXCEPT + { + engineClockRatioToPeak = engineClockRatioToPeak_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceClockModeInfoAMD && setEngineClockRatioToPeak( float engineClockRatioToPeak_ ) && VULKAN_HPP_NOEXCEPT + { + engineClockRatioToPeak = engineClockRatioToPeak_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGpaDeviceClockModeInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaDeviceClockModeInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaDeviceClockModeInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGpaDeviceClockModeInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, clockMode, memoryClockRatioToPeak, engineClockRatioToPeak ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GpaDeviceClockModeInfoAMD const & ) const = default; +#else + bool operator==( GpaDeviceClockModeInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clockMode == rhs.clockMode ) && ( memoryClockRatioToPeak == rhs.memoryClockRatioToPeak ) && + ( engineClockRatioToPeak == rhs.engineClockRatioToPeak ); +# endif + } + + bool operator!=( GpaDeviceClockModeInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGpaDeviceClockModeInfoAMD; + void const * pNext = {}; + GpaDeviceClockModeAMD clockMode = GpaDeviceClockModeAMD::eDefault; + float memoryClockRatioToPeak = {}; + float engineClockRatioToPeak = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GpaDeviceClockModeInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = GpaDeviceClockModeInfoAMD; + }; + + // wrapper struct for struct VkGpaDeviceGetClockInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaDeviceGetClockInfoAMD.html + struct GpaDeviceGetClockInfoAMD + { + using NativeType = VkGpaDeviceGetClockInfoAMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGpaDeviceGetClockInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GpaDeviceGetClockInfoAMD( float memoryClockRatioToPeak_ = {}, + float engineClockRatioToPeak_ = {}, + uint32_t memoryClockFrequency_ = {}, + uint32_t engineClockFrequency_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryClockRatioToPeak{ memoryClockRatioToPeak_ } + , engineClockRatioToPeak{ engineClockRatioToPeak_ } + , memoryClockFrequency{ memoryClockFrequency_ } + , engineClockFrequency{ engineClockFrequency_ } + { + } + + VULKAN_HPP_CONSTEXPR GpaDeviceGetClockInfoAMD( GpaDeviceGetClockInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GpaDeviceGetClockInfoAMD( VkGpaDeviceGetClockInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : GpaDeviceGetClockInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + GpaDeviceGetClockInfoAMD & operator=( GpaDeviceGetClockInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GpaDeviceGetClockInfoAMD & operator=( VkGpaDeviceGetClockInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD & setMemoryClockRatioToPeak( float memoryClockRatioToPeak_ ) & VULKAN_HPP_NOEXCEPT + { + memoryClockRatioToPeak = memoryClockRatioToPeak_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD && setMemoryClockRatioToPeak( float memoryClockRatioToPeak_ ) && VULKAN_HPP_NOEXCEPT + { + memoryClockRatioToPeak = memoryClockRatioToPeak_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD & setEngineClockRatioToPeak( float engineClockRatioToPeak_ ) & VULKAN_HPP_NOEXCEPT + { + engineClockRatioToPeak = engineClockRatioToPeak_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD && setEngineClockRatioToPeak( float engineClockRatioToPeak_ ) && VULKAN_HPP_NOEXCEPT + { + engineClockRatioToPeak = engineClockRatioToPeak_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD & setMemoryClockFrequency( uint32_t memoryClockFrequency_ ) & VULKAN_HPP_NOEXCEPT + { + memoryClockFrequency = memoryClockFrequency_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD && setMemoryClockFrequency( uint32_t memoryClockFrequency_ ) && VULKAN_HPP_NOEXCEPT + { + memoryClockFrequency = memoryClockFrequency_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD & setEngineClockFrequency( uint32_t engineClockFrequency_ ) & VULKAN_HPP_NOEXCEPT + { + engineClockFrequency = engineClockFrequency_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaDeviceGetClockInfoAMD && setEngineClockFrequency( uint32_t engineClockFrequency_ ) && VULKAN_HPP_NOEXCEPT + { + engineClockFrequency = engineClockFrequency_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGpaDeviceGetClockInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaDeviceGetClockInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaDeviceGetClockInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGpaDeviceGetClockInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryClockRatioToPeak, engineClockRatioToPeak, memoryClockFrequency, engineClockFrequency ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GpaDeviceGetClockInfoAMD const & ) const = default; +#else + bool operator==( GpaDeviceGetClockInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryClockRatioToPeak == rhs.memoryClockRatioToPeak ) && + ( engineClockRatioToPeak == rhs.engineClockRatioToPeak ) && ( memoryClockFrequency == rhs.memoryClockFrequency ) && + ( engineClockFrequency == rhs.engineClockFrequency ); +# endif + } + + bool operator!=( GpaDeviceGetClockInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGpaDeviceGetClockInfoAMD; + void * pNext = {}; + float memoryClockRatioToPeak = {}; + float engineClockRatioToPeak = {}; + uint32_t memoryClockFrequency = {}; + uint32_t engineClockFrequency = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GpaDeviceGetClockInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = GpaDeviceGetClockInfoAMD; + }; + + // wrapper struct for struct VkGpaPerfBlockPropertiesAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaPerfBlockPropertiesAMD.html + struct GpaPerfBlockPropertiesAMD + { + using NativeType = VkGpaPerfBlockPropertiesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GpaPerfBlockPropertiesAMD( GpaPerfBlockAMD blockType_ = GpaPerfBlockAMD::eCpf, + GpaPerfBlockPropertiesFlagsAMD flags_ = {}, + uint32_t instanceCount_ = {}, + uint32_t maxEventID_ = {}, + uint32_t maxGlobalOnlyCounters_ = {}, + uint32_t maxGlobalSharedCounters_ = {}, + uint32_t maxStreamingCounters_ = {} ) VULKAN_HPP_NOEXCEPT + : blockType{ blockType_ } + , flags{ flags_ } + , instanceCount{ instanceCount_ } + , maxEventID{ maxEventID_ } + , maxGlobalOnlyCounters{ maxGlobalOnlyCounters_ } + , maxGlobalSharedCounters{ maxGlobalSharedCounters_ } + , maxStreamingCounters{ maxStreamingCounters_ } + { + } + + VULKAN_HPP_CONSTEXPR GpaPerfBlockPropertiesAMD( GpaPerfBlockPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GpaPerfBlockPropertiesAMD( VkGpaPerfBlockPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : GpaPerfBlockPropertiesAMD( *reinterpret_cast( &rhs ) ) + { + } + + GpaPerfBlockPropertiesAMD & operator=( GpaPerfBlockPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GpaPerfBlockPropertiesAMD & operator=( VkGpaPerfBlockPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD & setBlockType( GpaPerfBlockAMD blockType_ ) & VULKAN_HPP_NOEXCEPT + { + blockType = blockType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD && setBlockType( GpaPerfBlockAMD blockType_ ) && VULKAN_HPP_NOEXCEPT + { + blockType = blockType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD & setFlags( GpaPerfBlockPropertiesFlagsAMD flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD && setFlags( GpaPerfBlockPropertiesFlagsAMD flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD & setMaxEventID( uint32_t maxEventID_ ) & VULKAN_HPP_NOEXCEPT + { + maxEventID = maxEventID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD && setMaxEventID( uint32_t maxEventID_ ) && VULKAN_HPP_NOEXCEPT + { + maxEventID = maxEventID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD & setMaxGlobalOnlyCounters( uint32_t maxGlobalOnlyCounters_ ) & VULKAN_HPP_NOEXCEPT + { + maxGlobalOnlyCounters = maxGlobalOnlyCounters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD && setMaxGlobalOnlyCounters( uint32_t maxGlobalOnlyCounters_ ) && VULKAN_HPP_NOEXCEPT + { + maxGlobalOnlyCounters = maxGlobalOnlyCounters_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD & setMaxGlobalSharedCounters( uint32_t maxGlobalSharedCounters_ ) & VULKAN_HPP_NOEXCEPT + { + maxGlobalSharedCounters = maxGlobalSharedCounters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD && setMaxGlobalSharedCounters( uint32_t maxGlobalSharedCounters_ ) && VULKAN_HPP_NOEXCEPT + { + maxGlobalSharedCounters = maxGlobalSharedCounters_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD & setMaxStreamingCounters( uint32_t maxStreamingCounters_ ) & VULKAN_HPP_NOEXCEPT + { + maxStreamingCounters = maxStreamingCounters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfBlockPropertiesAMD && setMaxStreamingCounters( uint32_t maxStreamingCounters_ ) && VULKAN_HPP_NOEXCEPT + { + maxStreamingCounters = maxStreamingCounters_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGpaPerfBlockPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaPerfBlockPropertiesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaPerfBlockPropertiesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGpaPerfBlockPropertiesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( blockType, flags, instanceCount, maxEventID, maxGlobalOnlyCounters, maxGlobalSharedCounters, maxStreamingCounters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GpaPerfBlockPropertiesAMD const & ) const = default; +#else + bool operator==( GpaPerfBlockPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( blockType == rhs.blockType ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) && ( maxEventID == rhs.maxEventID ) && + ( maxGlobalOnlyCounters == rhs.maxGlobalOnlyCounters ) && ( maxGlobalSharedCounters == rhs.maxGlobalSharedCounters ) && + ( maxStreamingCounters == rhs.maxStreamingCounters ); +# endif + } + + bool operator!=( GpaPerfBlockPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + GpaPerfBlockAMD blockType = GpaPerfBlockAMD::eCpf; + GpaPerfBlockPropertiesFlagsAMD flags = {}; + uint32_t instanceCount = {}; + uint32_t maxEventID = {}; + uint32_t maxGlobalOnlyCounters = {}; + uint32_t maxGlobalSharedCounters = {}; + uint32_t maxStreamingCounters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GpaPerfBlockPropertiesAMD; + }; +#endif + + // wrapper struct for struct VkGpaPerfCounterAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaPerfCounterAMD.html + struct GpaPerfCounterAMD + { + using NativeType = VkGpaPerfCounterAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + GpaPerfCounterAMD( GpaPerfBlockAMD blockType_ = GpaPerfBlockAMD::eCpf, uint32_t blockInstance_ = {}, uint32_t eventID_ = {} ) VULKAN_HPP_NOEXCEPT + : blockType{ blockType_ } + , blockInstance{ blockInstance_ } + , eventID{ eventID_ } + { + } + + VULKAN_HPP_CONSTEXPR GpaPerfCounterAMD( GpaPerfCounterAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GpaPerfCounterAMD( VkGpaPerfCounterAMD const & rhs ) VULKAN_HPP_NOEXCEPT : GpaPerfCounterAMD( *reinterpret_cast( &rhs ) ) {} + + GpaPerfCounterAMD & operator=( GpaPerfCounterAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GpaPerfCounterAMD & operator=( VkGpaPerfCounterAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GpaPerfCounterAMD & setBlockType( GpaPerfBlockAMD blockType_ ) & VULKAN_HPP_NOEXCEPT + { + blockType = blockType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfCounterAMD && setBlockType( GpaPerfBlockAMD blockType_ ) && VULKAN_HPP_NOEXCEPT + { + blockType = blockType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfCounterAMD & setBlockInstance( uint32_t blockInstance_ ) & VULKAN_HPP_NOEXCEPT + { + blockInstance = blockInstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfCounterAMD && setBlockInstance( uint32_t blockInstance_ ) && VULKAN_HPP_NOEXCEPT + { + blockInstance = blockInstance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfCounterAMD & setEventID( uint32_t eventID_ ) & VULKAN_HPP_NOEXCEPT + { + eventID = eventID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaPerfCounterAMD && setEventID( uint32_t eventID_ ) && VULKAN_HPP_NOEXCEPT + { + eventID = eventID_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGpaPerfCounterAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaPerfCounterAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaPerfCounterAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGpaPerfCounterAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( blockType, blockInstance, eventID ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GpaPerfCounterAMD const & ) const = default; +#else + bool operator==( GpaPerfCounterAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( blockType == rhs.blockType ) && ( blockInstance == rhs.blockInstance ) && ( eventID == rhs.eventID ); +# endif + } + + bool operator!=( GpaPerfCounterAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + GpaPerfBlockAMD blockType = GpaPerfBlockAMD::eCpf; + uint32_t blockInstance = {}; + uint32_t eventID = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GpaPerfCounterAMD; + }; +#endif + + // wrapper struct for struct VkGpaSampleBeginInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaSampleBeginInfoAMD.html + struct GpaSampleBeginInfoAMD + { + using NativeType = VkGpaSampleBeginInfoAMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGpaSampleBeginInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GpaSampleBeginInfoAMD( GpaSampleTypeAMD sampleType_ = GpaSampleTypeAMD::eCumulative, + Bool32 sampleInternalOperations_ = {}, + Bool32 cacheFlushOnCounterCollection_ = {}, + Bool32 sqShaderMaskEnable_ = {}, + GpaSqShaderStageFlagsAMD sqShaderMask_ = {}, + uint32_t perfCounterCount_ = {}, + GpaPerfCounterAMD const * pPerfCounters_ = {}, + uint32_t streamingPerfTraceSampleInterval_ = {}, + DeviceSize perfCounterDeviceMemoryLimit_ = {}, + Bool32 sqThreadTraceEnable_ = {}, + Bool32 sqThreadTraceSuppressInstructionTokens_ = {}, + DeviceSize sqThreadTraceDeviceMemoryLimit_ = {}, + PipelineStageFlags timingPreSample_ = {}, + PipelineStageFlags timingPostSample_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sampleType{ sampleType_ } + , sampleInternalOperations{ sampleInternalOperations_ } + , cacheFlushOnCounterCollection{ cacheFlushOnCounterCollection_ } + , sqShaderMaskEnable{ sqShaderMaskEnable_ } + , sqShaderMask{ sqShaderMask_ } + , perfCounterCount{ perfCounterCount_ } + , pPerfCounters{ pPerfCounters_ } + , streamingPerfTraceSampleInterval{ streamingPerfTraceSampleInterval_ } + , perfCounterDeviceMemoryLimit{ perfCounterDeviceMemoryLimit_ } + , sqThreadTraceEnable{ sqThreadTraceEnable_ } + , sqThreadTraceSuppressInstructionTokens{ sqThreadTraceSuppressInstructionTokens_ } + , sqThreadTraceDeviceMemoryLimit{ sqThreadTraceDeviceMemoryLimit_ } + , timingPreSample{ timingPreSample_ } + , timingPostSample{ timingPostSample_ } + { + } + + VULKAN_HPP_CONSTEXPR GpaSampleBeginInfoAMD( GpaSampleBeginInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GpaSampleBeginInfoAMD( VkGpaSampleBeginInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : GpaSampleBeginInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GpaSampleBeginInfoAMD( GpaSampleTypeAMD sampleType_, + Bool32 sampleInternalOperations_, + Bool32 cacheFlushOnCounterCollection_, + Bool32 sqShaderMaskEnable_, + GpaSqShaderStageFlagsAMD sqShaderMask_, + ArrayProxyNoTemporaries const & perfCounters_, + uint32_t streamingPerfTraceSampleInterval_ = {}, + DeviceSize perfCounterDeviceMemoryLimit_ = {}, + Bool32 sqThreadTraceEnable_ = {}, + Bool32 sqThreadTraceSuppressInstructionTokens_ = {}, + DeviceSize sqThreadTraceDeviceMemoryLimit_ = {}, + PipelineStageFlags timingPreSample_ = {}, + PipelineStageFlags timingPostSample_ = {}, + void const * pNext_ = nullptr ) + : pNext( pNext_ ) + , sampleType( sampleType_ ) + , sampleInternalOperations( sampleInternalOperations_ ) + , cacheFlushOnCounterCollection( cacheFlushOnCounterCollection_ ) + , sqShaderMaskEnable( sqShaderMaskEnable_ ) + , sqShaderMask( sqShaderMask_ ) + , perfCounterCount( static_cast( perfCounters_.size() ) ) + , pPerfCounters( perfCounters_.data() ) + , streamingPerfTraceSampleInterval( streamingPerfTraceSampleInterval_ ) + , perfCounterDeviceMemoryLimit( perfCounterDeviceMemoryLimit_ ) + , sqThreadTraceEnable( sqThreadTraceEnable_ ) + , sqThreadTraceSuppressInstructionTokens( sqThreadTraceSuppressInstructionTokens_ ) + , sqThreadTraceDeviceMemoryLimit( sqThreadTraceDeviceMemoryLimit_ ) + , timingPreSample( timingPreSample_ ) + , timingPostSample( timingPostSample_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + GpaSampleBeginInfoAMD & operator=( GpaSampleBeginInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GpaSampleBeginInfoAMD & operator=( VkGpaSampleBeginInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setSampleType( GpaSampleTypeAMD sampleType_ ) & VULKAN_HPP_NOEXCEPT + { + sampleType = sampleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setSampleType( GpaSampleTypeAMD sampleType_ ) && VULKAN_HPP_NOEXCEPT + { + sampleType = sampleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setSampleInternalOperations( Bool32 sampleInternalOperations_ ) & VULKAN_HPP_NOEXCEPT + { + sampleInternalOperations = sampleInternalOperations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setSampleInternalOperations( Bool32 sampleInternalOperations_ ) && VULKAN_HPP_NOEXCEPT + { + sampleInternalOperations = sampleInternalOperations_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setCacheFlushOnCounterCollection( Bool32 cacheFlushOnCounterCollection_ ) & VULKAN_HPP_NOEXCEPT + { + cacheFlushOnCounterCollection = cacheFlushOnCounterCollection_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setCacheFlushOnCounterCollection( Bool32 cacheFlushOnCounterCollection_ ) && VULKAN_HPP_NOEXCEPT + { + cacheFlushOnCounterCollection = cacheFlushOnCounterCollection_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setSqShaderMaskEnable( Bool32 sqShaderMaskEnable_ ) & VULKAN_HPP_NOEXCEPT + { + sqShaderMaskEnable = sqShaderMaskEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setSqShaderMaskEnable( Bool32 sqShaderMaskEnable_ ) && VULKAN_HPP_NOEXCEPT + { + sqShaderMaskEnable = sqShaderMaskEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setSqShaderMask( GpaSqShaderStageFlagsAMD sqShaderMask_ ) & VULKAN_HPP_NOEXCEPT + { + sqShaderMask = sqShaderMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setSqShaderMask( GpaSqShaderStageFlagsAMD sqShaderMask_ ) && VULKAN_HPP_NOEXCEPT + { + sqShaderMask = sqShaderMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setPerfCounterCount( uint32_t perfCounterCount_ ) & VULKAN_HPP_NOEXCEPT + { + perfCounterCount = perfCounterCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setPerfCounterCount( uint32_t perfCounterCount_ ) && VULKAN_HPP_NOEXCEPT + { + perfCounterCount = perfCounterCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setPPerfCounters( GpaPerfCounterAMD const * pPerfCounters_ ) & VULKAN_HPP_NOEXCEPT + { + pPerfCounters = pPerfCounters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setPPerfCounters( GpaPerfCounterAMD const * pPerfCounters_ ) && VULKAN_HPP_NOEXCEPT + { + pPerfCounters = pPerfCounters_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GpaSampleBeginInfoAMD & setPerfCounters( ArrayProxyNoTemporaries const & perfCounters_ ) VULKAN_HPP_NOEXCEPT + { + perfCounterCount = static_cast( perfCounters_.size() ); + pPerfCounters = perfCounters_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setStreamingPerfTraceSampleInterval( uint32_t streamingPerfTraceSampleInterval_ ) & VULKAN_HPP_NOEXCEPT + { + streamingPerfTraceSampleInterval = streamingPerfTraceSampleInterval_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setStreamingPerfTraceSampleInterval( uint32_t streamingPerfTraceSampleInterval_ ) && VULKAN_HPP_NOEXCEPT + { + streamingPerfTraceSampleInterval = streamingPerfTraceSampleInterval_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setPerfCounterDeviceMemoryLimit( DeviceSize perfCounterDeviceMemoryLimit_ ) & VULKAN_HPP_NOEXCEPT + { + perfCounterDeviceMemoryLimit = perfCounterDeviceMemoryLimit_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setPerfCounterDeviceMemoryLimit( DeviceSize perfCounterDeviceMemoryLimit_ ) && VULKAN_HPP_NOEXCEPT + { + perfCounterDeviceMemoryLimit = perfCounterDeviceMemoryLimit_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setSqThreadTraceEnable( Bool32 sqThreadTraceEnable_ ) & VULKAN_HPP_NOEXCEPT + { + sqThreadTraceEnable = sqThreadTraceEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setSqThreadTraceEnable( Bool32 sqThreadTraceEnable_ ) && VULKAN_HPP_NOEXCEPT + { + sqThreadTraceEnable = sqThreadTraceEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setSqThreadTraceSuppressInstructionTokens( Bool32 sqThreadTraceSuppressInstructionTokens_ ) & + VULKAN_HPP_NOEXCEPT + { + sqThreadTraceSuppressInstructionTokens = sqThreadTraceSuppressInstructionTokens_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setSqThreadTraceSuppressInstructionTokens( Bool32 sqThreadTraceSuppressInstructionTokens_ ) && + VULKAN_HPP_NOEXCEPT + { + sqThreadTraceSuppressInstructionTokens = sqThreadTraceSuppressInstructionTokens_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setSqThreadTraceDeviceMemoryLimit( DeviceSize sqThreadTraceDeviceMemoryLimit_ ) & VULKAN_HPP_NOEXCEPT + { + sqThreadTraceDeviceMemoryLimit = sqThreadTraceDeviceMemoryLimit_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setSqThreadTraceDeviceMemoryLimit( DeviceSize sqThreadTraceDeviceMemoryLimit_ ) && VULKAN_HPP_NOEXCEPT + { + sqThreadTraceDeviceMemoryLimit = sqThreadTraceDeviceMemoryLimit_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setTimingPreSample( PipelineStageFlags timingPreSample_ ) & VULKAN_HPP_NOEXCEPT + { + timingPreSample = timingPreSample_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setTimingPreSample( PipelineStageFlags timingPreSample_ ) && VULKAN_HPP_NOEXCEPT + { + timingPreSample = timingPreSample_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD & setTimingPostSample( PipelineStageFlags timingPostSample_ ) & VULKAN_HPP_NOEXCEPT + { + timingPostSample = timingPostSample_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSampleBeginInfoAMD && setTimingPostSample( PipelineStageFlags timingPostSample_ ) && VULKAN_HPP_NOEXCEPT + { + timingPostSample = timingPostSample_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGpaSampleBeginInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaSampleBeginInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaSampleBeginInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGpaSampleBeginInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + sampleType, + sampleInternalOperations, + cacheFlushOnCounterCollection, + sqShaderMaskEnable, + sqShaderMask, + perfCounterCount, + pPerfCounters, + streamingPerfTraceSampleInterval, + perfCounterDeviceMemoryLimit, + sqThreadTraceEnable, + sqThreadTraceSuppressInstructionTokens, + sqThreadTraceDeviceMemoryLimit, + timingPreSample, + timingPostSample ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GpaSampleBeginInfoAMD const & ) const = default; +#else + bool operator==( GpaSampleBeginInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleType == rhs.sampleType ) && + ( sampleInternalOperations == rhs.sampleInternalOperations ) && ( cacheFlushOnCounterCollection == rhs.cacheFlushOnCounterCollection ) && + ( sqShaderMaskEnable == rhs.sqShaderMaskEnable ) && ( sqShaderMask == rhs.sqShaderMask ) && ( perfCounterCount == rhs.perfCounterCount ) && + ( pPerfCounters == rhs.pPerfCounters ) && ( streamingPerfTraceSampleInterval == rhs.streamingPerfTraceSampleInterval ) && + ( perfCounterDeviceMemoryLimit == rhs.perfCounterDeviceMemoryLimit ) && ( sqThreadTraceEnable == rhs.sqThreadTraceEnable ) && + ( sqThreadTraceSuppressInstructionTokens == rhs.sqThreadTraceSuppressInstructionTokens ) && + ( sqThreadTraceDeviceMemoryLimit == rhs.sqThreadTraceDeviceMemoryLimit ) && ( timingPreSample == rhs.timingPreSample ) && + ( timingPostSample == rhs.timingPostSample ); +# endif + } + + bool operator!=( GpaSampleBeginInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGpaSampleBeginInfoAMD; + void const * pNext = {}; + GpaSampleTypeAMD sampleType = GpaSampleTypeAMD::eCumulative; + Bool32 sampleInternalOperations = {}; + Bool32 cacheFlushOnCounterCollection = {}; + Bool32 sqShaderMaskEnable = {}; + GpaSqShaderStageFlagsAMD sqShaderMask = {}; + uint32_t perfCounterCount = {}; + GpaPerfCounterAMD const * pPerfCounters = {}; + uint32_t streamingPerfTraceSampleInterval = {}; + DeviceSize perfCounterDeviceMemoryLimit = {}; + Bool32 sqThreadTraceEnable = {}; + Bool32 sqThreadTraceSuppressInstructionTokens = {}; + DeviceSize sqThreadTraceDeviceMemoryLimit = {}; + PipelineStageFlags timingPreSample = {}; + PipelineStageFlags timingPostSample = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GpaSampleBeginInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = GpaSampleBeginInfoAMD; + }; + + // wrapper struct for struct VkGpaSessionCreateInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGpaSessionCreateInfoAMD.html + struct GpaSessionCreateInfoAMD + { + using NativeType = VkGpaSessionCreateInfoAMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGpaSessionCreateInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GpaSessionCreateInfoAMD( GpaSessionAMD secondaryCopySource_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , secondaryCopySource{ secondaryCopySource_ } + { + } + + VULKAN_HPP_CONSTEXPR GpaSessionCreateInfoAMD( GpaSessionCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GpaSessionCreateInfoAMD( VkGpaSessionCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : GpaSessionCreateInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + GpaSessionCreateInfoAMD & operator=( GpaSessionCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GpaSessionCreateInfoAMD & operator=( VkGpaSessionCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GpaSessionCreateInfoAMD & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSessionCreateInfoAMD && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GpaSessionCreateInfoAMD & setSecondaryCopySource( GpaSessionAMD secondaryCopySource_ ) & VULKAN_HPP_NOEXCEPT + { + secondaryCopySource = secondaryCopySource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GpaSessionCreateInfoAMD && setSecondaryCopySource( GpaSessionAMD secondaryCopySource_ ) && VULKAN_HPP_NOEXCEPT + { + secondaryCopySource = secondaryCopySource_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGpaSessionCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaSessionCreateInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGpaSessionCreateInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGpaSessionCreateInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, secondaryCopySource ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GpaSessionCreateInfoAMD const & ) const = default; +#else + bool operator==( GpaSessionCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( secondaryCopySource == rhs.secondaryCopySource ); +# endif + } + + bool operator!=( GpaSessionCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGpaSessionCreateInfoAMD; + void const * pNext = {}; + GpaSessionAMD secondaryCopySource = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GpaSessionCreateInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = GpaSessionCreateInfoAMD; + }; + // wrapper struct for struct VkVertexInputBindingDescription, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputBindingDescription.html struct VertexInputBindingDescription @@ -92623,90 +94618,90 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = MicromapCreateInfoEXT; }; - // wrapper struct for struct VkMicromapTriangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTriangleEXT.html - struct MicromapTriangleEXT + // wrapper struct for struct VkMicromapTriangleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTriangleKHR.html + struct MicromapTriangleKHR { - using NativeType = VkMicromapTriangleEXT; + using NativeType = VkMicromapTriangleKHR; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MicromapTriangleEXT( uint32_t dataOffset_ = {}, uint16_t subdivisionLevel_ = {}, uint16_t format_ = {} ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR MicromapTriangleKHR( uint32_t dataOffset_ = {}, uint16_t subdivisionLevel_ = {}, uint16_t format_ = {} ) VULKAN_HPP_NOEXCEPT : dataOffset{ dataOffset_ } , subdivisionLevel{ subdivisionLevel_ } , format{ format_ } { } - VULKAN_HPP_CONSTEXPR MicromapTriangleEXT( MicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR MicromapTriangleKHR( MicromapTriangleKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - MicromapTriangleEXT( VkMicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapTriangleEXT( *reinterpret_cast( &rhs ) ) + MicromapTriangleKHR( VkMicromapTriangleKHR const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapTriangleKHR( *reinterpret_cast( &rhs ) ) { } - MicromapTriangleEXT & operator=( MicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + MicromapTriangleKHR & operator=( MicromapTriangleKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - MicromapTriangleEXT & operator=( VkMicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT + MicromapTriangleKHR & operator=( VkMicromapTriangleKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } #if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setDataOffset( uint32_t dataOffset_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleKHR & setDataOffset( uint32_t dataOffset_ ) & VULKAN_HPP_NOEXCEPT { dataOffset = dataOffset_; return *this; } - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setDataOffset( uint32_t dataOffset_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleKHR && setDataOffset( uint32_t dataOffset_ ) && VULKAN_HPP_NOEXCEPT { dataOffset = dataOffset_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setSubdivisionLevel( uint16_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleKHR & setSubdivisionLevel( uint16_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT { subdivisionLevel = subdivisionLevel_; return *this; } - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setSubdivisionLevel( uint16_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleKHR && setSubdivisionLevel( uint16_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT { subdivisionLevel = subdivisionLevel_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setFormat( uint16_t format_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleKHR & setFormat( uint16_t format_ ) & VULKAN_HPP_NOEXCEPT { format = format_; return *this; } - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setFormat( uint16_t format_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleKHR && setFormat( uint16_t format_ ) && VULKAN_HPP_NOEXCEPT { format = format_; return std::move( *this ); } #endif /*VULKAN_HPP_NO_SETTERS*/ - operator VkMicromapTriangleEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkMicromapTriangleKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkMicromapTriangleEXT &() VULKAN_HPP_NOEXCEPT + operator VkMicromapTriangleKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkMicromapTriangleEXT const *() const VULKAN_HPP_NOEXCEPT + operator VkMicromapTriangleKHR const *() const VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } - operator VkMicromapTriangleEXT *() VULKAN_HPP_NOEXCEPT + operator VkMicromapTriangleKHR *() VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } #if defined( VULKAN_HPP_USE_REFLECT ) @@ -92717,9 +94712,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MicromapTriangleEXT const & ) const = default; + auto operator<=>( MicromapTriangleKHR const & ) const = default; #else - bool operator==( MicromapTriangleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( MicromapTriangleKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); @@ -92728,7 +94723,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE # endif } - bool operator!=( MicromapTriangleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( MicromapTriangleKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } @@ -92742,11 +94737,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if 20 <= VULKAN_HPP_CPP_VERSION template <> - struct CppType + struct CppType { - using Type = MicromapTriangleEXT; + using Type = MicromapTriangleKHR; }; #endif + using MicromapTriangleEXT = MicromapTriangleKHR; // wrapper struct for struct VkMicromapVersionInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapVersionInfoEXT.html struct MicromapVersionInfoEXT @@ -105381,6 +107377,139 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDataGraphModelFeaturesQCOM; }; + // wrapper struct for struct VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM.html + struct PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM + { + using NativeType = VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM( Bool32 dataGraphNeuralAcceleratorStatistics_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataGraphNeuralAcceleratorStatistics{ dataGraphNeuralAcceleratorStatistics_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM( + PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM( VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & rhs ) + VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM & + operator=( PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM & + operator=( VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM & + setDataGraphNeuralAcceleratorStatistics( Bool32 dataGraphNeuralAcceleratorStatistics_ ) & + VULKAN_HPP_NOEXCEPT + { + dataGraphNeuralAcceleratorStatistics = dataGraphNeuralAcceleratorStatistics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM && + setDataGraphNeuralAcceleratorStatistics( Bool32 dataGraphNeuralAcceleratorStatistics_ ) && + VULKAN_HPP_NOEXCEPT + { + dataGraphNeuralAcceleratorStatistics = dataGraphNeuralAcceleratorStatistics_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataGraphNeuralAcceleratorStatistics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphNeuralAcceleratorStatistics == rhs.dataGraphNeuralAcceleratorStatistics ); +# endif + } + + bool operator!=( PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + void * pNext = {}; + Bool32 dataGraphNeuralAcceleratorStatistics = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM; + }; + // wrapper struct for struct VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM.html struct PhysicalDeviceDataGraphOpticalFlowFeaturesARM @@ -110986,6 +113115,129 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; }; + // wrapper struct for struct VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM.html + struct PhysicalDeviceElapsedTimerQueryFeaturesQCOM + { + using NativeType = VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceElapsedTimerQueryFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceElapsedTimerQueryFeaturesQCOM( Bool32 elapsedTimerQuery_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , elapsedTimerQuery{ elapsedTimerQuery_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceElapsedTimerQueryFeaturesQCOM( PhysicalDeviceElapsedTimerQueryFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceElapsedTimerQueryFeaturesQCOM( VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceElapsedTimerQueryFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceElapsedTimerQueryFeaturesQCOM & operator=( PhysicalDeviceElapsedTimerQueryFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceElapsedTimerQueryFeaturesQCOM & operator=( VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceElapsedTimerQueryFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceElapsedTimerQueryFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceElapsedTimerQueryFeaturesQCOM & setElapsedTimerQuery( Bool32 elapsedTimerQuery_ ) & VULKAN_HPP_NOEXCEPT + { + elapsedTimerQuery = elapsedTimerQuery_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceElapsedTimerQueryFeaturesQCOM && setElapsedTimerQuery( Bool32 elapsedTimerQuery_ ) && VULKAN_HPP_NOEXCEPT + { + elapsedTimerQuery = elapsedTimerQuery_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, elapsedTimerQuery ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceElapsedTimerQueryFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceElapsedTimerQueryFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( elapsedTimerQuery == rhs.elapsedTimerQuery ); +# endif + } + + bool operator!=( PhysicalDeviceElapsedTimerQueryFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceElapsedTimerQueryFeaturesQCOM; + void * pNext = {}; + Bool32 elapsedTimerQuery = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceElapsedTimerQueryFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceElapsedTimerQueryFeaturesQCOM; + }; + // wrapper struct for struct VkPhysicalDeviceExclusiveScissorFeaturesNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html struct PhysicalDeviceExclusiveScissorFeaturesNV @@ -117093,6 +119345,390 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures; using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures; + // wrapper struct for struct VkPhysicalDeviceGpaFeaturesAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGpaFeaturesAMD.html + struct PhysicalDeviceGpaFeaturesAMD + { + using NativeType = VkPhysicalDeviceGpaFeaturesAMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGpaFeaturesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceGpaFeaturesAMD( Bool32 perfCounters_ = {}, + Bool32 streamingPerfCounters_ = {}, + Bool32 sqThreadTracing_ = {}, + Bool32 clockModes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , perfCounters{ perfCounters_ } + , streamingPerfCounters{ streamingPerfCounters_ } + , sqThreadTracing{ sqThreadTracing_ } + , clockModes{ clockModes_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceGpaFeaturesAMD( PhysicalDeviceGpaFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceGpaFeaturesAMD( VkPhysicalDeviceGpaFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceGpaFeaturesAMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceGpaFeaturesAMD & operator=( PhysicalDeviceGpaFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceGpaFeaturesAMD & operator=( VkPhysicalDeviceGpaFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD & setPerfCounters( Bool32 perfCounters_ ) & VULKAN_HPP_NOEXCEPT + { + perfCounters = perfCounters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD && setPerfCounters( Bool32 perfCounters_ ) && VULKAN_HPP_NOEXCEPT + { + perfCounters = perfCounters_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD & setStreamingPerfCounters( Bool32 streamingPerfCounters_ ) & VULKAN_HPP_NOEXCEPT + { + streamingPerfCounters = streamingPerfCounters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD && setStreamingPerfCounters( Bool32 streamingPerfCounters_ ) && VULKAN_HPP_NOEXCEPT + { + streamingPerfCounters = streamingPerfCounters_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD & setSqThreadTracing( Bool32 sqThreadTracing_ ) & VULKAN_HPP_NOEXCEPT + { + sqThreadTracing = sqThreadTracing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD && setSqThreadTracing( Bool32 sqThreadTracing_ ) && VULKAN_HPP_NOEXCEPT + { + sqThreadTracing = sqThreadTracing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD & setClockModes( Bool32 clockModes_ ) & VULKAN_HPP_NOEXCEPT + { + clockModes = clockModes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGpaFeaturesAMD && setClockModes( Bool32 clockModes_ ) && VULKAN_HPP_NOEXCEPT + { + clockModes = clockModes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceGpaFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaFeaturesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaFeaturesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaFeaturesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perfCounters, streamingPerfCounters, sqThreadTracing, clockModes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceGpaFeaturesAMD const & ) const = default; +#else + bool operator==( PhysicalDeviceGpaFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perfCounters == rhs.perfCounters ) && + ( streamingPerfCounters == rhs.streamingPerfCounters ) && ( sqThreadTracing == rhs.sqThreadTracing ) && ( clockModes == rhs.clockModes ); +# endif + } + + bool operator!=( PhysicalDeviceGpaFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceGpaFeaturesAMD; + void * pNext = {}; + Bool32 perfCounters = {}; + Bool32 streamingPerfCounters = {}; + Bool32 sqThreadTracing = {}; + Bool32 clockModes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceGpaFeaturesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceGpaFeaturesAMD; + }; + + // wrapper struct for struct VkPhysicalDeviceGpaProperties2AMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGpaProperties2AMD.html + struct PhysicalDeviceGpaProperties2AMD + { + using NativeType = VkPhysicalDeviceGpaProperties2AMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGpaProperties2AMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceGpaProperties2AMD( uint32_t revisionId_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , revisionId{ revisionId_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceGpaProperties2AMD( PhysicalDeviceGpaProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceGpaProperties2AMD( VkPhysicalDeviceGpaProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceGpaProperties2AMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceGpaProperties2AMD & operator=( PhysicalDeviceGpaProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceGpaProperties2AMD & operator=( VkPhysicalDeviceGpaProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceGpaProperties2AMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaProperties2AMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaProperties2AMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaProperties2AMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, revisionId ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceGpaProperties2AMD const & ) const = default; +#else + bool operator==( PhysicalDeviceGpaProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( revisionId == rhs.revisionId ); +# endif + } + + bool operator!=( PhysicalDeviceGpaProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceGpaProperties2AMD; + void * pNext = {}; + uint32_t revisionId = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceGpaProperties2AMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceGpaProperties2AMD; + }; + + // wrapper struct for struct VkPhysicalDeviceGpaPropertiesAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGpaPropertiesAMD.html + struct PhysicalDeviceGpaPropertiesAMD + { + using NativeType = VkPhysicalDeviceGpaPropertiesAMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGpaPropertiesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceGpaPropertiesAMD( PhysicalDeviceGpaPropertiesFlagsAMD flags_ = {}, + DeviceSize maxSqttSeBufferSize_ = {}, + uint32_t shaderEngineCount_ = {}, + uint32_t perfBlockCount_ = {}, + GpaPerfBlockPropertiesAMD * pPerfBlocks_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , maxSqttSeBufferSize{ maxSqttSeBufferSize_ } + , shaderEngineCount{ shaderEngineCount_ } + , perfBlockCount{ perfBlockCount_ } + , pPerfBlocks{ pPerfBlocks_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceGpaPropertiesAMD( PhysicalDeviceGpaPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceGpaPropertiesAMD( VkPhysicalDeviceGpaPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceGpaPropertiesAMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceGpaPropertiesAMD & operator=( PhysicalDeviceGpaPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceGpaPropertiesAMD & operator=( VkPhysicalDeviceGpaPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceGpaPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaPropertiesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaPropertiesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGpaPropertiesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, maxSqttSeBufferSize, shaderEngineCount, perfBlockCount, pPerfBlocks ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceGpaPropertiesAMD const & ) const = default; +#else + bool operator==( PhysicalDeviceGpaPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSqttSeBufferSize == rhs.maxSqttSeBufferSize ) && + ( shaderEngineCount == rhs.shaderEngineCount ) && ( perfBlockCount == rhs.perfBlockCount ) && ( pPerfBlocks == rhs.pPerfBlocks ); +# endif + } + + bool operator!=( PhysicalDeviceGpaPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceGpaPropertiesAMD; + void * pNext = {}; + PhysicalDeviceGpaPropertiesFlagsAMD flags = {}; + DeviceSize maxSqttSeBufferSize = {}; + uint32_t shaderEngineCount = {}; + uint32_t perfBlockCount = {}; + GpaPerfBlockPropertiesAMD * pPerfBlocks = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceGpaPropertiesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceGpaPropertiesAMD; + }; + // wrapper struct for struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.html struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT @@ -119418,6 +122054,163 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceImageProcessing2PropertiesQCOM; }; + // wrapper struct for struct VkPhysicalDeviceImageProcessing3FeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessing3FeaturesQCOM.html + struct PhysicalDeviceImageProcessing3FeaturesQCOM + { + using NativeType = VkPhysicalDeviceImageProcessing3FeaturesQCOM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessing3FeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing3FeaturesQCOM( Bool32 imageGatherLinear_ = {}, + Bool32 imageGatherExtendedModes_ = {}, + Bool32 blockMatchExtendedClampToEdge_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageGatherLinear{ imageGatherLinear_ } + , imageGatherExtendedModes{ imageGatherExtendedModes_ } + , blockMatchExtendedClampToEdge{ blockMatchExtendedClampToEdge_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing3FeaturesQCOM( PhysicalDeviceImageProcessing3FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageProcessing3FeaturesQCOM( VkPhysicalDeviceImageProcessing3FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageProcessing3FeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageProcessing3FeaturesQCOM & operator=( PhysicalDeviceImageProcessing3FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageProcessing3FeaturesQCOM & operator=( VkPhysicalDeviceImageProcessing3FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM & setImageGatherLinear( Bool32 imageGatherLinear_ ) & VULKAN_HPP_NOEXCEPT + { + imageGatherLinear = imageGatherLinear_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM && setImageGatherLinear( Bool32 imageGatherLinear_ ) && VULKAN_HPP_NOEXCEPT + { + imageGatherLinear = imageGatherLinear_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM & setImageGatherExtendedModes( Bool32 imageGatherExtendedModes_ ) & VULKAN_HPP_NOEXCEPT + { + imageGatherExtendedModes = imageGatherExtendedModes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM && setImageGatherExtendedModes( Bool32 imageGatherExtendedModes_ ) && VULKAN_HPP_NOEXCEPT + { + imageGatherExtendedModes = imageGatherExtendedModes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM & setBlockMatchExtendedClampToEdge( Bool32 blockMatchExtendedClampToEdge_ ) & + VULKAN_HPP_NOEXCEPT + { + blockMatchExtendedClampToEdge = blockMatchExtendedClampToEdge_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing3FeaturesQCOM && setBlockMatchExtendedClampToEdge( Bool32 blockMatchExtendedClampToEdge_ ) && + VULKAN_HPP_NOEXCEPT + { + blockMatchExtendedClampToEdge = blockMatchExtendedClampToEdge_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageProcessing3FeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing3FeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing3FeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing3FeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageGatherLinear, imageGatherExtendedModes, blockMatchExtendedClampToEdge ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageProcessing3FeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceImageProcessing3FeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageGatherLinear == rhs.imageGatherLinear ) && + ( imageGatherExtendedModes == rhs.imageGatherExtendedModes ) && ( blockMatchExtendedClampToEdge == rhs.blockMatchExtendedClampToEdge ); +# endif + } + + bool operator!=( PhysicalDeviceImageProcessing3FeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageProcessing3FeaturesQCOM; + void * pNext = {}; + Bool32 imageGatherLinear = {}; + Bool32 imageGatherExtendedModes = {}; + Bool32 blockMatchExtendedClampToEdge = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessing3FeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessing3FeaturesQCOM; + }; + // wrapper struct for struct VkPhysicalDeviceImageProcessingFeaturesQCOM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessingFeaturesQCOM.html struct PhysicalDeviceImageProcessingFeaturesQCOM @@ -123561,6 +126354,129 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMaintenance10PropertiesKHR; }; + // wrapper struct for struct VkPhysicalDeviceMaintenance11FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance11FeaturesKHR.html + struct PhysicalDeviceMaintenance11FeaturesKHR + { + using NativeType = VkPhysicalDeviceMaintenance11FeaturesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance11FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance11FeaturesKHR( Bool32 maintenance11_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance11{ maintenance11_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance11FeaturesKHR( PhysicalDeviceMaintenance11FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance11FeaturesKHR( VkPhysicalDeviceMaintenance11FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance11FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance11FeaturesKHR & operator=( PhysicalDeviceMaintenance11FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance11FeaturesKHR & operator=( VkPhysicalDeviceMaintenance11FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance11FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance11FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance11FeaturesKHR & setMaintenance11( Bool32 maintenance11_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance11 = maintenance11_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance11FeaturesKHR && setMaintenance11( Bool32 maintenance11_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance11 = maintenance11_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance11FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance11FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance11FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance11FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance11 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance11FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance11FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance11 == rhs.maintenance11 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance11FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance11FeaturesKHR; + void * pNext = {}; + Bool32 maintenance11 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance11FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance11FeaturesKHR; + }; + // wrapper struct for struct VkPhysicalDeviceMaintenance3Properties, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance3Properties.html struct PhysicalDeviceMaintenance3Properties @@ -128300,6 +131216,129 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceOpacityMicromapFeaturesEXT; }; + // wrapper struct for struct VkPhysicalDeviceOpacityMicromapFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapFeaturesKHR.html + struct PhysicalDeviceOpacityMicromapFeaturesKHR + { + using NativeType = VkPhysicalDeviceOpacityMicromapFeaturesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpacityMicromapFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapFeaturesKHR( Bool32 micromap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , micromap{ micromap_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapFeaturesKHR( PhysicalDeviceOpacityMicromapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceOpacityMicromapFeaturesKHR( VkPhysicalDeviceOpacityMicromapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceOpacityMicromapFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceOpacityMicromapFeaturesKHR & operator=( PhysicalDeviceOpacityMicromapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceOpacityMicromapFeaturesKHR & operator=( VkPhysicalDeviceOpacityMicromapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesKHR & setMicromap( Bool32 micromap_ ) & VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesKHR && setMicromap( Bool32 micromap_ ) && VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceOpacityMicromapFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, micromap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceOpacityMicromapFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceOpacityMicromapFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( micromap == rhs.micromap ); +# endif + } + + bool operator!=( PhysicalDeviceOpacityMicromapFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceOpacityMicromapFeaturesKHR; + void * pNext = {}; + Bool32 micromap = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapFeaturesKHR; + }; + // wrapper struct for struct VkPhysicalDeviceOpacityMicromapPropertiesEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapPropertiesEXT.html struct PhysicalDeviceOpacityMicromapPropertiesEXT @@ -128402,6 +131441,117 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceOpacityMicromapPropertiesEXT; }; + // wrapper struct for struct VkPhysicalDeviceOpacityMicromapPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapPropertiesKHR.html + struct PhysicalDeviceOpacityMicromapPropertiesKHR + { + using NativeType = VkPhysicalDeviceOpacityMicromapPropertiesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpacityMicromapPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapPropertiesKHR( uint32_t maxOpacity2StateSubdivisionLevel_ = {}, + uint32_t maxOpacity4StateSubdivisionLevel_ = {}, + uint32_t maxOpacityLossy4StateSubdivisionLevel_ = {}, + uint64_t maxMicromapTriangles_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxOpacity2StateSubdivisionLevel{ maxOpacity2StateSubdivisionLevel_ } + , maxOpacity4StateSubdivisionLevel{ maxOpacity4StateSubdivisionLevel_ } + , maxOpacityLossy4StateSubdivisionLevel{ maxOpacityLossy4StateSubdivisionLevel_ } + , maxMicromapTriangles{ maxMicromapTriangles_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapPropertiesKHR( PhysicalDeviceOpacityMicromapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceOpacityMicromapPropertiesKHR( VkPhysicalDeviceOpacityMicromapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceOpacityMicromapPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceOpacityMicromapPropertiesKHR & operator=( PhysicalDeviceOpacityMicromapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceOpacityMicromapPropertiesKHR & operator=( VkPhysicalDeviceOpacityMicromapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, maxOpacity2StateSubdivisionLevel, maxOpacity4StateSubdivisionLevel, maxOpacityLossy4StateSubdivisionLevel, maxMicromapTriangles ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceOpacityMicromapPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceOpacityMicromapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxOpacity2StateSubdivisionLevel == rhs.maxOpacity2StateSubdivisionLevel ) && + ( maxOpacity4StateSubdivisionLevel == rhs.maxOpacity4StateSubdivisionLevel ) && + ( maxOpacityLossy4StateSubdivisionLevel == rhs.maxOpacityLossy4StateSubdivisionLevel ) && ( maxMicromapTriangles == rhs.maxMicromapTriangles ); +# endif + } + + bool operator!=( PhysicalDeviceOpacityMicromapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceOpacityMicromapPropertiesKHR; + void * pNext = {}; + uint32_t maxOpacity2StateSubdivisionLevel = {}; + uint32_t maxOpacity4StateSubdivisionLevel = {}; + uint32_t maxOpacityLossy4StateSubdivisionLevel = {}; + uint64_t maxMicromapTriangles = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapPropertiesKHR; + }; + // wrapper struct for struct VkPhysicalDeviceOpticalFlowFeaturesNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpticalFlowFeaturesNV.html struct PhysicalDeviceOpticalFlowFeaturesNV @@ -143890,6 +147040,233 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; }; + // wrapper struct for struct VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM.html + struct PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM + { + using NativeType = VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM( Bool32 shaderMultipleWaitQueues_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderMultipleWaitQueues{ shaderMultipleWaitQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM( PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM( VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM & + operator=( PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM & operator=( VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM & setShaderMultipleWaitQueues( Bool32 shaderMultipleWaitQueues_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderMultipleWaitQueues = shaderMultipleWaitQueues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM && setShaderMultipleWaitQueues( Bool32 shaderMultipleWaitQueues_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderMultipleWaitQueues = shaderMultipleWaitQueues_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderMultipleWaitQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderMultipleWaitQueues == rhs.shaderMultipleWaitQueues ); +# endif + } + + bool operator!=( PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + void * pNext = {}; + Bool32 shaderMultipleWaitQueues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM.html + struct PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM + { + using NativeType = VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( uint32_t maxShaderWaitQueues_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxShaderWaitQueues{ maxShaderWaitQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM & + operator=( PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM & operator=( VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxShaderWaitQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxShaderWaitQueues == rhs.maxShaderWaitQueues ); +# endif + } + + bool operator!=( PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + void * pNext = {}; + uint32_t maxShaderWaitQueues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + }; + // wrapper struct for struct VkPhysicalDeviceShaderObjectFeaturesEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderObjectFeaturesEXT.html struct PhysicalDeviceShaderObjectFeaturesEXT @@ -144721,6 +148098,228 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; }; + // wrapper struct for struct VkPhysicalDeviceShaderSplitBarrierFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSplitBarrierFeaturesEXT.html + struct PhysicalDeviceShaderSplitBarrierFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderSplitBarrierFeaturesEXT; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSplitBarrierFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSplitBarrierFeaturesEXT( Bool32 shaderSplitBarrier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSplitBarrier{ shaderSplitBarrier_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSplitBarrierFeaturesEXT( PhysicalDeviceShaderSplitBarrierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSplitBarrierFeaturesEXT( VkPhysicalDeviceShaderSplitBarrierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSplitBarrierFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSplitBarrierFeaturesEXT & operator=( PhysicalDeviceShaderSplitBarrierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSplitBarrierFeaturesEXT & operator=( VkPhysicalDeviceShaderSplitBarrierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSplitBarrierFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSplitBarrierFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSplitBarrierFeaturesEXT & setShaderSplitBarrier( Bool32 shaderSplitBarrier_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSplitBarrier = shaderSplitBarrier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSplitBarrierFeaturesEXT && setShaderSplitBarrier( Bool32 shaderSplitBarrier_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSplitBarrier = shaderSplitBarrier_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderSplitBarrierFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSplitBarrierFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSplitBarrierFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSplitBarrier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSplitBarrierFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSplitBarrierFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSplitBarrier == rhs.shaderSplitBarrier ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSplitBarrierFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSplitBarrierFeaturesEXT; + void * pNext = {}; + Bool32 shaderSplitBarrier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSplitBarrierFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSplitBarrierFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderSplitBarrierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSplitBarrierPropertiesEXT.html + struct PhysicalDeviceShaderSplitBarrierPropertiesEXT + { + using NativeType = VkPhysicalDeviceShaderSplitBarrierPropertiesEXT; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSplitBarrierPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSplitBarrierPropertiesEXT( uint32_t splitBarrierReservedSharedMemory_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , splitBarrierReservedSharedMemory{ splitBarrierReservedSharedMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderSplitBarrierPropertiesEXT( PhysicalDeviceShaderSplitBarrierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSplitBarrierPropertiesEXT( VkPhysicalDeviceShaderSplitBarrierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSplitBarrierPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSplitBarrierPropertiesEXT & operator=( PhysicalDeviceShaderSplitBarrierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSplitBarrierPropertiesEXT & operator=( VkPhysicalDeviceShaderSplitBarrierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderSplitBarrierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSplitBarrierPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSplitBarrierPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, splitBarrierReservedSharedMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSplitBarrierPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSplitBarrierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( splitBarrierReservedSharedMemory == rhs.splitBarrierReservedSharedMemory ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSplitBarrierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSplitBarrierPropertiesEXT; + void * pNext = {}; + uint32_t splitBarrierReservedSharedMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSplitBarrierPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSplitBarrierPropertiesEXT; + }; + // wrapper struct for struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures @@ -148319,6 +151918,129 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures; + // wrapper struct for struct VkPhysicalDeviceThrottleHintFeaturesSEC, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceThrottleHintFeaturesSEC.html + struct PhysicalDeviceThrottleHintFeaturesSEC + { + using NativeType = VkPhysicalDeviceThrottleHintFeaturesSEC; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceThrottleHintFeaturesSEC; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceThrottleHintFeaturesSEC( Bool32 throttleHint_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , throttleHint{ throttleHint_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceThrottleHintFeaturesSEC( PhysicalDeviceThrottleHintFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceThrottleHintFeaturesSEC( VkPhysicalDeviceThrottleHintFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceThrottleHintFeaturesSEC( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceThrottleHintFeaturesSEC & operator=( PhysicalDeviceThrottleHintFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceThrottleHintFeaturesSEC & operator=( VkPhysicalDeviceThrottleHintFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceThrottleHintFeaturesSEC & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceThrottleHintFeaturesSEC && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceThrottleHintFeaturesSEC & setThrottleHint( Bool32 throttleHint_ ) & VULKAN_HPP_NOEXCEPT + { + throttleHint = throttleHint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceThrottleHintFeaturesSEC && setThrottleHint( Bool32 throttleHint_ ) && VULKAN_HPP_NOEXCEPT + { + throttleHint = throttleHint_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceThrottleHintFeaturesSEC const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceThrottleHintFeaturesSEC &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceThrottleHintFeaturesSEC const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceThrottleHintFeaturesSEC *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, throttleHint ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceThrottleHintFeaturesSEC const & ) const = default; +#else + bool operator==( PhysicalDeviceThrottleHintFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( throttleHint == rhs.throttleHint ); +# endif + } + + bool operator!=( PhysicalDeviceThrottleHintFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceThrottleHintFeaturesSEC; + void * pNext = {}; + Bool32 throttleHint = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceThrottleHintFeaturesSEC; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceThrottleHintFeaturesSEC; + }; + // wrapper struct for struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.html struct PhysicalDeviceTileMemoryHeapFeaturesQCOM @@ -170278,6 +174000,107 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties; using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties; + // wrapper struct for struct VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR.html + struct QueueFamilyOptimalImageTransferGranularityPropertiesKHR + { + using NativeType = VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyOptimalImageTransferGranularityPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyOptimalImageTransferGranularityPropertiesKHR( Extent3D optimalImageTransferGranularity_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , optimalImageTransferGranularity{ optimalImageTransferGranularity_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyOptimalImageTransferGranularityPropertiesKHR( QueueFamilyOptimalImageTransferGranularityPropertiesKHR const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyOptimalImageTransferGranularityPropertiesKHR( VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyOptimalImageTransferGranularityPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyOptimalImageTransferGranularityPropertiesKHR & + operator=( QueueFamilyOptimalImageTransferGranularityPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyOptimalImageTransferGranularityPropertiesKHR & + operator=( VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyOptimalImageTransferGranularityPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, optimalImageTransferGranularity ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyOptimalImageTransferGranularityPropertiesKHR const & ) const = default; +#else + bool operator==( QueueFamilyOptimalImageTransferGranularityPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalImageTransferGranularity == rhs.optimalImageTransferGranularity ); +# endif + } + + bool operator!=( QueueFamilyOptimalImageTransferGranularityPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyOptimalImageTransferGranularityPropertiesKHR; + void * pNext = {}; + Extent3D optimalImageTransferGranularity = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyOptimalImageTransferGranularityPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyOptimalImageTransferGranularityPropertiesKHR; + }; + // wrapper struct for struct VkQueueFamilyOwnershipTransferPropertiesKHR, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyOwnershipTransferPropertiesKHR.html struct QueueFamilyOwnershipTransferPropertiesKHR @@ -191918,6 +195741,129 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = TextureLODGatherFormatPropertiesAMD; }; + // wrapper struct for struct VkThrottleHintSubmitInfoSEC, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkThrottleHintSubmitInfoSEC.html + struct ThrottleHintSubmitInfoSEC + { + using NativeType = VkThrottleHintSubmitInfoSEC; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eThrottleHintSubmitInfoSEC; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ThrottleHintSubmitInfoSEC( ThrottleHintTypeSEC throttleHint_ = ThrottleHintTypeSEC::eDefault, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , throttleHint{ throttleHint_ } + { + } + + VULKAN_HPP_CONSTEXPR ThrottleHintSubmitInfoSEC( ThrottleHintSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ThrottleHintSubmitInfoSEC( VkThrottleHintSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT + : ThrottleHintSubmitInfoSEC( *reinterpret_cast( &rhs ) ) + { + } + + ThrottleHintSubmitInfoSEC & operator=( ThrottleHintSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ThrottleHintSubmitInfoSEC & operator=( VkThrottleHintSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ThrottleHintSubmitInfoSEC & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ThrottleHintSubmitInfoSEC && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ThrottleHintSubmitInfoSEC & setThrottleHint( ThrottleHintTypeSEC throttleHint_ ) & VULKAN_HPP_NOEXCEPT + { + throttleHint = throttleHint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ThrottleHintSubmitInfoSEC && setThrottleHint( ThrottleHintTypeSEC throttleHint_ ) && VULKAN_HPP_NOEXCEPT + { + throttleHint = throttleHint_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkThrottleHintSubmitInfoSEC const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkThrottleHintSubmitInfoSEC &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkThrottleHintSubmitInfoSEC const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkThrottleHintSubmitInfoSEC *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, throttleHint ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ThrottleHintSubmitInfoSEC const & ) const = default; +#else + bool operator==( ThrottleHintSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( throttleHint == rhs.throttleHint ); +# endif + } + + bool operator!=( ThrottleHintSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eThrottleHintSubmitInfoSEC; + void const * pNext = {}; + ThrottleHintTypeSEC throttleHint = ThrottleHintTypeSEC::eDefault; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ThrottleHintSubmitInfoSEC; + }; +#endif + + template <> + struct CppType + { + using Type = ThrottleHintSubmitInfoSEC; + }; + // wrapper struct for struct VkTileMemoryBindInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryBindInfoQCOM.html struct TileMemoryBindInfoQCOM { diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index 72fff97..b23a3c9 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -156,6 +156,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " VideoProfileIndependentKHR |"; if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetEXT ) result += " FragmentDensityMapOffsetEXT |"; + if ( value & ImageCreateFlagBits::eAliasSingleLayerDescriptorKHR ) + result += " AliasSingleLayerDescriptorKHR |"; if ( result.size() > 1 ) result.back() = '}'; @@ -1004,12 +1006,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " ColorAttachmentFeedbackLoopEXT |"; if ( value & PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT ) result += " DepthStencilAttachmentFeedbackLoopEXT |"; - if ( value & PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT ) - result += " RayTracingOpacityMicromapEXT |"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) if ( value & PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV ) result += " RayTracingDisplacementMicromapNV |"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + if ( value & PipelineCreateFlagBits::eRayTracingOpacityMicromapKHR ) + result += " RayTracingOpacityMicromapKHR |"; if ( result.size() > 1 ) result.back() = '}'; @@ -1023,6 +1025,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE std::string result = "{"; if ( value & PipelineLayoutCreateFlagBits::eIndependentSetsEXT ) result += " IndependentSetsEXT |"; + if ( value & PipelineLayoutCreateFlagBits::eNoTaskShaderKHR ) + result += " NoTaskShaderKHR |"; if ( result.size() > 1 ) result.back() = '}'; @@ -1950,6 +1954,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " VideoEncodeInputKHR |"; if ( value & FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) result += " VideoEncodeDpbKHR |"; + if ( value & FormatFeatureFlagBits2::eBlockMatchingSxdQCOM ) + result += " BlockMatchingSxdQCOM |"; if ( value & FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV ) result += " AccelerationStructureRadiusBufferNV |"; if ( value & FormatFeatureFlagBits2::eLinearColorAttachmentNV ) @@ -2092,6 +2098,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #endif /*VK_ENABLE_BETA_EXTENSIONS*/ if ( value & BufferUsageFlagBits2::eDescriptorHeapEXT ) result += " DescriptorHeapEXT |"; + if ( value & BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT ) + result += " MicromapBuildInputReadOnlyEXT |"; + if ( value & BufferUsageFlagBits2::eMicromapStorageEXT ) + result += " MicromapStorageEXT |"; if ( value & BufferUsageFlagBits2::eConditionalRenderingEXT ) result += " ConditionalRenderingEXT |"; if ( value & BufferUsageFlagBits2::eShaderBindingTableKHR ) @@ -2118,10 +2128,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " ResourceDescriptorBufferEXT |"; if ( value & BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT ) result += " PushDescriptorsDescriptorBufferEXT |"; - if ( value & BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT ) - result += " MicromapBuildInputReadOnlyEXT |"; - if ( value & BufferUsageFlagBits2::eMicromapStorageEXT ) - result += " MicromapStorageEXT |"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) if ( value & BufferUsageFlagBits2::eCompressedDataDgf1AMDX ) result += " CompressedDataDgf1AMDX |"; @@ -2220,8 +2226,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " RenderingFragmentShadingRateAttachmentKHR |"; if ( value & PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT ) result += " RenderingFragmentDensityMapAttachmentEXT |"; - if ( value & PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT ) - result += " RayTracingOpacityMicromapEXT |"; if ( value & PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT ) result += " ColorAttachmentFeedbackLoopEXT |"; if ( value & PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT ) @@ -2242,6 +2246,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " IndirectBindableEXT |"; if ( value & PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE ) result += " PerLayerFragmentDensityVALVE |"; + if ( value & PipelineCreateFlagBits2::eRayTracingOpacityMicromapKHR ) + result += " RayTracingOpacityMicromapKHR |"; + if ( value & PipelineCreateFlagBits2::eOpacityMicromapDisallowMixedSpecialIndexKHR ) + result += " OpacityMicromapDisallowMixedSpecialIndexKHR |"; if ( value & PipelineCreateFlagBits2::e64BitIndexingEXT ) result += " 64BitIndexingEXT |"; @@ -3109,6 +3117,43 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return "{}"; } + //=== VK_AMD_gpa_interface === + + VULKAN_HPP_INLINE std::string to_string( GpaSqShaderStageFlagsAMD value ) + { + std::string result = "{"; + if ( value & GpaSqShaderStageFlagBitsAMD::ePs ) + result += " Ps |"; + if ( value & GpaSqShaderStageFlagBitsAMD::eVs ) + result += " Vs |"; + if ( value & GpaSqShaderStageFlagBitsAMD::eGs ) + result += " Gs |"; + if ( value & GpaSqShaderStageFlagBitsAMD::eEs ) + result += " Es |"; + if ( value & GpaSqShaderStageFlagBitsAMD::eHs ) + result += " Hs |"; + if ( value & GpaSqShaderStageFlagBitsAMD::eLs ) + result += " Ls |"; + if ( value & GpaSqShaderStageFlagBitsAMD::eCs ) + result += " Cs |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GpaPerfBlockPropertiesFlagsAMD ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceGpaPropertiesFlagsAMD ) + { + return "{}"; + } + //=== VK_EXT_descriptor_heap === VULKAN_HPP_INLINE std::string to_string( SpirvResourceTypeFlagsEXT value ) @@ -3190,10 +3235,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " ForceOpaque |"; if ( value & GeometryInstanceFlagBitsKHR::eForceNoOpaque ) result += " ForceNoOpaque |"; - if ( value & GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT ) - result += " ForceOpacityMicromap2StateEXT |"; - if ( value & GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT ) - result += " DisableOpacityMicromapsEXT |"; + if ( value & GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2State ) + result += " ForceOpacityMicromap2State |"; + if ( value & GeometryInstanceFlagBitsKHR::eDisableOpacityMicromaps ) + result += " DisableOpacityMicromaps |"; if ( result.size() > 1 ) result.back() = '}'; @@ -3217,10 +3262,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " LowMemory |"; if ( value & BuildAccelerationStructureFlagBitsKHR::eMotionNV ) result += " MotionNV |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT ) - result += " AllowOpacityMicromapUpdateEXT |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT ) - result += " AllowDisableOpacityMicromapsEXT |"; if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT ) result += " AllowOpacityMicromapDataUpdateEXT |"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) @@ -3231,6 +3272,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " AllowDataAccess |"; if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV ) result += " AllowClusterOpacityMicromapsNV |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdate ) + result += " AllowOpacityMicromapUpdate |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromaps ) + result += " AllowDisableOpacityMicromaps |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eMicromapLossy ) + result += " MicromapLossy |"; if ( result.size() > 1 ) result.back() = '}'; @@ -4050,8 +4097,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " FragmentDensityMapAttachment |"; if ( value & ShaderCreateFlagBitsEXT::eIndirectBindable ) result += " IndirectBindable |"; + if ( value & ShaderCreateFlagBitsEXT::eOpacityMicromapDisallowMixedSpecialIndex ) + result += " OpacityMicromapDisallowMixedSpecialIndex |"; if ( value & ShaderCreateFlagBitsEXT::e64BitIndexing ) result += " 64BitIndexing |"; + if ( value & ShaderCreateFlagBitsEXT::eIndependentSetsKHR ) + result += " IndependentSetsKHR |"; if ( result.size() > 1 ) result.back() = '}'; @@ -5120,6 +5171,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::eExternalFormatANDROID : return "ExternalFormatANDROID"; case StructureType::eAndroidHardwareBufferFormatProperties2ANDROID: return "AndroidHardwareBufferFormatProperties2ANDROID"; #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + case StructureType::ePhysicalDeviceGpaFeaturesAMD : return "PhysicalDeviceGpaFeaturesAMD"; + case StructureType::ePhysicalDeviceGpaPropertiesAMD : return "PhysicalDeviceGpaPropertiesAMD"; + case StructureType::eGpaSampleBeginInfoAMD : return "GpaSampleBeginInfoAMD"; + case StructureType::eGpaSessionCreateInfoAMD : return "GpaSessionCreateInfoAMD"; + case StructureType::eGpaDeviceClockModeInfoAMD : return "GpaDeviceClockModeInfoAMD"; + case StructureType::ePhysicalDeviceGpaProperties2AMD: return "PhysicalDeviceGpaProperties2AMD"; + case StructureType::eGpaDeviceGetClockInfoAMD : return "GpaDeviceGetClockInfoAMD"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX : return "PhysicalDeviceShaderEnqueueFeaturesAMDX"; case StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX: return "PhysicalDeviceShaderEnqueuePropertiesAMDX"; @@ -5209,6 +5267,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT"; case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT"; case StructureType::ePhysicalDeviceCooperativeMatrixConversionFeaturesQCOM: return "PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM"; + case StructureType::ePhysicalDeviceElapsedTimerQueryFeaturesQCOM : return "PhysicalDeviceElapsedTimerQueryFeaturesQCOM"; case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT"; case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT"; case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; @@ -5362,6 +5421,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::ePerfHintInfoQCOM : return "PerfHintInfoQCOM"; case StructureType::ePhysicalDeviceQueuePerfHintFeaturesQCOM : return "PhysicalDeviceQueuePerfHintFeaturesQCOM"; case StructureType::ePhysicalDeviceQueuePerfHintPropertiesQCOM : return "PhysicalDeviceQueuePerfHintPropertiesQCOM"; + case StructureType::ePhysicalDeviceImageProcessing3FeaturesQCOM : return "PhysicalDeviceImageProcessing3FeaturesQCOM"; + case StructureType::ePhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM : return "PhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM"; + case StructureType::ePhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM : return "PhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM"; + case StructureType::ePhysicalDeviceShaderSplitBarrierFeaturesEXT : return "PhysicalDeviceShaderSplitBarrierFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderSplitBarrierPropertiesEXT : return "PhysicalDeviceShaderSplitBarrierPropertiesEXT"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case StructureType::eCudaModuleCreateInfoNV : return "CudaModuleCreateInfoNV"; case StructureType::eCudaFunctionCreateInfoNV : return "CudaFunctionCreateInfoNV"; @@ -5901,6 +5965,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT : return "RenderPassFragmentDensityMapOffsetEndInfoEXT"; case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"; case StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : return "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"; + case StructureType::ePhysicalDeviceOpacityMicromapFeaturesKHR : return "PhysicalDeviceOpacityMicromapFeaturesKHR"; + case StructureType::ePhysicalDeviceOpacityMicromapPropertiesKHR : return "PhysicalDeviceOpacityMicromapPropertiesKHR"; + case StructureType::eAccelerationStructureGeometryMicromapDataKHR : return "AccelerationStructureGeometryMicromapDataKHR"; + case StructureType::eAccelerationStructureTrianglesOpacityMicromapKHR : return "AccelerationStructureTrianglesOpacityMicromapKHR"; case StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT : return "PhysicalDeviceShader64BitIndexingFeaturesEXT"; case StructureType::ePhysicalDeviceCustomResolveFeaturesEXT : return "PhysicalDeviceCustomResolveFeaturesEXT"; case StructureType::eBeginCustomResolveInfoEXT : return "BeginCustomResolveInfoEXT"; @@ -5927,13 +5995,21 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT: return "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT"; case StructureType::eComputeOccupancyPriorityParametersNV : return "ComputeOccupancyPriorityParametersNV"; case StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV : return "PhysicalDeviceComputeOccupancyPriorityFeaturesNV"; + case StructureType::ePhysicalDeviceMaintenance11FeaturesKHR : return "PhysicalDeviceMaintenance11FeaturesKHR"; + case StructureType::eQueueFamilyOptimalImageTransferGranularityPropertiesKHR : return "QueueFamilyOptimalImageTransferGranularityPropertiesKHR"; case StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT : return "PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"; #if defined( VK_USE_PLATFORM_UBM_SEC ) case StructureType::eUbmSurfaceCreateInfoSEC: return "UbmSurfaceCreateInfoSEC"; #endif /*VK_USE_PLATFORM_UBM_SEC*/ case StructureType::ePhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE: return "PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE"; - case StructureType::ePhysicalDevicePrimitiveRestartIndexFeaturesEXT : return "PhysicalDevicePrimitiveRestartIndexFeaturesEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case StructureType::ePhysicalDeviceThrottleHintFeaturesSEC : return "PhysicalDeviceThrottleHintFeaturesSEC"; + case StructureType::eThrottleHintSubmitInfoSEC : return "ThrottleHintSubmitInfoSEC"; + case StructureType::eDataGraphPipelineNeuralStatisticsCreateInfoARM : return "DataGraphPipelineNeuralStatisticsCreateInfoARM"; + case StructureType::eDataGraphPipelineSessionNeuralStatisticsCreateInfoARM: return "DataGraphPipelineSessionNeuralStatisticsCreateInfoARM"; + case StructureType::ePhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM: + return "PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM"; + case StructureType::ePhysicalDevicePrimitiveRestartIndexFeaturesEXT: return "PhysicalDevicePrimitiveRestartIndexFeaturesEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -5980,6 +6056,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case ObjectType::eCuModuleNVX : return "CuModuleNVX"; case ObjectType::eCuFunctionNVX : return "CuFunctionNVX"; case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT"; + case ObjectType::eGpaSessionAMD : return "GpaSessionAMD"; case ObjectType::eAccelerationStructureKHR : return "AccelerationStructureKHR"; case ObjectType::eValidationCacheEXT : return "ValidationCacheEXT"; case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV"; @@ -6394,6 +6471,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case ImageCreateFlagBits::e2DViewCompatibleEXT : return "2DViewCompatibleEXT"; case ImageCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR"; case ImageCreateFlagBits::eFragmentDensityMapOffsetEXT : return "FragmentDensityMapOffsetEXT"; + case ImageCreateFlagBits::eAliasSingleLayerDescriptorKHR : return "AliasSingleLayerDescriptorKHR"; default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -6753,6 +6831,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case QueryType::eAccelerationStructureCompactedSizeKHR : return "AccelerationStructureCompactedSizeKHR"; case QueryType::eAccelerationStructureSerializationSizeKHR : return "AccelerationStructureSerializationSizeKHR"; case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV"; + case QueryType::eTimeElapsedQCOM : return "TimeElapsedQCOM"; case QueryType::ePerformanceQueryINTEL : return "PerformanceQueryINTEL"; case QueryType::eVideoEncodeFeedbackKHR : return "VideoEncodeFeedbackKHR"; case QueryType::eMeshPrimitivesGeneratedEXT : return "MeshPrimitivesGeneratedEXT"; @@ -7103,11 +7182,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case PipelineCreateFlagBits::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV"; case PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT"; case PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT"; - case PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case PipelineCreateFlagBits::eRayTracingOpacityMicromapKHR: return "RayTracingOpacityMicromapKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -7116,6 +7195,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE switch ( value ) { case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT"; + case PipelineLayoutCreateFlagBits::eNoTaskShaderKHR : return "NoTaskShaderKHR"; default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -8237,6 +8317,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR"; case FormatFeatureFlagBits2::eVideoEncodeInputKHR : return "VideoEncodeInputKHR"; case FormatFeatureFlagBits2::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; + case FormatFeatureFlagBits2::eBlockMatchingSxdQCOM : return "BlockMatchingSxdQCOM"; case FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV : return "AccelerationStructureRadiusBufferNV"; case FormatFeatureFlagBits2::eLinearColorAttachmentNV : return "LinearColorAttachmentNV"; case FormatFeatureFlagBits2::eWeightImageQCOM : return "WeightImageQCOM"; @@ -8356,6 +8437,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case BufferUsageFlagBits2::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ case BufferUsageFlagBits2::eDescriptorHeapEXT : return "DescriptorHeapEXT"; + case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT"; + case BufferUsageFlagBits2::eMicromapStorageEXT : return "MicromapStorageEXT"; case BufferUsageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; case BufferUsageFlagBits2::eShaderBindingTableKHR : return "ShaderBindingTableKHR"; case BufferUsageFlagBits2::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT"; @@ -8369,8 +8452,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case BufferUsageFlagBits2::eSamplerDescriptorBufferEXT : return "SamplerDescriptorBufferEXT"; case BufferUsageFlagBits2::eResourceDescriptorBufferEXT : return "ResourceDescriptorBufferEXT"; case BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT"; - case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT"; - case BufferUsageFlagBits2::eMicromapStorageEXT : return "MicromapStorageEXT"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case BufferUsageFlagBits2::eCompressedDataDgf1AMDX: return "CompressedDataDgf1AMDX"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ @@ -8427,20 +8508,21 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case PipelineCreateFlagBits2::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV"; case PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR : return "RenderingFragmentShadingRateAttachmentKHR"; case PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT : return "RenderingFragmentDensityMapAttachmentEXT"; - case PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT"; case PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT"; case PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case PipelineCreateFlagBits2::eDescriptorBufferEXT : return "DescriptorBufferEXT"; - case PipelineCreateFlagBits2::eDisallowOpacityMicromapARM : return "DisallowOpacityMicromapARM"; - case PipelineCreateFlagBits2::eInstrumentShadersARM : return "InstrumentShadersARM"; - case PipelineCreateFlagBits2::eCaptureDataKHR : return "CaptureDataKHR"; - case PipelineCreateFlagBits2::eIndirectBindableEXT : return "IndirectBindableEXT"; - case PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE: return "PerLayerFragmentDensityVALVE"; - case PipelineCreateFlagBits2::e64BitIndexingEXT : return "64BitIndexingEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case PipelineCreateFlagBits2::eDescriptorBufferEXT : return "DescriptorBufferEXT"; + case PipelineCreateFlagBits2::eDisallowOpacityMicromapARM : return "DisallowOpacityMicromapARM"; + case PipelineCreateFlagBits2::eInstrumentShadersARM : return "InstrumentShadersARM"; + case PipelineCreateFlagBits2::eCaptureDataKHR : return "CaptureDataKHR"; + case PipelineCreateFlagBits2::eIndirectBindableEXT : return "IndirectBindableEXT"; + case PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE"; + case PipelineCreateFlagBits2::eRayTracingOpacityMicromapKHR : return "RayTracingOpacityMicromapKHR"; + case PipelineCreateFlagBits2::eOpacityMicromapDisallowMixedSpecialIndexKHR: return "OpacityMicromapDisallowMixedSpecialIndexKHR"; + case PipelineCreateFlagBits2::e64BitIndexingEXT : return "64BitIndexingEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -9312,6 +9394,123 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return "(void)"; } + //=== VK_AMD_gpa_interface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GpaSqShaderStageFlagBitsAMD value ) + { + switch ( value ) + { + case GpaSqShaderStageFlagBitsAMD::ePs: return "Ps"; + case GpaSqShaderStageFlagBitsAMD::eVs: return "Vs"; + case GpaSqShaderStageFlagBitsAMD::eGs: return "Gs"; + case GpaSqShaderStageFlagBitsAMD::eEs: return "Es"; + case GpaSqShaderStageFlagBitsAMD::eHs: return "Hs"; + case GpaSqShaderStageFlagBitsAMD::eLs: return "Ls"; + case GpaSqShaderStageFlagBitsAMD::eCs: return "Cs"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GpaPerfBlockAMD value ) + { + switch ( value ) + { + case GpaPerfBlockAMD::eCpf : return "Cpf"; + case GpaPerfBlockAMD::eIa : return "Ia"; + case GpaPerfBlockAMD::eVgt : return "Vgt"; + case GpaPerfBlockAMD::ePa : return "Pa"; + case GpaPerfBlockAMD::eSc : return "Sc"; + case GpaPerfBlockAMD::eSpi : return "Spi"; + case GpaPerfBlockAMD::eSq : return "Sq"; + case GpaPerfBlockAMD::eSx : return "Sx"; + case GpaPerfBlockAMD::eTa : return "Ta"; + case GpaPerfBlockAMD::eTd : return "Td"; + case GpaPerfBlockAMD::eTcp : return "Tcp"; + case GpaPerfBlockAMD::eTcc : return "Tcc"; + case GpaPerfBlockAMD::eTca : return "Tca"; + case GpaPerfBlockAMD::eDb : return "Db"; + case GpaPerfBlockAMD::eCb : return "Cb"; + case GpaPerfBlockAMD::eGds : return "Gds"; + case GpaPerfBlockAMD::eSrbm : return "Srbm"; + case GpaPerfBlockAMD::eGrbm : return "Grbm"; + case GpaPerfBlockAMD::eGrbmSe : return "GrbmSe"; + case GpaPerfBlockAMD::eRlc : return "Rlc"; + case GpaPerfBlockAMD::eDma : return "Dma"; + case GpaPerfBlockAMD::eMc : return "Mc"; + case GpaPerfBlockAMD::eCpg : return "Cpg"; + case GpaPerfBlockAMD::eCpc : return "Cpc"; + case GpaPerfBlockAMD::eWd : return "Wd"; + case GpaPerfBlockAMD::eTcs : return "Tcs"; + case GpaPerfBlockAMD::eAtc : return "Atc"; + case GpaPerfBlockAMD::eAtcL2 : return "AtcL2"; + case GpaPerfBlockAMD::eMcVmL2 : return "McVmL2"; + case GpaPerfBlockAMD::eEa : return "Ea"; + case GpaPerfBlockAMD::eRpb : return "Rpb"; + case GpaPerfBlockAMD::eRmi : return "Rmi"; + case GpaPerfBlockAMD::eUmcch : return "Umcch"; + case GpaPerfBlockAMD::eGe : return "Ge"; + case GpaPerfBlockAMD::eGl1A : return "Gl1A"; + case GpaPerfBlockAMD::eGl1C : return "Gl1C"; + case GpaPerfBlockAMD::eGl1Cg : return "Gl1Cg"; + case GpaPerfBlockAMD::eGl2A : return "Gl2A"; + case GpaPerfBlockAMD::eGl2C : return "Gl2C"; + case GpaPerfBlockAMD::eCha : return "Cha"; + case GpaPerfBlockAMD::eChc : return "Chc"; + case GpaPerfBlockAMD::eChcg : return "Chcg"; + case GpaPerfBlockAMD::eGus : return "Gus"; + case GpaPerfBlockAMD::eGcr : return "Gcr"; + case GpaPerfBlockAMD::ePh : return "Ph"; + case GpaPerfBlockAMD::eUtcl1 : return "Utcl1"; + case GpaPerfBlockAMD::eGeDist : return "GeDist"; + case GpaPerfBlockAMD::eGeSe : return "GeSe"; + case GpaPerfBlockAMD::eDfMall : return "DfMall"; + case GpaPerfBlockAMD::eSqWgp : return "SqWgp"; + case GpaPerfBlockAMD::ePc : return "Pc"; + case GpaPerfBlockAMD::eGl1Xa : return "Gl1Xa"; + case GpaPerfBlockAMD::eGl1Xc : return "Gl1Xc"; + case GpaPerfBlockAMD::eWgs : return "Wgs"; + case GpaPerfBlockAMD::eEacpwd : return "Eacpwd"; + case GpaPerfBlockAMD::eEase : return "Ease"; + case GpaPerfBlockAMD::eRlcuser: return "Rlcuser"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GpaSampleTypeAMD value ) + { + switch ( value ) + { + case GpaSampleTypeAMD::eCumulative: return "Cumulative"; + case GpaSampleTypeAMD::eTrace : return "Trace"; + case GpaSampleTypeAMD::eTiming : return "Timing"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GpaDeviceClockModeAMD value ) + { + switch ( value ) + { + case GpaDeviceClockModeAMD::eDefault : return "Default"; + case GpaDeviceClockModeAMD::eQuery : return "Query"; + case GpaDeviceClockModeAMD::eProfiling: return "Profiling"; + case GpaDeviceClockModeAMD::eMinMemory: return "MinMemory"; + case GpaDeviceClockModeAMD::eMinEngine: return "MinEngine"; + case GpaDeviceClockModeAMD::ePeak : return "Peak"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GpaPerfBlockPropertiesFlagBitsAMD ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceGpaPropertiesFlagBitsAMD ) + { + return "(void)"; + } + //=== VK_EXT_descriptor_heap === VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorMappingSourceEXT value ) @@ -9387,10 +9586,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case AccelerationStructureTypeKHR::eTopLevel : return "TopLevel"; - case AccelerationStructureTypeKHR::eBottomLevel: return "BottomLevel"; - case AccelerationStructureTypeKHR::eGeneric : return "Generic"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case AccelerationStructureTypeKHR::eTopLevel : return "TopLevel"; + case AccelerationStructureTypeKHR::eBottomLevel : return "BottomLevel"; + case AccelerationStructureTypeKHR::eGeneric : return "Generic"; + case AccelerationStructureTypeKHR::eOpacityMicromap: return "OpacityMicromap"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -9419,13 +9619,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable : return "TriangleFacingCullDisable"; - case GeometryInstanceFlagBitsKHR::eTriangleFlipFacing : return "TriangleFlipFacing"; - case GeometryInstanceFlagBitsKHR::eForceOpaque : return "ForceOpaque"; - case GeometryInstanceFlagBitsKHR::eForceNoOpaque : return "ForceNoOpaque"; - case GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT: return "ForceOpacityMicromap2StateEXT"; - case GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT : return "DisableOpacityMicromapsEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable : return "TriangleFacingCullDisable"; + case GeometryInstanceFlagBitsKHR::eTriangleFlipFacing : return "TriangleFlipFacing"; + case GeometryInstanceFlagBitsKHR::eForceOpaque : return "ForceOpaque"; + case GeometryInstanceFlagBitsKHR::eForceNoOpaque : return "ForceNoOpaque"; + case GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2State: return "ForceOpacityMicromap2State"; + case GeometryInstanceFlagBitsKHR::eDisableOpacityMicromaps : return "DisableOpacityMicromaps"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -9439,14 +9639,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild : return "PreferFastBuild"; case BuildAccelerationStructureFlagBitsKHR::eLowMemory : return "LowMemory"; case BuildAccelerationStructureFlagBitsKHR::eMotionNV : return "MotionNV"; - case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT : return "AllowOpacityMicromapUpdateEXT"; - case BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT : return "AllowDisableOpacityMicromapsEXT"; case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT: return "AllowOpacityMicromapDataUpdateEXT"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV: return "AllowDisplacementMicromapUpdateNV"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ case BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess : return "AllowDataAccess"; case BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV: return "AllowClusterOpacityMicromapsNV"; + case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdate : return "AllowOpacityMicromapUpdate"; + case BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromaps : return "AllowDisableOpacityMicromaps"; + case BuildAccelerationStructureFlagBitsKHR::eMicromapLossy : return "MicromapLossy"; default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -9475,7 +9676,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) case GeometryTypeKHR::eDenseGeometryFormatTrianglesAMDX: return "DenseGeometryFormatTrianglesAMDX"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case GeometryTypeKHR::eMicromap: return "Micromap"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -10379,29 +10581,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapFormatEXT value ) - { - switch ( value ) - { - case OpacityMicromapFormatEXT::e2State: return "2State"; - case OpacityMicromapFormatEXT::e4State: return "4State"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapSpecialIndexEXT value ) - { - switch ( value ) - { - case OpacityMicromapSpecialIndexEXT::eFullyTransparent : return "FullyTransparent"; - case OpacityMicromapSpecialIndexEXT::eFullyOpaque : return "FullyOpaque"; - case OpacityMicromapSpecialIndexEXT::eFullyUnknownTransparent : return "FullyUnknownTransparent"; - case OpacityMicromapSpecialIndexEXT::eFullyUnknownOpaque : return "FullyUnknownOpaque"; - case OpacityMicromapSpecialIndexEXT::eClusterGeometryDisableOpacityMicromapNV: return "ClusterGeometryDisableOpacityMicromapNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_displacement_micromap === @@ -10651,18 +10830,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case ShaderCreateFlagBitsEXT::eLinkStage : return "LinkStage"; - case ShaderCreateFlagBitsEXT::eDescriptorHeap : return "DescriptorHeap"; - case ShaderCreateFlagBitsEXT::eInstrumentShaderARM : return "InstrumentShaderARM"; - case ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize : return "AllowVaryingSubgroupSize"; - case ShaderCreateFlagBitsEXT::eRequireFullSubgroups : return "RequireFullSubgroups"; - case ShaderCreateFlagBitsEXT::eNoTaskShader : return "NoTaskShader"; - case ShaderCreateFlagBitsEXT::eDispatchBase : return "DispatchBase"; - case ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment"; - case ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment : return "FragmentDensityMapAttachment"; - case ShaderCreateFlagBitsEXT::eIndirectBindable : return "IndirectBindable"; - case ShaderCreateFlagBitsEXT::e64BitIndexing : return "64BitIndexing"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case ShaderCreateFlagBitsEXT::eLinkStage : return "LinkStage"; + case ShaderCreateFlagBitsEXT::eDescriptorHeap : return "DescriptorHeap"; + case ShaderCreateFlagBitsEXT::eInstrumentShaderARM : return "InstrumentShaderARM"; + case ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize : return "AllowVaryingSubgroupSize"; + case ShaderCreateFlagBitsEXT::eRequireFullSubgroups : return "RequireFullSubgroups"; + case ShaderCreateFlagBitsEXT::eNoTaskShader : return "NoTaskShader"; + case ShaderCreateFlagBitsEXT::eDispatchBase : return "DispatchBase"; + case ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment : return "FragmentShadingRateAttachment"; + case ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment : return "FragmentDensityMapAttachment"; + case ShaderCreateFlagBitsEXT::eIndirectBindable : return "IndirectBindable"; + case ShaderCreateFlagBitsEXT::eOpacityMicromapDisallowMixedSpecialIndex: return "OpacityMicromapDisallowMixedSpecialIndex"; + case ShaderCreateFlagBitsEXT::e64BitIndexing : return "64BitIndexing"; + case ShaderCreateFlagBitsEXT::eIndependentSetsKHR : return "IndependentSetsKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -10808,9 +10989,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case DataGraphPipelineSessionBindPointARM::eTransient : return "Transient"; - case DataGraphPipelineSessionBindPointARM::eOpticalFlowCache: return "OpticalFlowCache"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case DataGraphPipelineSessionBindPointARM::eTransient : return "Transient"; + case DataGraphPipelineSessionBindPointARM::eOpticalFlowCache : return "OpticalFlowCache"; + case DataGraphPipelineSessionBindPointARM::eNeuralAcceleratorStatistics: return "NeuralAcceleratorStatistics"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -10837,9 +11019,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case DataGraphPipelinePropertyARM::eCreationLog: return "CreationLog"; - case DataGraphPipelinePropertyARM::eIdentifier : return "Identifier"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case DataGraphPipelinePropertyARM::eCreationLog : return "CreationLog"; + case DataGraphPipelinePropertyARM::eIdentifier : return "Identifier"; + case DataGraphPipelinePropertyARM::eNeuralAcceleratorDebugDatabase : return "NeuralAcceleratorDebugDatabase"; + case DataGraphPipelinePropertyARM::eNeuralAcceleratorStatisticsInfo: return "NeuralAcceleratorStatisticsInfo"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -11367,6 +11551,40 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return "(void)"; } + //=== VK_KHR_opacity_micromap === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapFormatKHR value ) + { + switch ( value ) + { + case OpacityMicromapFormatKHR::e2State: return "2State"; + case OpacityMicromapFormatKHR::e4State: return "4State"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapSpecialIndexKHR value ) + { + switch ( value ) + { + case OpacityMicromapSpecialIndexKHR::eFullyTransparent : return "FullyTransparent"; + case OpacityMicromapSpecialIndexKHR::eFullyOpaque : return "FullyOpaque"; + case OpacityMicromapSpecialIndexKHR::eFullyUnknownTransparent : return "FullyUnknownTransparent"; + case OpacityMicromapSpecialIndexKHR::eFullyUnknownOpaque : return "FullyUnknownOpaque"; + case OpacityMicromapSpecialIndexKHR::eClusterGeometryDisableOpacityMicromapNV: return "ClusterGeometryDisableOpacityMicromapNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureSerializedBlockTypeKHR value ) + { + switch ( value ) + { + case AccelerationStructureSerializedBlockTypeKHR::eOpacityMicromap: return "OpacityMicromap"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + //=== VK_QCOM_data_graph_model === VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphModelCacheTypeQCOM value ) @@ -11496,6 +11714,32 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } #endif /*VK_USE_PLATFORM_UBM_SEC*/ + //=== VK_SEC_throttle_hint === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ThrottleHintTypeSEC value ) + { + switch ( value ) + { + case ThrottleHintTypeSEC::eDefault: return "Default"; + case ThrottleHintTypeSEC::eLow : return "Low"; + case ThrottleHintTypeSEC::eHigh : return "High"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_ARM_data_graph_neural_accelerator_statistics === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( NeuralAcceleratorStatisticsModeARM value ) + { + switch ( value ) + { + case NeuralAcceleratorStatisticsModeARM::eDisabled : return "Disabled"; + case NeuralAcceleratorStatisticsModeARM::eStatistics0: return "Statistics0"; + case NeuralAcceleratorStatisticsModeARM::eStatistics1: return "Statistics1"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + } // namespace VULKAN_HPP_NAMESPACE #if defined( __clang__ ) || defined( __GNUC__ ) diff --git a/third_party/vulkan/vulkan_video.hpp b/third_party/vulkan/vulkan_video.hpp index 83b30a8..1646141 100644 --- a/third_party/vulkan/vulkan_video.hpp +++ b/third_party/vulkan/vulkan_video.hpp @@ -665,16 +665,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && - ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && - ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && - ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && - ( video_full_range_flag == rhs.video_full_range_flag ) && - ( color_description_present_flag == rhs.color_description_present_flag ) && - ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && - ( timing_info_present_flag == rhs.timing_info_present_flag ) && - ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && - ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && + return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && + ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && + ( video_full_range_flag == rhs.video_full_range_flag ) && ( color_description_present_flag == rhs.color_description_present_flag ) && + ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && + ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ); } @@ -725,17 +720,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && - ( bit_rate_scale == rhs.bit_rate_scale ) && - ( cpb_size_scale == rhs.cpb_size_scale ) && - ( reserved1 == rhs.reserved1 ) && - ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && - ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && - ( cbr_flag == rhs.cbr_flag ) && + return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) && + ( reserved1 == rhs.reserved1 ) && ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && + ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ) && ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && ( cpb_removal_delay_length_minus1 == rhs.cpb_removal_delay_length_minus1 ) && - ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && - ( time_offset_length == rhs.time_offset_length ); + ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( time_offset_length == rhs.time_offset_length ); } bool operator!=( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -783,21 +773,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && - ( sar_width == rhs.sar_width ) && - ( sar_height == rhs.sar_height ) && - ( video_format == rhs.video_format ) && - ( colour_primaries == rhs.colour_primaries ) && - ( transfer_characteristics == rhs.transfer_characteristics ) && - ( matrix_coefficients == rhs.matrix_coefficients ) && - ( num_units_in_tick == rhs.num_units_in_tick ) && - ( time_scale == rhs.time_scale ) && - ( max_num_reorder_frames == rhs.max_num_reorder_frames ) && - ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && - ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && - ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && - ( reserved1 == rhs.reserved1 ) && + return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && + ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && + ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coefficients == rhs.matrix_coefficients ) && + ( num_units_in_tick == rhs.num_units_in_tick ) && ( time_scale == rhs.time_scale ) && ( max_num_reorder_frames == rhs.max_num_reorder_frames ) && + ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && + ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && ( pHrdParameters == rhs.pHrdParameters ); } @@ -852,22 +833,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( constraint_set0_flag == rhs.constraint_set0_flag ) && - ( constraint_set1_flag == rhs.constraint_set1_flag ) && - ( constraint_set2_flag == rhs.constraint_set2_flag ) && - ( constraint_set3_flag == rhs.constraint_set3_flag ) && - ( constraint_set4_flag == rhs.constraint_set4_flag ) && - ( constraint_set5_flag == rhs.constraint_set5_flag ) && - ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && - ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) && - ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && - ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) && + return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) && + ( constraint_set2_flag == rhs.constraint_set2_flag ) && ( constraint_set3_flag == rhs.constraint_set3_flag ) && + ( constraint_set4_flag == rhs.constraint_set4_flag ) && ( constraint_set5_flag == rhs.constraint_set5_flag ) && + ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) && + ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && ( gaps_in_frame_num_value_allowed_flag == rhs.gaps_in_frame_num_value_allowed_flag ) && - ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && - ( frame_cropping_flag == rhs.frame_cropping_flag ) && - ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && - ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ); + ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && ( frame_cropping_flag == rhs.frame_cropping_flag ) && + ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ); } bool operator!=( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -920,10 +894,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && - ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) && - ( ScalingList4x4 == rhs.ScalingList4x4 ) && - ( ScalingList8x8 == rhs.ScalingList8x8 ); + return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) && + ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ); } bool operator!=( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -964,30 +936,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( profile_idc == rhs.profile_idc ) && - ( level_idc == rhs.level_idc ) && - ( chroma_format_idc == rhs.chroma_format_idc ) && - ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && - ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && - ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && - ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && - ( pic_order_cnt_type == rhs.pic_order_cnt_type ) && - ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && - ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) && + return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) && + ( chroma_format_idc == rhs.chroma_format_idc ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && + ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && + ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && ( pic_order_cnt_type == rhs.pic_order_cnt_type ) && + ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) && ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && - ( num_ref_frames_in_pic_order_cnt_cycle == rhs.num_ref_frames_in_pic_order_cnt_cycle ) && - ( max_num_ref_frames == rhs.max_num_ref_frames ) && - ( reserved1 == rhs.reserved1 ) && - ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) && - ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && - ( frame_crop_left_offset == rhs.frame_crop_left_offset ) && - ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && - ( frame_crop_top_offset == rhs.frame_crop_top_offset ) && - ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && - ( reserved2 == rhs.reserved2 ) && - ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && - ( pScalingLists == rhs.pScalingLists ) && + ( num_ref_frames_in_pic_order_cnt_cycle == rhs.num_ref_frames_in_pic_order_cnt_cycle ) && ( max_num_ref_frames == rhs.max_num_ref_frames ) && + ( reserved1 == rhs.reserved1 ) && ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) && + ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && ( frame_crop_left_offset == rhs.frame_crop_left_offset ) && + ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && ( frame_crop_top_offset == rhs.frame_crop_top_offset ) && + ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && ( reserved2 == rhs.reserved2 ) && + ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && ( pScalingLists == rhs.pScalingLists ) && ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ); } @@ -1052,14 +1012,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && - ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) && + return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && - ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && - ( weighted_pred_flag == rhs.weighted_pred_flag ) && + ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( bottom_field_pic_order_in_frame_present_flag == rhs.bottom_field_pic_order_in_frame_present_flag ) && - ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && - ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag ); + ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag ); } bool operator!=( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1104,16 +1061,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && - ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && + return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && - ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && - ( weighted_bipred_idc == rhs.weighted_bipred_idc ) && - ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && - ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) && - ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && - ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) && + ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( weighted_bipred_idc == rhs.weighted_bipred_idc ) && + ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) && + ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) && ( pScalingLists == rhs.pScalingLists ); } @@ -1167,11 +1119,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( field_pic_flag == rhs.field_pic_flag ) && - ( is_intra == rhs.is_intra ) && - ( IdrPicFlag == rhs.IdrPicFlag ) && - ( bottom_field_flag == rhs.bottom_field_flag ) && - ( is_reference == rhs.is_reference ) && + return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) && + ( bottom_field_flag == rhs.bottom_field_flag ) && ( is_reference == rhs.is_reference ) && ( complementary_field_pair == rhs.complementary_field_pair ); } @@ -1215,13 +1164,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && - ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && - ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && - ( frame_num == rhs.frame_num ) && - ( idr_pic_id == rhs.idr_pic_id ) && + return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && + ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( frame_num == rhs.frame_num ) && ( idr_pic_id == rhs.idr_pic_id ) && ( PicOrderCnt == rhs.PicOrderCnt ); } @@ -1267,10 +1211,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( top_field_flag == rhs.top_field_flag ) && - ( bottom_field_flag == rhs.bottom_field_flag ) && - ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && - ( is_non_existing == rhs.is_non_existing ); + return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) && + ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( is_non_existing == rhs.is_non_existing ); } bool operator!=( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1356,10 +1298,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && - ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && - ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && - ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); + return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && + ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); } bool operator!=( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1400,16 +1340,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && - ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && - ( luma_weight_l0 == rhs.luma_weight_l0 ) && - ( luma_offset_l0 == rhs.luma_offset_l0 ) && - ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && - ( chroma_offset_l0 == rhs.chroma_offset_l0 ) && - ( luma_weight_l1 == rhs.luma_weight_l1 ) && - ( luma_offset_l1 == rhs.luma_offset_l1 ) && - ( chroma_weight_l1 == rhs.chroma_weight_l1 ) && + return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && + ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && ( luma_weight_l0 == rhs.luma_weight_l0 ) && + ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && ( chroma_offset_l0 == rhs.chroma_offset_l0 ) && + ( luma_weight_l1 == rhs.luma_weight_l1 ) && ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( chroma_weight_l1 == rhs.chroma_weight_l1 ) && ( chroma_offset_l1 == rhs.chroma_offset_l1 ); } @@ -1459,8 +1393,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) && - ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && - ( reserved == rhs.reserved ); + ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1500,12 +1433,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( IdrPicFlag == rhs.IdrPicFlag ) && - ( is_reference == rhs.is_reference ) && - ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && - ( long_term_reference_flag == rhs.long_term_reference_flag ) && - ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && - ( reserved == rhs.reserved ); + return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) && + ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( long_term_reference_flag == rhs.long_term_reference_flag ) && + ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1588,8 +1518,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && - ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && - ( reserved == rhs.reserved ); + ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1629,8 +1558,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && - ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) && + return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ); } @@ -1673,10 +1601,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( memory_management_control_operation == rhs.memory_management_control_operation ) && - ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && - ( long_term_pic_num == rhs.long_term_pic_num ) && - ( long_term_frame_idx == rhs.long_term_frame_idx ) && - ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 ); + ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) && + ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 ); } bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1719,17 +1645,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && - ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && - ( RefPicList0 == rhs.RefPicList0 ) && - ( RefPicList1 == rhs.RefPicList1 ) && - ( refList0ModOpCount == rhs.refList0ModOpCount ) && - ( refList1ModOpCount == rhs.refList1ModOpCount ) && - ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && - ( reserved1 == rhs.reserved1 ) && - ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && - ( pRefList1ModOperations == rhs.pRefList1ModOperations ) && + return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && + ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && + ( RefPicList1 == rhs.RefPicList1 ) && ( refList0ModOpCount == rhs.refList0ModOpCount ) && ( refList1ModOpCount == rhs.refList1ModOpCount ) && + ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && ( reserved1 == rhs.reserved1 ) && + ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && ( pRefList1ModOperations == rhs.pRefList1ModOperations ) && ( pRefPicMarkingOperations == rhs.pRefPicMarkingOperations ); } @@ -1779,16 +1699,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && - ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && - ( idr_pic_id == rhs.idr_pic_id ) && - ( primary_pic_type == rhs.primary_pic_type ) && - ( frame_num == rhs.frame_num ) && - ( PicOrderCnt == rhs.PicOrderCnt ) && - ( temporal_id == rhs.temporal_id ) && - ( reserved1 == rhs.reserved1 ) && - ( pRefLists == rhs.pRefLists ); + return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && + ( idr_pic_id == rhs.idr_pic_id ) && ( primary_pic_type == rhs.primary_pic_type ) && ( frame_num == rhs.frame_num ) && + ( PicOrderCnt == rhs.PicOrderCnt ) && ( temporal_id == rhs.temporal_id ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ); } bool operator!=( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1836,13 +1749,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( primary_pic_type == rhs.primary_pic_type ) && - ( FrameNum == rhs.FrameNum ) && - ( PicOrderCnt == rhs.PicOrderCnt ) && - ( long_term_pic_num == rhs.long_term_pic_num ) && - ( long_term_frame_idx == rhs.long_term_frame_idx ) && - ( temporal_id == rhs.temporal_id ); + return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) && + ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( temporal_id == rhs.temporal_id ); } bool operator!=( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1887,16 +1795,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( first_mb_in_slice == rhs.first_mb_in_slice ) && - ( slice_type == rhs.slice_type ) && - ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && - ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && - ( slice_qp_delta == rhs.slice_qp_delta ) && - ( reserved1 == rhs.reserved1 ) && - ( cabac_init_idc == rhs.cabac_init_idc ) && - ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && - ( pWeightTable == rhs.pWeightTable ); + return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) && + ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && + ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) && + ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable ); } bool operator!=( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -1949,8 +1851,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && - ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) && + return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) && ( max_num_reorder_pics == rhs.max_num_reorder_pics ); } @@ -1991,10 +1892,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && - ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && - ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && - ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) && + return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && + ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ); } @@ -2041,8 +1940,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ) && ( sub_pic_hrd_params_present_flag == rhs.sub_pic_hrd_params_present_flag ) && ( sub_pic_cpb_params_in_pic_timing_sei_flag == rhs.sub_pic_cpb_params_in_pic_timing_sei_flag ) && - ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && - ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) && + ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) && ( low_delay_hrd_flag == rhs.low_delay_hrd_flag ); } @@ -2087,21 +1985,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) && + return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) && ( du_cpb_removal_delay_increment_length_minus1 == rhs.du_cpb_removal_delay_increment_length_minus1 ) && - ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && - ( bit_rate_scale == rhs.bit_rate_scale ) && - ( cpb_size_scale == rhs.cpb_size_scale ) && - ( cpb_size_du_scale == rhs.cpb_size_du_scale ) && + ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && + ( cpb_size_scale == rhs.cpb_size_scale ) && ( cpb_size_du_scale == rhs.cpb_size_du_scale ) && ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && ( au_cpb_removal_delay_length_minus1 == rhs.au_cpb_removal_delay_length_minus1 ) && - ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && - ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && - ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && - ( reserved == rhs.reserved ) && - ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && - ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl ); + ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && + ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && ( reserved == rhs.reserved ) && + ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl ); } bool operator!=( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -2197,8 +2089,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( general_tier_flag == rhs.general_tier_flag ) && - ( general_progressive_source_flag == rhs.general_progressive_source_flag ) && + return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) && ( general_interlaced_source_flag == rhs.general_interlaced_source_flag ) && ( general_non_packed_constraint_flag == rhs.general_non_packed_constraint_flag ) && ( general_frame_only_constraint_flag == rhs.general_frame_only_constraint_flag ); @@ -2284,18 +2175,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) && - ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && - ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && - ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && - ( vps_time_scale == rhs.vps_time_scale ) && - ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && - ( reserved3 == rhs.reserved3 ) && - ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && - ( pHrdParameters == rhs.pHrdParameters ) && - ( pProfileTierLevel == rhs.pProfileTierLevel ); + return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) && + ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && + ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && ( vps_time_scale == rhs.vps_time_scale ) && + ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && ( reserved3 == rhs.reserved3 ) && + ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pHrdParameters == rhs.pHrdParameters ) && ( pProfileTierLevel == rhs.pProfileTierLevel ); } bool operator!=( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -2344,11 +2228,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( ScalingList4x4 == rhs.ScalingList4x4 ) && - ( ScalingList8x8 == rhs.ScalingList8x8 ) && - ( ScalingList16x16 == rhs.ScalingList16x16 ) && - ( ScalingList32x32 == rhs.ScalingList32x32 ) && - ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) && + return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) && + ( ScalingList32x32 == rhs.ScalingList32x32 ) && ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) && ( ScalingListDCCoef32x32 == rhs.ScalingListDCCoef32x32 ); } @@ -2392,21 +2273,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && - ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && - ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && - ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && - ( video_full_range_flag == rhs.video_full_range_flag ) && - ( colour_description_present_flag == rhs.colour_description_present_flag ) && + return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && + ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && + ( video_full_range_flag == rhs.video_full_range_flag ) && ( colour_description_present_flag == rhs.colour_description_present_flag ) && ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && - ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && - ( field_seq_flag == rhs.field_seq_flag ) && - ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && - ( default_display_window_flag == rhs.default_display_window_flag ) && + ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && ( field_seq_flag == rhs.field_seq_flag ) && + ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && ( default_display_window_flag == rhs.default_display_window_flag ) && ( vui_timing_info_present_flag == rhs.vui_timing_info_present_flag ) && ( vui_poc_proportional_to_timing_flag == rhs.vui_poc_proportional_to_timing_flag ) && - ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && - ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && + ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && ( tiles_fixed_structure_flag == rhs.tiles_fixed_structure_flag ) && ( motion_vectors_over_pic_boundaries_flag == rhs.motion_vectors_over_pic_boundaries_flag ) && ( restricted_ref_pic_lists_flag == rhs.restricted_ref_pic_lists_flag ); @@ -2464,31 +2339,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && - ( sar_width == rhs.sar_width ) && - ( sar_height == rhs.sar_height ) && - ( video_format == rhs.video_format ) && - ( colour_primaries == rhs.colour_primaries ) && - ( transfer_characteristics == rhs.transfer_characteristics ) && - ( matrix_coeffs == rhs.matrix_coeffs ) && + return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && + ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && + ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coeffs == rhs.matrix_coeffs ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && - ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && - ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && - ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) && - ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && - ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) && - ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && - ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) && - ( vui_time_scale == rhs.vui_time_scale ) && - ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) && - ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && - ( reserved3 == rhs.reserved3 ) && - ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && - ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) && - ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && - ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) && + ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && + ( reserved2 == rhs.reserved2 ) && ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) && + ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) && + ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) && + ( vui_time_scale == rhs.vui_time_scale ) && ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) && + ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && ( reserved3 == rhs.reserved3 ) && + ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) && + ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) && ( pHrdParameters == rhs.pHrdParameters ); } @@ -2592,34 +2454,27 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && - ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && + return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && ( conformance_window_flag == rhs.conformance_window_flag ) && ( sps_sub_layer_ordering_info_present_flag == rhs.sps_sub_layer_ordering_info_present_flag ) && ( scaling_list_enabled_flag == rhs.scaling_list_enabled_flag ) && - ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && - ( amp_enabled_flag == rhs.amp_enabled_flag ) && - ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && - ( pcm_enabled_flag == rhs.pcm_enabled_flag ) && + ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && ( amp_enabled_flag == rhs.amp_enabled_flag ) && + ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && ( pcm_enabled_flag == rhs.pcm_enabled_flag ) && ( pcm_loop_filter_disabled_flag == rhs.pcm_loop_filter_disabled_flag ) && ( long_term_ref_pics_present_flag == rhs.long_term_ref_pics_present_flag ) && ( sps_temporal_mvp_enabled_flag == rhs.sps_temporal_mvp_enabled_flag ) && ( strong_intra_smoothing_enabled_flag == rhs.strong_intra_smoothing_enabled_flag ) && - ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && - ( sps_extension_present_flag == rhs.sps_extension_present_flag ) && + ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && ( sps_extension_present_flag == rhs.sps_extension_present_flag ) && ( sps_range_extension_flag == rhs.sps_range_extension_flag ) && ( transform_skip_rotation_enabled_flag == rhs.transform_skip_rotation_enabled_flag ) && ( transform_skip_context_enabled_flag == rhs.transform_skip_context_enabled_flag ) && - ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && - ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) && + ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) && ( extended_precision_processing_flag == rhs.extended_precision_processing_flag ) && ( intra_smoothing_disabled_flag == rhs.intra_smoothing_disabled_flag ) && ( high_precision_offsets_enabled_flag == rhs.high_precision_offsets_enabled_flag ) && ( persistent_rice_adaptation_enabled_flag == rhs.persistent_rice_adaptation_enabled_flag ) && - ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && - ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) && - ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && - ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) && + ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) && + ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) && ( sps_palette_predictor_initializers_present_flag == rhs.sps_palette_predictor_initializers_present_flag ) && ( intra_boundary_filtering_disabled_flag == rhs.intra_boundary_filtering_disabled_flag ); } @@ -2727,20 +2582,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && - ( use_delta_flag == rhs.use_delta_flag ) && - ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && - ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) && - ( used_by_curr_pic_s0_flag == rhs.used_by_curr_pic_s0_flag ) && - ( used_by_curr_pic_s1_flag == rhs.used_by_curr_pic_s1_flag ) && - ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && - ( reserved3 == rhs.reserved3 ) && - ( num_negative_pics == rhs.num_negative_pics ) && - ( num_positive_pics == rhs.num_positive_pics ) && - ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && - ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 ); + return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) && + ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) && + ( used_by_curr_pic_s0_flag == rhs.used_by_curr_pic_s0_flag ) && ( used_by_curr_pic_s1_flag == rhs.used_by_curr_pic_s1_flag ) && + ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( reserved3 == rhs.reserved3 ) && + ( num_negative_pics == rhs.num_negative_pics ) && ( num_positive_pics == rhs.num_positive_pics ) && + ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 ); } bool operator!=( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -2830,15 +2677,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( chroma_format_idc == rhs.chroma_format_idc ) && - ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) && - ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && - ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && - ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && - ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) && - ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && - ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && + return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) && + ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) && + ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && ( log2_min_luma_coding_block_size_minus3 == rhs.log2_min_luma_coding_block_size_minus3 ) && ( log2_diff_max_min_luma_coding_block_size == rhs.log2_diff_max_min_luma_coding_block_size ) && @@ -2846,29 +2688,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( log2_diff_max_min_luma_transform_block_size == rhs.log2_diff_max_min_luma_transform_block_size ) && ( max_transform_hierarchy_depth_inter == rhs.max_transform_hierarchy_depth_inter ) && ( max_transform_hierarchy_depth_intra == rhs.max_transform_hierarchy_depth_intra ) && - ( num_short_term_ref_pic_sets == rhs.num_short_term_ref_pic_sets ) && - ( num_long_term_ref_pics_sps == rhs.num_long_term_ref_pics_sps ) && + ( num_short_term_ref_pic_sets == rhs.num_short_term_ref_pic_sets ) && ( num_long_term_ref_pics_sps == rhs.num_long_term_ref_pics_sps ) && ( pcm_sample_bit_depth_luma_minus1 == rhs.pcm_sample_bit_depth_luma_minus1 ) && ( pcm_sample_bit_depth_chroma_minus1 == rhs.pcm_sample_bit_depth_chroma_minus1 ) && ( log2_min_pcm_luma_coding_block_size_minus3 == rhs.log2_min_pcm_luma_coding_block_size_minus3 ) && - ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && - ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && - ( palette_max_size == rhs.palette_max_size ) && + ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && ( reserved1 == rhs.reserved1 ) && + ( reserved2 == rhs.reserved2 ) && ( palette_max_size == rhs.palette_max_size ) && ( delta_palette_max_predictor_size == rhs.delta_palette_max_predictor_size ) && ( motion_vector_resolution_control_idc == rhs.motion_vector_resolution_control_idc ) && ( sps_num_palette_predictor_initializers_minus1 == rhs.sps_num_palette_predictor_initializers_minus1 ) && - ( conf_win_left_offset == rhs.conf_win_left_offset ) && - ( conf_win_right_offset == rhs.conf_win_right_offset ) && - ( conf_win_top_offset == rhs.conf_win_top_offset ) && - ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) && - ( pProfileTierLevel == rhs.pProfileTierLevel ) && - ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && - ( pScalingLists == rhs.pScalingLists ) && - ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && - ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) && - ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && - ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); + ( conf_win_left_offset == rhs.conf_win_left_offset ) && ( conf_win_right_offset == rhs.conf_win_right_offset ) && + ( conf_win_top_offset == rhs.conf_win_top_offset ) && ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) && + ( pProfileTierLevel == rhs.pProfileTierLevel ) && ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pScalingLists == rhs.pScalingLists ) && + ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) && + ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); } bool operator!=( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -2946,19 +2779,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) && - ( output_flag_present_flag == rhs.output_flag_present_flag ) && - ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) && - ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && - ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && - ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && - ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) && + ( output_flag_present_flag == rhs.output_flag_present_flag ) && ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) && + ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && + ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) && ( pps_slice_chroma_qp_offsets_present_flag == rhs.pps_slice_chroma_qp_offsets_present_flag ) && - ( weighted_pred_flag == rhs.weighted_pred_flag ) && - ( weighted_bipred_flag == rhs.weighted_bipred_flag ) && - ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && - ( tiles_enabled_flag == rhs.tiles_enabled_flag ) && - ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && - ( uniform_spacing_flag == rhs.uniform_spacing_flag ) && + ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( weighted_bipred_flag == rhs.weighted_bipred_flag ) && + ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && ( tiles_enabled_flag == rhs.tiles_enabled_flag ) && + ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && ( uniform_spacing_flag == rhs.uniform_spacing_flag ) && ( loop_filter_across_tiles_enabled_flag == rhs.loop_filter_across_tiles_enabled_flag ) && ( pps_loop_filter_across_slices_enabled_flag == rhs.pps_loop_filter_across_slices_enabled_flag ) && ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && @@ -2974,8 +2801,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( residual_adaptive_colour_transform_enabled_flag == rhs.residual_adaptive_colour_transform_enabled_flag ) && ( pps_slice_act_qp_offsets_present_flag == rhs.pps_slice_act_qp_offsets_present_flag ) && ( pps_palette_predictor_initializers_present_flag == rhs.pps_palette_predictor_initializers_present_flag ) && - ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && - ( pps_range_extension_flag == rhs.pps_range_extension_flag ); + ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && ( pps_range_extension_flag == rhs.pps_range_extension_flag ); } bool operator!=( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3043,41 +2869,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && - ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && - ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && + ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && ( num_extra_slice_header_bits == rhs.num_extra_slice_header_bits ) && ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && - ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && - ( init_qp_minus26 == rhs.init_qp_minus26 ) && - ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && - ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) && - ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && - ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) && - ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && - ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) && + ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( init_qp_minus26 == rhs.init_qp_minus26 ) && + ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) && + ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) && + ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) && ( log2_max_transform_skip_block_size_minus2 == rhs.log2_max_transform_skip_block_size_minus2 ) && ( diff_cu_chroma_qp_offset_depth == rhs.diff_cu_chroma_qp_offset_depth ) && - ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && - ( cb_qp_offset_list == rhs.cb_qp_offset_list ) && - ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && - ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) && - ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && - ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) && - ( pps_act_cb_qp_offset_plus5 == rhs.pps_act_cb_qp_offset_plus5 ) && - ( pps_act_cr_qp_offset_plus3 == rhs.pps_act_cr_qp_offset_plus3 ) && + ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && ( cb_qp_offset_list == rhs.cb_qp_offset_list ) && + ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) && + ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) && + ( pps_act_cb_qp_offset_plus5 == rhs.pps_act_cb_qp_offset_plus5 ) && ( pps_act_cr_qp_offset_plus3 == rhs.pps_act_cr_qp_offset_plus3 ) && ( pps_num_palette_predictor_initializers == rhs.pps_num_palette_predictor_initializers ) && - ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && - ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) && - ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && - ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) && - ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && - ( column_width_minus1 == rhs.column_width_minus1 ) && - ( row_height_minus1 == rhs.row_height_minus1 ) && - ( reserved3 == rhs.reserved3 ) && - ( pScalingLists == rhs.pScalingLists ) && + ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) && + ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) && + ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( column_width_minus1 == rhs.column_width_minus1 ) && + ( row_height_minus1 == rhs.row_height_minus1 ) && ( reserved3 == rhs.reserved3 ) && ( pScalingLists == rhs.pScalingLists ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); } @@ -3155,9 +2965,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( IrapPicFlag == rhs.IrapPicFlag ) && - ( IdrPicFlag == rhs.IdrPicFlag ) && - ( IsReference == rhs.IsReference ) && + return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) && ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ); } @@ -3199,16 +3007,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && - ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && - ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && - ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && - ( PicOrderCntVal == rhs.PicOrderCntVal ) && - ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && - ( reserved == rhs.reserved ) && - ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && - ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) && + return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && + ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && + ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && ( reserved == rhs.reserved ) && + ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) && ( RefPicSetLtCurr == rhs.RefPicSetLtCurr ); } @@ -3339,10 +3142,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && - ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && - ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && - ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); + return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && + ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); } bool operator!=( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3383,16 +3184,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && - ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && - ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) && - ( luma_offset_l0 == rhs.luma_offset_l0 ) && - ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) && - ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && - ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) && - ( luma_offset_l1 == rhs.luma_offset_l1 ) && - ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) && + return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && + ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) && + ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) && + ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) && + ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) && ( delta_chroma_offset_l1 == rhs.delta_chroma_offset_l1 ); } @@ -3442,18 +3238,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) && - ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && - ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) && - ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && - ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && - ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && - ( cabac_init_flag == rhs.cabac_init_flag ) && + ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) && + ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && + ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && ( cabac_init_flag == rhs.cabac_init_flag ) && ( cu_chroma_qp_offset_enabled_flag == rhs.cu_chroma_qp_offset_enabled_flag ) && ( deblocking_filter_override_flag == rhs.deblocking_filter_override_flag ) && ( slice_deblocking_filter_disabled_flag == rhs.slice_deblocking_filter_disabled_flag ) && ( collocated_from_l0_flag == rhs.collocated_from_l0_flag ) && - ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && - ( reserved == rhs.reserved ); + ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3503,20 +3295,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( slice_type == rhs.slice_type ) && - ( slice_segment_address == rhs.slice_segment_address ) && - ( collocated_ref_idx == rhs.collocated_ref_idx ) && - ( MaxNumMergeCand == rhs.MaxNumMergeCand ) && - ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && - ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) && - ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && - ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) && - ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && - ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) && - ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && - ( slice_qp_delta == rhs.slice_qp_delta ) && - ( reserved1 == rhs.reserved1 ) && + return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) && + ( collocated_ref_idx == rhs.collocated_ref_idx ) && ( MaxNumMergeCand == rhs.MaxNumMergeCand ) && + ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) && + ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) && + ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) && + ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( pWeightTable == rhs.pWeightTable ); } @@ -3570,8 +3354,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && - ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && - ( reserved == rhs.reserved ); + ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3611,13 +3394,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && - ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && - ( RefPicList0 == rhs.RefPicList0 ) && - ( RefPicList1 == rhs.RefPicList1 ) && - ( list_entry_l0 == rhs.list_entry_l0 ) && - ( list_entry_l1 == rhs.list_entry_l1 ); + return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && + ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && + ( RefPicList1 == rhs.RefPicList1 ) && ( list_entry_l0 == rhs.list_entry_l0 ) && ( list_entry_l1 == rhs.list_entry_l1 ); } bool operator!=( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3661,16 +3440,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( is_reference == rhs.is_reference ) && - ( IrapPicFlag == rhs.IrapPicFlag ) && - ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && - ( discardable_flag == rhs.discardable_flag ) && - ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && - ( pic_output_flag == rhs.pic_output_flag ) && + return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) && + ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( discardable_flag == rhs.discardable_flag ) && + ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && ( pic_output_flag == rhs.pic_output_flag ) && ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ) && - ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && - ( reserved == rhs.reserved ); + ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3717,13 +3492,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( num_long_term_sps == rhs.num_long_term_sps ) && - ( num_long_term_pics == rhs.num_long_term_pics ) && - ( lt_idx_sps == rhs.lt_idx_sps ) && - ( poc_lsb_lt == rhs.poc_lsb_lt ) && - ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) && - ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && - ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt ); + return ( num_long_term_sps == rhs.num_long_term_sps ) && ( num_long_term_pics == rhs.num_long_term_pics ) && ( lt_idx_sps == rhs.lt_idx_sps ) && + ( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) && + ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt ); } bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3767,18 +3538,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( pic_type == rhs.pic_type ) && - ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && - ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && - ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && - ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && - ( PicOrderCntVal == rhs.PicOrderCntVal ) && - ( TemporalId == rhs.TemporalId ) && - ( reserved1 == rhs.reserved1 ) && - ( pRefLists == rhs.pRefLists ) && - ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && - ( pLongTermRefPics == rhs.pLongTermRefPics ); + return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && + ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && + ( TemporalId == rhs.TemporalId ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ) && + ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPics == rhs.pLongTermRefPics ); } bool operator!=( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -3827,8 +3591,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && - ( unused_for_reference == rhs.unused_for_reference ) && + return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) && ( reserved == rhs.reserved ); } @@ -3953,12 +3716,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( BitDepth == rhs.BitDepth ) && - ( subsampling_x == rhs.subsampling_x ) && - ( subsampling_y == rhs.subsampling_y ) && - ( reserved1 == rhs.reserved1 ) && - ( color_space == rhs.color_space ); + return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && + ( reserved1 == rhs.reserved1 ) && ( color_space == rhs.color_space ); } bool operator!=( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4001,8 +3760,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && - ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && + return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && ( reserved == rhs.reserved ); } @@ -4043,13 +3801,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( loop_filter_level == rhs.loop_filter_level ) && - ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && - ( update_ref_delta == rhs.update_ref_delta ) && - ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && - ( update_mode_delta == rhs.update_mode_delta ) && - ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); + return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && + ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && + ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); } bool operator!=( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4093,10 +3847,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( segmentation_update_map == rhs.segmentation_update_map ) && - ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && - ( segmentation_update_data == rhs.segmentation_update_data ) && - ( segmentation_abs_or_delta_update == rhs.segmentation_abs_or_delta_update ) && + return ( segmentation_update_map == rhs.segmentation_update_map ) && ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && + ( segmentation_update_data == rhs.segmentation_update_data ) && ( segmentation_abs_or_delta_update == rhs.segmentation_abs_or_delta_update ) && ( reserved == rhs.reserved ); } @@ -4139,11 +3891,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( segmentation_tree_probs == rhs.segmentation_tree_probs ) && - ( segmentation_pred_prob == rhs.segmentation_pred_prob ) && - ( FeatureEnabled == rhs.FeatureEnabled ) && - ( FeatureData == rhs.FeatureData ); + return ( flags == rhs.flags ) && ( segmentation_tree_probs == rhs.segmentation_tree_probs ) && + ( segmentation_pred_prob == rhs.segmentation_pred_prob ) && ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData ); } bool operator!=( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4189,15 +3938,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( error_resilient_mode == rhs.error_resilient_mode ) && - ( intra_only == rhs.intra_only ) && - ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && - ( refresh_frame_context == rhs.refresh_frame_context ) && - ( frame_parallel_decoding_mode == rhs.frame_parallel_decoding_mode ) && - ( segmentation_enabled == rhs.segmentation_enabled ) && - ( show_frame == rhs.show_frame ) && - ( UsePrevFrameMvs == rhs.UsePrevFrameMvs ) && - ( reserved == rhs.reserved ); + return ( error_resilient_mode == rhs.error_resilient_mode ) && ( intra_only == rhs.intra_only ) && + ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && ( refresh_frame_context == rhs.refresh_frame_context ) && + ( frame_parallel_decoding_mode == rhs.frame_parallel_decoding_mode ) && ( segmentation_enabled == rhs.segmentation_enabled ) && + ( show_frame == rhs.show_frame ) && ( UsePrevFrameMvs == rhs.UsePrevFrameMvs ) && ( reserved == rhs.reserved ); } bool operator!=( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4243,23 +3987,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( profile == rhs.profile ) && - ( frame_type == rhs.frame_type ) && - ( frame_context_idx == rhs.frame_context_idx ) && - ( reset_frame_context == rhs.reset_frame_context ) && - ( refresh_frame_flags == rhs.refresh_frame_flags ) && - ( ref_frame_sign_bias_mask == rhs.ref_frame_sign_bias_mask ) && - ( interpolation_filter == rhs.interpolation_filter ) && - ( base_q_idx == rhs.base_q_idx ) && - ( delta_q_y_dc == rhs.delta_q_y_dc ) && - ( delta_q_uv_dc == rhs.delta_q_uv_dc ) && - ( delta_q_uv_ac == rhs.delta_q_uv_ac ) && - ( tile_cols_log2 == rhs.tile_cols_log2 ) && - ( tile_rows_log2 == rhs.tile_rows_log2 ) && - ( reserved1 == rhs.reserved1 ) && - ( pColorConfig == rhs.pColorConfig ) && - ( pLoopFilter == rhs.pLoopFilter ) && + return ( flags == rhs.flags ) && ( profile == rhs.profile ) && ( frame_type == rhs.frame_type ) && ( frame_context_idx == rhs.frame_context_idx ) && + ( reset_frame_context == rhs.reset_frame_context ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && + ( ref_frame_sign_bias_mask == rhs.ref_frame_sign_bias_mask ) && ( interpolation_filter == rhs.interpolation_filter ) && + ( base_q_idx == rhs.base_q_idx ) && ( delta_q_y_dc == rhs.delta_q_y_dc ) && ( delta_q_uv_dc == rhs.delta_q_uv_dc ) && + ( delta_q_uv_ac == rhs.delta_q_uv_ac ) && ( tile_cols_log2 == rhs.tile_cols_log2 ) && ( tile_rows_log2 == rhs.tile_rows_log2 ) && + ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pLoopFilter == rhs.pLoopFilter ) && ( pSegmentation == rhs.pSegmentation ); } @@ -4320,11 +4053,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( mono_chrome == rhs.mono_chrome ) && - ( color_range == rhs.color_range ) && - ( separate_uv_delta_q == rhs.separate_uv_delta_q ) && - ( color_description_present_flag == rhs.color_description_present_flag ) && - ( reserved == rhs.reserved ); + return ( mono_chrome == rhs.mono_chrome ) && ( color_range == rhs.color_range ) && ( separate_uv_delta_q == rhs.separate_uv_delta_q ) && + ( color_description_present_flag == rhs.color_description_present_flag ) && ( reserved == rhs.reserved ); } bool operator!=( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4366,15 +4096,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( BitDepth == rhs.BitDepth ) && - ( subsampling_x == rhs.subsampling_x ) && - ( subsampling_y == rhs.subsampling_y ) && - ( reserved1 == rhs.reserved1 ) && - ( color_primaries == rhs.color_primaries ) && - ( transfer_characteristics == rhs.transfer_characteristics ) && - ( matrix_coefficients == rhs.matrix_coefficients ) && - ( chroma_sample_position == rhs.chroma_sample_position ); + return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && + ( reserved1 == rhs.reserved1 ) && ( color_primaries == rhs.color_primaries ) && ( transfer_characteristics == rhs.transfer_characteristics ) && + ( matrix_coefficients == rhs.matrix_coefficients ) && ( chroma_sample_position == rhs.chroma_sample_position ); } bool operator!=( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4463,9 +4187,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && - ( time_scale == rhs.time_scale ) && + return ( flags == rhs.flags ) && ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && ( time_scale == rhs.time_scale ) && ( num_ticks_per_picture_minus_1 == rhs.num_ticks_per_picture_minus_1 ); } @@ -4507,8 +4229,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && - ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && + return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && ( reserved == rhs.reserved ); } @@ -4549,13 +4270,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( loop_filter_level == rhs.loop_filter_level ) && - ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && - ( update_ref_delta == rhs.update_ref_delta ) && - ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && - ( update_mode_delta == rhs.update_mode_delta ) && - ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); + return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && + ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && + ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); } bool operator!=( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4639,16 +4356,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( base_q_idx == rhs.base_q_idx ) && - ( DeltaQYDc == rhs.DeltaQYDc ) && - ( DeltaQUDc == rhs.DeltaQUDc ) && - ( DeltaQUAc == rhs.DeltaQUAc ) && - ( DeltaQVDc == rhs.DeltaQVDc ) && - ( DeltaQVAc == rhs.DeltaQVAc ) && - ( qm_y == rhs.qm_y ) && - ( qm_u == rhs.qm_u ) && - ( qm_v == rhs.qm_v ); + return ( flags == rhs.flags ) && ( base_q_idx == rhs.base_q_idx ) && ( DeltaQYDc == rhs.DeltaQYDc ) && ( DeltaQUDc == rhs.DeltaQUDc ) && + ( DeltaQUAc == rhs.DeltaQUAc ) && ( DeltaQVDc == rhs.DeltaQVDc ) && ( DeltaQVAc == rhs.DeltaQVAc ) && ( qm_y == rhs.qm_y ) && + ( qm_u == rhs.qm_u ) && ( qm_v == rhs.qm_v ); } bool operator!=( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4773,16 +4483,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( TileCols == rhs.TileCols ) && - ( TileRows == rhs.TileRows ) && - ( context_update_tile_id == rhs.context_update_tile_id ) && - ( tile_size_bytes_minus_1 == rhs.tile_size_bytes_minus_1 ) && - ( reserved1 == rhs.reserved1 ) && - ( pMiColStarts == rhs.pMiColStarts ) && - ( pMiRowStarts == rhs.pMiRowStarts ) && - ( pWidthInSbsMinus1 == rhs.pWidthInSbsMinus1 ) && - ( pHeightInSbsMinus1 == rhs.pHeightInSbsMinus1 ); + return ( flags == rhs.flags ) && ( TileCols == rhs.TileCols ) && ( TileRows == rhs.TileRows ) && + ( context_update_tile_id == rhs.context_update_tile_id ) && ( tile_size_bytes_minus_1 == rhs.tile_size_bytes_minus_1 ) && + ( reserved1 == rhs.reserved1 ) && ( pMiColStarts == rhs.pMiColStarts ) && ( pMiRowStarts == rhs.pMiRowStarts ) && + ( pWidthInSbsMinus1 == rhs.pWidthInSbsMinus1 ) && ( pHeightInSbsMinus1 == rhs.pHeightInSbsMinus1 ); } bool operator!=( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -4829,11 +4533,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && - ( cdef_bits == rhs.cdef_bits ) && - ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) && - ( cdef_y_sec_strength == rhs.cdef_y_sec_strength ) && - ( cdef_uv_pri_strength == rhs.cdef_uv_pri_strength ) && + return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && ( cdef_bits == rhs.cdef_bits ) && ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) && + ( cdef_y_sec_strength == rhs.cdef_y_sec_strength ) && ( cdef_uv_pri_strength == rhs.cdef_uv_pri_strength ) && ( cdef_uv_sec_strength == rhs.cdef_uv_sec_strength ); } @@ -4955,11 +4656,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && - ( overlap_flag == rhs.overlap_flag ) && - ( clip_to_restricted_range == rhs.clip_to_restricted_range ) && - ( update_grain == rhs.update_grain ) && - ( reserved == rhs.reserved ); + return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && ( overlap_flag == rhs.overlap_flag ) && + ( clip_to_restricted_range == rhs.clip_to_restricted_range ) && ( update_grain == rhs.update_grain ) && ( reserved == rhs.reserved ); } bool operator!=( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5001,31 +4699,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && - ( ar_coeff_lag == rhs.ar_coeff_lag ) && - ( ar_coeff_shift_minus_6 == rhs.ar_coeff_shift_minus_6 ) && - ( grain_scale_shift == rhs.grain_scale_shift ) && - ( grain_seed == rhs.grain_seed ) && - ( film_grain_params_ref_idx == rhs.film_grain_params_ref_idx ) && - ( num_y_points == rhs.num_y_points ) && - ( point_y_value == rhs.point_y_value ) && - ( point_y_scaling == rhs.point_y_scaling ) && - ( num_cb_points == rhs.num_cb_points ) && - ( point_cb_value == rhs.point_cb_value ) && - ( point_cb_scaling == rhs.point_cb_scaling ) && - ( num_cr_points == rhs.num_cr_points ) && - ( point_cr_value == rhs.point_cr_value ) && - ( point_cr_scaling == rhs.point_cr_scaling ) && - ( ar_coeffs_y_plus_128 == rhs.ar_coeffs_y_plus_128 ) && - ( ar_coeffs_cb_plus_128 == rhs.ar_coeffs_cb_plus_128 ) && - ( ar_coeffs_cr_plus_128 == rhs.ar_coeffs_cr_plus_128 ) && - ( cb_mult == rhs.cb_mult ) && - ( cb_luma_mult == rhs.cb_luma_mult ) && - ( cb_offset == rhs.cb_offset ) && - ( cr_mult == rhs.cr_mult ) && - ( cr_luma_mult == rhs.cr_luma_mult ) && - ( cr_offset == rhs.cr_offset ); + return ( flags == rhs.flags ) && ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && ( ar_coeff_lag == rhs.ar_coeff_lag ) && + ( ar_coeff_shift_minus_6 == rhs.ar_coeff_shift_minus_6 ) && ( grain_scale_shift == rhs.grain_scale_shift ) && ( grain_seed == rhs.grain_seed ) && + ( film_grain_params_ref_idx == rhs.film_grain_params_ref_idx ) && ( num_y_points == rhs.num_y_points ) && + ( point_y_value == rhs.point_y_value ) && ( point_y_scaling == rhs.point_y_scaling ) && ( num_cb_points == rhs.num_cb_points ) && + ( point_cb_value == rhs.point_cb_value ) && ( point_cb_scaling == rhs.point_cb_scaling ) && ( num_cr_points == rhs.num_cr_points ) && + ( point_cr_value == rhs.point_cr_value ) && ( point_cr_scaling == rhs.point_cr_scaling ) && + ( ar_coeffs_y_plus_128 == rhs.ar_coeffs_y_plus_128 ) && ( ar_coeffs_cb_plus_128 == rhs.ar_coeffs_cb_plus_128 ) && + ( ar_coeffs_cr_plus_128 == rhs.ar_coeffs_cr_plus_128 ) && ( cb_mult == rhs.cb_mult ) && ( cb_luma_mult == rhs.cb_luma_mult ) && + ( cb_offset == rhs.cb_offset ) && ( cr_mult == rhs.cr_mult ) && ( cr_luma_mult == rhs.cr_luma_mult ) && ( cr_offset == rhs.cr_offset ); } bool operator!=( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5087,26 +4769,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( still_picture == rhs.still_picture ) && - ( reduced_still_picture_header == rhs.reduced_still_picture_header ) && - ( use_128x128_superblock == rhs.use_128x128_superblock ) && - ( enable_filter_intra == rhs.enable_filter_intra ) && - ( enable_intra_edge_filter == rhs.enable_intra_edge_filter ) && - ( enable_interintra_compound == rhs.enable_interintra_compound ) && - ( enable_masked_compound == rhs.enable_masked_compound ) && - ( enable_warped_motion == rhs.enable_warped_motion ) && - ( enable_dual_filter == rhs.enable_dual_filter ) && - ( enable_order_hint == rhs.enable_order_hint ) && - ( enable_jnt_comp == rhs.enable_jnt_comp ) && - ( enable_ref_frame_mvs == rhs.enable_ref_frame_mvs ) && - ( frame_id_numbers_present_flag == rhs.frame_id_numbers_present_flag ) && - ( enable_superres == rhs.enable_superres ) && - ( enable_cdef == rhs.enable_cdef ) && - ( enable_restoration == rhs.enable_restoration ) && - ( film_grain_params_present == rhs.film_grain_params_present ) && - ( timing_info_present_flag == rhs.timing_info_present_flag ) && - ( initial_display_delay_present_flag == rhs.initial_display_delay_present_flag ) && - ( reserved == rhs.reserved ); + return ( still_picture == rhs.still_picture ) && ( reduced_still_picture_header == rhs.reduced_still_picture_header ) && + ( use_128x128_superblock == rhs.use_128x128_superblock ) && ( enable_filter_intra == rhs.enable_filter_intra ) && + ( enable_intra_edge_filter == rhs.enable_intra_edge_filter ) && ( enable_interintra_compound == rhs.enable_interintra_compound ) && + ( enable_masked_compound == rhs.enable_masked_compound ) && ( enable_warped_motion == rhs.enable_warped_motion ) && + ( enable_dual_filter == rhs.enable_dual_filter ) && ( enable_order_hint == rhs.enable_order_hint ) && + ( enable_jnt_comp == rhs.enable_jnt_comp ) && ( enable_ref_frame_mvs == rhs.enable_ref_frame_mvs ) && + ( frame_id_numbers_present_flag == rhs.frame_id_numbers_present_flag ) && ( enable_superres == rhs.enable_superres ) && + ( enable_cdef == rhs.enable_cdef ) && ( enable_restoration == rhs.enable_restoration ) && + ( film_grain_params_present == rhs.film_grain_params_present ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && + ( initial_display_delay_present_flag == rhs.initial_display_delay_present_flag ) && ( reserved == rhs.reserved ); } bool operator!=( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5163,20 +4835,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( seq_profile == rhs.seq_profile ) && - ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) && - ( frame_height_bits_minus_1 == rhs.frame_height_bits_minus_1 ) && - ( max_frame_width_minus_1 == rhs.max_frame_width_minus_1 ) && - ( max_frame_height_minus_1 == rhs.max_frame_height_minus_1 ) && - ( delta_frame_id_length_minus_2 == rhs.delta_frame_id_length_minus_2 ) && - ( additional_frame_id_length_minus_1 == rhs.additional_frame_id_length_minus_1 ) && - ( order_hint_bits_minus_1 == rhs.order_hint_bits_minus_1 ) && - ( seq_force_integer_mv == rhs.seq_force_integer_mv ) && - ( seq_force_screen_content_tools == rhs.seq_force_screen_content_tools ) && - ( reserved1 == rhs.reserved1 ) && - ( pColorConfig == rhs.pColorConfig ) && - ( pTimingInfo == rhs.pTimingInfo ); + return ( flags == rhs.flags ) && ( seq_profile == rhs.seq_profile ) && ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) && + ( frame_height_bits_minus_1 == rhs.frame_height_bits_minus_1 ) && ( max_frame_width_minus_1 == rhs.max_frame_width_minus_1 ) && + ( max_frame_height_minus_1 == rhs.max_frame_height_minus_1 ) && ( delta_frame_id_length_minus_2 == rhs.delta_frame_id_length_minus_2 ) && + ( additional_frame_id_length_minus_1 == rhs.additional_frame_id_length_minus_1 ) && ( order_hint_bits_minus_1 == rhs.order_hint_bits_minus_1 ) && + ( seq_force_integer_mv == rhs.seq_force_integer_mv ) && ( seq_force_screen_content_tools == rhs.seq_force_screen_content_tools ) && + ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pTimingInfo == rhs.pTimingInfo ); } bool operator!=( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5231,36 +4895,19 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( error_resilient_mode == rhs.error_resilient_mode ) && - ( disable_cdf_update == rhs.disable_cdf_update ) && - ( use_superres == rhs.use_superres ) && - ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && - ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && - ( is_filter_switchable == rhs.is_filter_switchable ) && - ( force_integer_mv == rhs.force_integer_mv ) && - ( frame_size_override_flag == rhs.frame_size_override_flag ) && - ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && - ( allow_intrabc == rhs.allow_intrabc ) && - ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && - ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && - ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && - ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && - ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && - ( allow_warped_motion == rhs.allow_warped_motion ) && - ( reduced_tx_set == rhs.reduced_tx_set ) && - ( reference_select == rhs.reference_select ) && - ( skip_mode_present == rhs.skip_mode_present ) && - ( delta_q_present == rhs.delta_q_present ) && - ( delta_lf_present == rhs.delta_lf_present ) && - ( delta_lf_multi == rhs.delta_lf_multi ) && - ( segmentation_enabled == rhs.segmentation_enabled ) && - ( segmentation_update_map == rhs.segmentation_update_map ) && - ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && - ( segmentation_update_data == rhs.segmentation_update_data ) && - ( UsesLr == rhs.UsesLr ) && - ( usesChromaLr == rhs.usesChromaLr ) && - ( apply_grain == rhs.apply_grain ) && - ( reserved == rhs.reserved ); + return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && + ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && + ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && + ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && + ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && + ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && + ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && + ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && + ( reduced_tx_set == rhs.reduced_tx_set ) && ( reference_select == rhs.reference_select ) && ( skip_mode_present == rhs.skip_mode_present ) && + ( delta_q_present == rhs.delta_q_present ) && ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && + ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && + ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && + ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( apply_grain == rhs.apply_grain ) && ( reserved == rhs.reserved ); } bool operator!=( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5327,30 +4974,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( frame_type == rhs.frame_type ) && - ( current_frame_id == rhs.current_frame_id ) && - ( OrderHint == rhs.OrderHint ) && - ( primary_ref_frame == rhs.primary_ref_frame ) && - ( refresh_frame_flags == rhs.refresh_frame_flags ) && - ( reserved1 == rhs.reserved1 ) && - ( interpolation_filter == rhs.interpolation_filter ) && - ( TxMode == rhs.TxMode ) && - ( delta_q_res == rhs.delta_q_res ) && - ( delta_lf_res == rhs.delta_lf_res ) && - ( SkipModeFrame == rhs.SkipModeFrame ) && - ( coded_denom == rhs.coded_denom ) && - ( reserved2 == rhs.reserved2 ) && - ( OrderHints == rhs.OrderHints ) && - ( expectedFrameId == rhs.expectedFrameId ) && - ( pTileInfo == rhs.pTileInfo ) && - ( pQuantization == rhs.pQuantization ) && - ( pSegmentation == rhs.pSegmentation ) && - ( pLoopFilter == rhs.pLoopFilter ) && - ( pCDEF == rhs.pCDEF ) && - ( pLoopRestoration == rhs.pLoopRestoration ) && - ( pGlobalMotion == rhs.pGlobalMotion ) && - ( pFilmGrain == rhs.pFilmGrain ); + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( current_frame_id == rhs.current_frame_id ) && ( OrderHint == rhs.OrderHint ) && + ( primary_ref_frame == rhs.primary_ref_frame ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( reserved1 == rhs.reserved1 ) && + ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && + ( delta_lf_res == rhs.delta_lf_res ) && ( SkipModeFrame == rhs.SkipModeFrame ) && ( coded_denom == rhs.coded_denom ) && + ( reserved2 == rhs.reserved2 ) && ( OrderHints == rhs.OrderHints ) && ( expectedFrameId == rhs.expectedFrameId ) && + ( pTileInfo == rhs.pTileInfo ) && ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && + ( pLoopFilter == rhs.pLoopFilter ) && ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && + ( pGlobalMotion == rhs.pGlobalMotion ) && ( pFilmGrain == rhs.pFilmGrain ); } bool operator!=( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5412,8 +5043,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && - ( segmentation_enabled == rhs.segmentation_enabled ) && + return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && ( reserved == rhs.reserved ); } @@ -5454,10 +5084,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( frame_type == rhs.frame_type ) && - ( RefFrameSignBias == rhs.RefFrameSignBias ) && - ( OrderHint == rhs.OrderHint ) && + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( RefFrameSignBias == rhs.RefFrameSignBias ) && ( OrderHint == rhs.OrderHint ) && ( SavedOrderHints == rhs.SavedOrderHints ); } @@ -5506,8 +5133,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) && ( buffer_removal_time_length_minus_1 == rhs.buffer_removal_time_length_minus_1 ) && - ( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && - ( reserved1 == rhs.reserved1 ) && + ( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && ( reserved1 == rhs.reserved1 ) && ( num_units_in_decoding_tick == rhs.num_units_in_decoding_tick ); } @@ -5589,10 +5215,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && - ( low_delay_mode_flag == rhs.low_delay_mode_flag ) && - ( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && - ( reserved == rhs.reserved ); + return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) && + ( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5633,12 +5257,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( operating_point_idc == rhs.operating_point_idc ) && - ( seq_level_idx == rhs.seq_level_idx ) && - ( seq_tier == rhs.seq_tier ) && - ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && - ( encoder_buffer_delay == rhs.encoder_buffer_delay ) && + return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) && + ( seq_tier == rhs.seq_tier ) && ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && ( encoder_buffer_delay == rhs.encoder_buffer_delay ) && ( initial_display_delay_minus_1 == rhs.initial_display_delay_minus_1 ); } @@ -5683,36 +5303,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( error_resilient_mode == rhs.error_resilient_mode ) && - ( disable_cdf_update == rhs.disable_cdf_update ) && - ( use_superres == rhs.use_superres ) && - ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && - ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && - ( is_filter_switchable == rhs.is_filter_switchable ) && - ( force_integer_mv == rhs.force_integer_mv ) && - ( frame_size_override_flag == rhs.frame_size_override_flag ) && - ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && - ( allow_intrabc == rhs.allow_intrabc ) && - ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && - ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && - ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && - ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && - ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && - ( allow_warped_motion == rhs.allow_warped_motion ) && - ( reduced_tx_set == rhs.reduced_tx_set ) && - ( skip_mode_present == rhs.skip_mode_present ) && - ( delta_q_present == rhs.delta_q_present ) && - ( delta_lf_present == rhs.delta_lf_present ) && - ( delta_lf_multi == rhs.delta_lf_multi ) && - ( segmentation_enabled == rhs.segmentation_enabled ) && - ( segmentation_update_map == rhs.segmentation_update_map ) && - ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && - ( segmentation_update_data == rhs.segmentation_update_data ) && - ( UsesLr == rhs.UsesLr ) && - ( usesChromaLr == rhs.usesChromaLr ) && - ( show_frame == rhs.show_frame ) && - ( showable_frame == rhs.showable_frame ) && - ( reserved == rhs.reserved ); + return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && + ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && + ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && + ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && + ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && + ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && + ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && + ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && + ( reduced_tx_set == rhs.reduced_tx_set ) && ( skip_mode_present == rhs.skip_mode_present ) && ( delta_q_present == rhs.delta_q_present ) && + ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && + ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && + ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && + ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( show_frame == rhs.show_frame ) && + ( showable_frame == rhs.showable_frame ) && ( reserved == rhs.reserved ); } bool operator!=( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5779,33 +5383,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( frame_type == rhs.frame_type ) && - ( frame_presentation_time == rhs.frame_presentation_time ) && - ( current_frame_id == rhs.current_frame_id ) && - ( order_hint == rhs.order_hint ) && - ( primary_ref_frame == rhs.primary_ref_frame ) && - ( refresh_frame_flags == rhs.refresh_frame_flags ) && - ( coded_denom == rhs.coded_denom ) && - ( render_width_minus_1 == rhs.render_width_minus_1 ) && - ( render_height_minus_1 == rhs.render_height_minus_1 ) && - ( interpolation_filter == rhs.interpolation_filter ) && - ( TxMode == rhs.TxMode ) && - ( delta_q_res == rhs.delta_q_res ) && - ( delta_lf_res == rhs.delta_lf_res ) && - ( ref_order_hint == rhs.ref_order_hint ) && - ( ref_frame_idx == rhs.ref_frame_idx ) && - ( reserved1 == rhs.reserved1 ) && - ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && - ( pTileInfo == rhs.pTileInfo ) && - ( pQuantization == rhs.pQuantization ) && - ( pSegmentation == rhs.pSegmentation ) && - ( pLoopFilter == rhs.pLoopFilter ) && - ( pCDEF == rhs.pCDEF ) && - ( pLoopRestoration == rhs.pLoopRestoration ) && - ( pGlobalMotion == rhs.pGlobalMotion ) && - ( pExtensionHeader == rhs.pExtensionHeader ) && - ( pBufferRemovalTimes == rhs.pBufferRemovalTimes ); + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) && + ( current_frame_id == rhs.current_frame_id ) && ( order_hint == rhs.order_hint ) && ( primary_ref_frame == rhs.primary_ref_frame ) && + ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( coded_denom == rhs.coded_denom ) && + ( render_width_minus_1 == rhs.render_width_minus_1 ) && ( render_height_minus_1 == rhs.render_height_minus_1 ) && + ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && + ( delta_lf_res == rhs.delta_lf_res ) && ( ref_order_hint == rhs.ref_order_hint ) && ( ref_frame_idx == rhs.ref_frame_idx ) && + ( reserved1 == rhs.reserved1 ) && ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && ( pTileInfo == rhs.pTileInfo ) && + ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && ( pLoopFilter == rhs.pLoopFilter ) && + ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && ( pGlobalMotion == rhs.pGlobalMotion ) && + ( pExtensionHeader == rhs.pExtensionHeader ) && ( pBufferRemovalTimes == rhs.pBufferRemovalTimes ); } bool operator!=( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT @@ -5870,8 +5457,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && - ( segmentation_enabled == rhs.segmentation_enabled ) && + return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && ( reserved == rhs.reserved ); } @@ -5912,12 +5498,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && - ( RefFrameId == rhs.RefFrameId ) && - ( frame_type == rhs.frame_type ) && - ( OrderHint == rhs.OrderHint ) && - ( reserved1 == rhs.reserved1 ) && - ( pExtensionHeader == rhs.pExtensionHeader ); + return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) && + ( reserved1 == rhs.reserved1 ) && ( pExtensionHeader == rhs.pExtensionHeader ); } bool operator!=( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT