From 6b67355878f28d52041b9b34be212e4b7dcf365e Mon Sep 17 00:00:00 2001 From: kbJeff-8 Date: Sun, 22 Mar 2026 01:03:14 +0000 Subject: [PATCH] [BOT] update dependencies --- third_party/vulkan/vulkan.cppm | 6 +- third_party/vulkan/vulkan.hpp | 127 +- third_party/vulkan/vulkan_core.h | 219 ++- third_party/vulkan/vulkan_enums.hpp | 86 +- .../vulkan/vulkan_extension_inspection.hpp | 50 +- third_party/vulkan/vulkan_funcs.hpp | 94 ++ third_party/vulkan/vulkan_handles.hpp | 54 +- third_party/vulkan/vulkan_hash.hpp | 165 ++- third_party/vulkan/vulkan_raii.hpp | 55 + .../vulkan/vulkan_static_assertions.hpp | 96 +- third_party/vulkan/vulkan_structs.hpp | 1223 +++++++++++++++-- third_party/vulkan/vulkan_to_string.hpp | 99 +- 12 files changed, 1992 insertions(+), 282 deletions(-) diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index f41a508..c81e11c 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 == 346, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 347, "Wrong VK_HEADER_VERSION!" ); #if defined( _MSC_VER ) # pragma warning( push ) @@ -1259,6 +1259,10 @@ export using ::PFN_vkUpdateIndirectExecutionSetPipelineEXT; using ::PFN_vkUpdateIndirectExecutionSetShaderEXT; + //=== VK_KHR_device_fault === + using ::PFN_vkGetDeviceFaultDebugInfoKHR; + using ::PFN_vkGetDeviceFaultReportsKHR; + #if defined( VK_USE_PLATFORM_OHOS ) //=== VK_OHOS_surface === using ::PFN_vkCreateSurfaceOHOS; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 936cf08..2e6ae3c 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 == 346, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 347, "Wrong VK_HEADER_VERSION!" ); VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { @@ -1621,7 +1621,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirements ) DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirementsKHR ) DECLARE_IS_DISPATCHED( vkGetDeviceCombinedImageSamplerIndexNVX ) + DECLARE_IS_DISPATCHED( vkGetDeviceFaultDebugInfoKHR ) DECLARE_IS_DISPATCHED( vkGetDeviceFaultInfoEXT ) + DECLARE_IS_DISPATCHED( vkGetDeviceFaultReportsKHR ) DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeatures ) DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeaturesKHR ) DECLARE_IS_DISPATCHED( vkGetDeviceGroupPresentCapabilitiesKHR ) @@ -7884,6 +7886,21 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites ); } + //=== VK_KHR_device_fault === + + VULKAN_HPP_INLINE VkResult vkGetDeviceFaultReportsKHR( VkDevice device, + uint64_t timeout, + uint32_t * pFaultCounts, + VkDeviceFaultInfoKHR * pFaultInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceFaultReportsKHR( device, timeout, pFaultCounts, pFaultInfo ); + } + + VULKAN_HPP_INLINE VkResult vkGetDeviceFaultDebugInfoKHR( VkDevice device, VkDeviceFaultDebugInfoKHR * pDebugInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceFaultDebugInfoKHR( device, pDebugInfo ); + } + # if defined( VK_USE_PLATFORM_OHOS ) //=== VK_OHOS_surface === @@ -10020,10 +10037,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemorySpecVersion = VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemoryExtensionName = VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME; + //=== VK_KHR_shader_constant_data === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderConstantDataSpecVersion = VK_KHR_SHADER_CONSTANT_DATA_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderConstantDataExtensionName = VK_KHR_SHADER_CONSTANT_DATA_EXTENSION_NAME; + //=== VK_KHR_dynamic_rendering_local_read === VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadSpecVersion = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadExtensionName = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME; + //=== VK_KHR_shader_abort === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAbortSpecVersion = VK_KHR_SHADER_ABORT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAbortExtensionName = VK_KHR_SHADER_ABORT_EXTENSION_NAME; + //=== VK_EXT_shader_image_atomic_int64 === VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64SpecVersion = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64ExtensionName = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME; @@ -10948,6 +10973,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsSpecVersion = VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsExtensionName = VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME; + //=== VK_KHR_device_fault === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceFaultSpecVersion = VK_KHR_DEVICE_FAULT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceFaultExtensionName = VK_KHR_DEVICE_FAULT_EXTENSION_NAME; + //=== VK_KHR_maintenance8 === VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8SpecVersion = VK_KHR_MAINTENANCE_8_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8ExtensionName = VK_KHR_MAINTENANCE_8_EXTENSION_NAME; @@ -15428,6 +15457,62 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_shader_constant_data === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_abort === + 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_shader_image_atomic_int64 === template <> struct StructExtends @@ -20890,6 +20975,34 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_device_fault === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_KHR_maintenance8 === template <> struct StructExtends @@ -23281,6 +23394,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0; PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0; + //=== VK_KHR_device_fault === + PFN_vkGetDeviceFaultReportsKHR vkGetDeviceFaultReportsKHR = 0; + PFN_vkGetDeviceFaultDebugInfoKHR vkGetDeviceFaultDebugInfoKHR = 0; + #if defined( VK_USE_PLATFORM_OHOS ) //=== VK_OHOS_surface === PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0; @@ -24990,6 +25107,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE vkUpdateIndirectExecutionSetShaderEXT = PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetShaderEXT" ) ); + //=== VK_KHR_device_fault === + vkGetDeviceFaultReportsKHR = PFN_vkGetDeviceFaultReportsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultReportsKHR" ) ); + vkGetDeviceFaultDebugInfoKHR = PFN_vkGetDeviceFaultDebugInfoKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultDebugInfoKHR" ) ); + #if defined( VK_USE_PLATFORM_OHOS ) //=== VK_OHOS_surface === vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) ); @@ -26318,6 +26439,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE vkUpdateIndirectExecutionSetShaderEXT = PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) ); + //=== VK_KHR_device_fault === + vkGetDeviceFaultReportsKHR = PFN_vkGetDeviceFaultReportsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceFaultReportsKHR" ) ); + vkGetDeviceFaultDebugInfoKHR = PFN_vkGetDeviceFaultDebugInfoKHR( vkGetDeviceProcAddr( device, "vkGetDeviceFaultDebugInfoKHR" ) ); + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_external_memory_metal === vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index 304303b..e57cd25 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 346 +#define VK_HEADER_VERSION 347 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -797,6 +797,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR = 1000231000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR = 1000233000, + VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR = 1000233001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR = 1000233002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, @@ -1350,6 +1354,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR = 1000573000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR = 1000573001, + VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR = 1000573002, + VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR = 1000573003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR = 1000574000, VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR = 1000574002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, @@ -3658,9 +3666,9 @@ typedef struct VkDeviceCreateInfo { VkDeviceCreateFlags flags; uint32_t queueCreateInfoCount; const VkDeviceQueueCreateInfo* pQueueCreateInfos; - // enabledLayerCount is legacy and ignored + // enabledLayerCount is legacy and not used uint32_t enabledLayerCount; - // ppEnabledLayerNames is legacy and ignored + // ppEnabledLayerNames is legacy and not used const char* const* ppEnabledLayerNames; uint32_t enabledExtensionCount; const char* const* ppEnabledExtensionNames; @@ -11710,6 +11718,18 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( #endif +// VK_KHR_shader_constant_data is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_constant_data 1 +#define VK_KHR_SHADER_CONSTANT_DATA_SPEC_VERSION 1 +#define VK_KHR_SHADER_CONSTANT_DATA_EXTENSION_NAME "VK_KHR_shader_constant_data" +typedef struct VkPhysicalDeviceShaderConstantDataFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderConstantData; +} VkPhysicalDeviceShaderConstantDataFeaturesKHR; + + + // VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_dynamic_rendering_local_read 1 #define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1 @@ -11738,6 +11758,31 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR( #endif +// VK_KHR_shader_abort is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_abort 1 +#define VK_KHR_SHADER_ABORT_SPEC_VERSION 1 +#define VK_KHR_SHADER_ABORT_EXTENSION_NAME "VK_KHR_shader_abort" +typedef struct VkPhysicalDeviceShaderAbortFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderAbort; +} VkPhysicalDeviceShaderAbortFeaturesKHR; + +typedef struct VkDeviceFaultShaderAbortMessageInfoKHR { + VkStructureType sType; + void* pNext; + uint64_t messageDataSize; + void* pMessageData; +} VkDeviceFaultShaderAbortMessageInfoKHR; + +typedef struct VkPhysicalDeviceShaderAbortPropertiesKHR { + VkStructureType sType; + void* pNext; + uint64_t maxShaderAbortMessageSize; +} VkPhysicalDeviceShaderAbortPropertiesKHR; + + + // VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_shader_quad_control 1 #define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1 @@ -14249,6 +14294,124 @@ typedef struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR { +// VK_KHR_device_fault is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_device_fault 1 +#define VK_KHR_DEVICE_FAULT_SPEC_VERSION 1 +#define VK_KHR_DEVICE_FAULT_EXTENSION_NAME "VK_KHR_device_fault" + +typedef enum VkDeviceFaultAddressTypeKHR { + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_KHR = 0, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_KHR = 1, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_KHR = 2, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_KHR = 3, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_KHR = 4, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_KHR = 5, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_KHR = 6, + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_KHR, + VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceFaultAddressTypeKHR; + +typedef enum VkDeviceFaultVendorBinaryHeaderVersionKHR { + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_KHR = 1, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_KHR, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceFaultVendorBinaryHeaderVersionKHR; + +typedef enum VkDeviceFaultFlagBitsKHR { + VK_DEVICE_FAULT_FLAG_DEVICE_LOST_KHR = 0x00000001, + VK_DEVICE_FAULT_FLAG_MEMORY_ADDRESS_KHR = 0x00000002, + VK_DEVICE_FAULT_FLAG_INSTRUCTION_ADDRESS_KHR = 0x00000004, + VK_DEVICE_FAULT_FLAG_VENDOR_KHR = 0x00000008, + VK_DEVICE_FAULT_FLAG_WATCHDOG_TIMEOUT_KHR = 0x00000010, + VK_DEVICE_FAULT_FLAG_OVERFLOW_KHR = 0x00000020, + VK_DEVICE_FAULT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceFaultFlagBitsKHR; +typedef VkFlags VkDeviceFaultFlagsKHR; +typedef struct VkPhysicalDeviceFaultFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; + VkBool32 deviceFaultReportMasked; + VkBool32 deviceFaultDeviceLostOnMasked; +} VkPhysicalDeviceFaultFeaturesKHR; + +typedef struct VkPhysicalDeviceFaultPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxDeviceFaultCount; +} VkPhysicalDeviceFaultPropertiesKHR; + +typedef struct VkDeviceFaultAddressInfoKHR { + VkDeviceFaultAddressTypeKHR addressType; + VkDeviceAddress reportedAddress; + VkDeviceSize addressPrecision; +} VkDeviceFaultAddressInfoKHR; + +typedef struct VkDeviceFaultVendorInfoKHR { + char description[VK_MAX_DESCRIPTION_SIZE]; + uint64_t vendorFaultCode; + uint64_t vendorFaultData; +} VkDeviceFaultVendorInfoKHR; + +typedef struct VkDeviceFaultInfoKHR { + VkStructureType sType; + void* pNext; + VkDeviceFaultFlagsKHR flags; + uint64_t groupId; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkDeviceFaultAddressInfoKHR faultAddressInfo; + VkDeviceFaultAddressInfoKHR instructionAddressInfo; + VkDeviceFaultVendorInfoKHR vendorInfo; +} VkDeviceFaultInfoKHR; + +typedef struct VkDeviceFaultDebugInfoKHR { + VkStructureType sType; + void* pNext; + uint32_t vendorBinarySize; + void* pVendorBinaryData; +} VkDeviceFaultDebugInfoKHR; + +typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneKHR { + uint32_t headerSize; + VkDeviceFaultVendorBinaryHeaderVersionKHR headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint32_t driverVersion; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + uint32_t applicationNameOffset; + uint32_t applicationVersion; + uint32_t engineNameOffset; + uint32_t engineVersion; + uint32_t apiVersion; +} VkDeviceFaultVendorBinaryHeaderVersionOneKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultReportsKHR)(VkDevice device, uint64_t timeout, uint32_t* pFaultCounts, VkDeviceFaultInfoKHR* pFaultInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultDebugInfoKHR)(VkDevice device, VkDeviceFaultDebugInfoKHR* pDebugInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultReportsKHR( + VkDevice device, + uint64_t timeout, + uint32_t* pFaultCounts, + VkDeviceFaultInfoKHR* pFaultInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultDebugInfoKHR( + VkDevice device, + VkDeviceFaultDebugInfoKHR* pDebugInfo); +#endif +#endif + + // VK_KHR_maintenance8 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_maintenance8 1 #define VK_KHR_MAINTENANCE_8_SPEC_VERSION 1 @@ -20041,22 +20204,10 @@ typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { #define VK_EXT_device_fault 1 #define VK_EXT_DEVICE_FAULT_SPEC_VERSION 2 #define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault" +typedef VkDeviceFaultAddressTypeKHR VkDeviceFaultAddressTypeEXT; -typedef enum VkDeviceFaultAddressTypeEXT { - VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, - VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, - VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, - VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, - VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultAddressTypeEXT; +typedef VkDeviceFaultVendorBinaryHeaderVersionKHR VkDeviceFaultVendorBinaryHeaderVersionEXT; -typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultVendorBinaryHeaderVersionEXT; typedef struct VkPhysicalDeviceFaultFeaturesEXT { VkStructureType sType; void* pNext; @@ -20072,40 +20223,20 @@ typedef struct VkDeviceFaultCountsEXT { VkDeviceSize vendorBinarySize; } VkDeviceFaultCountsEXT; -typedef struct VkDeviceFaultAddressInfoEXT { - VkDeviceFaultAddressTypeEXT addressType; - VkDeviceAddress reportedAddress; - VkDeviceSize addressPrecision; -} VkDeviceFaultAddressInfoEXT; - -typedef struct VkDeviceFaultVendorInfoEXT { - char description[VK_MAX_DESCRIPTION_SIZE]; - uint64_t vendorFaultCode; - uint64_t vendorFaultData; -} VkDeviceFaultVendorInfoEXT; - typedef struct VkDeviceFaultInfoEXT { VkStructureType sType; void* pNext; char description[VK_MAX_DESCRIPTION_SIZE]; - VkDeviceFaultAddressInfoEXT* pAddressInfos; - VkDeviceFaultVendorInfoEXT* pVendorInfos; + VkDeviceFaultAddressInfoKHR* pAddressInfos; + VkDeviceFaultVendorInfoKHR* pVendorInfos; void* pVendorBinaryData; } VkDeviceFaultInfoEXT; -typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { - uint32_t headerSize; - VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint32_t driverVersion; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - uint32_t applicationNameOffset; - uint32_t applicationVersion; - uint32_t engineNameOffset; - uint32_t engineVersion; - uint32_t apiVersion; -} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; +typedef VkDeviceFaultAddressInfoKHR VkDeviceFaultAddressInfoEXT; + +typedef VkDeviceFaultVendorInfoKHR VkDeviceFaultVendorInfoEXT; + +typedef VkDeviceFaultVendorBinaryHeaderVersionOneKHR VkDeviceFaultVendorBinaryHeaderVersionOneEXT; typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index 1729ca5..7cdd9b6 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -1141,6 +1141,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eRenderingFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, ePhysicalDeviceShaderCoreProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, ePhysicalDeviceCoherentMemoryFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, + ePhysicalDeviceShaderConstantDataFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR, + ePhysicalDeviceShaderAbortFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR, + eDeviceFaultShaderAbortMessageInfoKHR = VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR, + ePhysicalDeviceShaderAbortPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR, ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, ePhysicalDeviceShaderQuadControlFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, @@ -1716,6 +1720,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eIndirectExecutionSetShaderLayoutInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT, eGeneratedCommandsPipelineInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT, eGeneratedCommandsShaderInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT, + ePhysicalDeviceFaultFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR, + ePhysicalDeviceFaultPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR, + eDeviceFaultInfoKHR = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR, + eDeviceFaultDebugInfoKHR = VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR, ePhysicalDeviceMaintenance8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, eMemoryBarrierAccessFlags3KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR, ePhysicalDeviceImageAlignmentControlFeaturesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, @@ -8379,27 +8387,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ImageCompressionFixedRateFlagBitsEXT::e24Bpc; }; - //=== VK_EXT_device_fault === - - // wrapper class for enum VkDeviceFaultAddressTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressTypeEXT.html - enum class DeviceFaultAddressTypeEXT - { - eNone = VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT, - eReadInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT, - eWriteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT, - eExecuteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT, - eInstructionPointerUnknown = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT, - eInstructionPointerInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT, - eInstructionPointerFault = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT - }; - - // wrapper class for enum VkDeviceFaultVendorBinaryHeaderVersionEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionEXT.html - enum class DeviceFaultVendorBinaryHeaderVersionEXT - { - eOne = VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT - }; - #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) //=== VK_EXT_directfb_surface === @@ -9823,6 +9810,63 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer | IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer; }; + //=== VK_KHR_device_fault === + + // wrapper class for enum VkDeviceFaultAddressTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressTypeKHR.html + enum class DeviceFaultAddressTypeKHR + { + eNone = VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_KHR, + eNoneEXT = VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT, + eReadInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_KHR, + eReadInvalidEXT = VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT, + eWriteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_KHR, + eWriteInvalidEXT = VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT, + eExecuteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_KHR, + eExecuteInvalidEXT = VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT, + eInstructionPointerUnknown = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_KHR, + eInstructionPointerUnknownEXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT, + eInstructionPointerInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_KHR, + eInstructionPointerInvalidEXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT, + eInstructionPointerFault = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_KHR, + eInstructionPointerFaultEXT = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT + }; + + using DeviceFaultAddressTypeEXT = DeviceFaultAddressTypeKHR; + + // wrapper class for enum VkDeviceFaultVendorBinaryHeaderVersionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionKHR.html + enum class DeviceFaultVendorBinaryHeaderVersionKHR + { + eOne = VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_KHR, + eOneEXT = VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT + }; + + using DeviceFaultVendorBinaryHeaderVersionEXT = DeviceFaultVendorBinaryHeaderVersionKHR; + + // wrapper class for enum VkDeviceFaultFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultFlagBitsKHR.html + enum class DeviceFaultFlagBitsKHR : VkDeviceFaultFlagsKHR + { + eFlagDeviceLost = VK_DEVICE_FAULT_FLAG_DEVICE_LOST_KHR, + eFlagMemoryAddress = VK_DEVICE_FAULT_FLAG_MEMORY_ADDRESS_KHR, + eFlagInstructionAddress = VK_DEVICE_FAULT_FLAG_INSTRUCTION_ADDRESS_KHR, + eFlagVendor = VK_DEVICE_FAULT_FLAG_VENDOR_KHR, + eFlagWatchdogTimeout = VK_DEVICE_FAULT_FLAG_WATCHDOG_TIMEOUT_KHR, + eFlagOverflow = VK_DEVICE_FAULT_FLAG_OVERFLOW_KHR + }; + + // wrapper using for bitmask VkDeviceFaultFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultFlagsKHR.html + using DeviceFaultFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDeviceFaultFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceFaultFlagsKHR allFlags = DeviceFaultFlagBitsKHR::eFlagDeviceLost | DeviceFaultFlagBitsKHR::eFlagMemoryAddress | + DeviceFaultFlagBitsKHR::eFlagInstructionAddress | DeviceFaultFlagBitsKHR::eFlagVendor | + DeviceFaultFlagBitsKHR::eFlagWatchdogTimeout | DeviceFaultFlagBitsKHR::eFlagOverflow; + }; + //=== VK_KHR_maintenance8 === // wrapper class for enum VkAccessFlagBits3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits3KHR.html diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 97d094c..adf76f6 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -263,7 +263,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_KHR_fragment_shading_rate", "VK_AMD_shader_core_properties2", "VK_AMD_device_coherent_memory", + "VK_KHR_shader_constant_data", "VK_KHR_dynamic_rendering_local_read", + "VK_KHR_shader_abort", "VK_EXT_shader_image_atomic_int64", "VK_KHR_shader_quad_control", "VK_KHR_spirv_1_4", @@ -493,6 +495,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_NV_cluster_acceleration_structure", "VK_NV_partitioned_acceleration_structure", "VK_EXT_device_generated_commands", + "VK_KHR_device_fault", "VK_KHR_maintenance8", "VK_MESA_image_alignment_control", "VK_KHR_shader_fma", @@ -1502,6 +1505,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_shader_abort", + { { "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", { { "VK_VERSION_1_0", { { @@ -2892,6 +2902,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_KHR_maintenance5", } } }, { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_device_fault", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } } } }, { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } }, { "VK_MESA_image_alignment_control", { { "VK_VERSION_1_0", @@ -3258,6 +3273,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { "VK_EXT_image_robustness", "VK_VERSION_1_3" }, { "VK_KHR_copy_commands2", "VK_VERSION_1_3" }, { "VK_EXT_4444_formats", "VK_VERSION_1_3" }, + { "VK_EXT_device_fault", "VK_KHR_device_fault" }, { "VK_ARM_rasterization_order_attachment_access", "VK_EXT_rasterization_order_attachment_access" }, { "VK_VALVE_mutable_descriptor_type", "VK_EXT_mutable_descriptor_type" }, @@ -3741,6 +3757,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { return "VK_VERSION_1_3"; } + if ( extension == "VK_EXT_device_fault" ) + { + return "VK_KHR_device_fault"; + } if ( extension == "VK_ARM_rasterization_order_attachment_access" ) { return "VK_EXT_rasterization_order_attachment_access"; @@ -3956,12 +3976,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( extension == "VK_GOOGLE_hlsl_functionality1" ) || ( extension == "VK_GOOGLE_decorate_string" ) || ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_fragment_shading_rate" ) || ( extension == "VK_AMD_shader_core_properties2" ) || ( extension == "VK_AMD_device_coherent_memory" ) || - ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_EXT_shader_image_atomic_int64" ) || - ( extension == "VK_KHR_shader_quad_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_EXT_memory_budget" ) || - ( extension == "VK_EXT_memory_priority" ) || ( extension == "VK_NV_dedicated_allocation_image_aliasing" ) || - ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_buffer_device_address" ) || - ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_present_wait" ) || - ( extension == "VK_NV_cooperative_matrix" ) || ( extension == "VK_NV_coverage_reduction_mode" ) || + ( extension == "VK_KHR_shader_constant_data" ) || ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_KHR_shader_abort" ) || + ( extension == "VK_EXT_shader_image_atomic_int64" ) || ( extension == "VK_KHR_shader_quad_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || + ( extension == "VK_EXT_memory_budget" ) || ( extension == "VK_EXT_memory_priority" ) || + ( extension == "VK_NV_dedicated_allocation_image_aliasing" ) || ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || + ( extension == "VK_EXT_buffer_device_address" ) || ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) || + ( extension == "VK_KHR_present_wait" ) || ( extension == "VK_NV_cooperative_matrix" ) || ( extension == "VK_NV_coverage_reduction_mode" ) || ( extension == "VK_EXT_fragment_shader_interlock" ) || ( extension == "VK_EXT_ycbcr_image_arrays" ) || ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || ( extension == "VK_EXT_provoking_vertex" ) #if defined( VK_USE_PLATFORM_WIN32_KHR ) @@ -4073,8 +4093,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_EXT_shader_float8" ) || ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) || - ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) || - ( extension == "VK_NV_push_constant_bank" ) || ( extension == "VK_EXT_ray_tracing_invocation_reorder" ) || + ( extension == "VK_KHR_device_fault" ) || ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || + ( extension == "VK_KHR_shader_fma" ) || ( extension == "VK_NV_push_constant_bank" ) || ( extension == "VK_EXT_ray_tracing_invocation_reorder" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) #if defined( VK_USE_PLATFORM_METAL_EXT ) @@ -4205,13 +4225,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) || - ( 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_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_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_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" ) || ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index 200835a..82b41c8 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -32051,6 +32051,100 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_KHR_device_fault === + + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultReportsKHR( + uint64_t timeout, uint32_t * pFaultCounts, DeviceFaultInfoKHR * pFaultInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetDeviceFaultReportsKHR( static_cast( m_device ), timeout, pFaultCounts, reinterpret_cast( pFaultInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::getFaultReportsKHR( + uint64_t timeout, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceFaultReportsKHR && "Function requires " ); +# endif + + std::vector faultInfo; + uint32_t faultCounts; + Result result; + do + { + result = static_cast( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, nullptr ) ); + if ( ( result == Result::eSuccess ) && faultCounts ) + { + faultInfo.resize( faultCounts ); + result = + static_cast( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, reinterpret_cast( faultInfo.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultReportsKHR", { Result::eSuccess, Result::eIncomplete, Result::eTimeout } ); + VULKAN_HPP_ASSERT( faultCounts <= faultInfo.size() ); + if ( faultCounts < faultInfo.size() ) + { + faultInfo.resize( faultCounts ); + } + return { result, faultInfo }; + } + + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::getFaultReportsKHR( + uint64_t timeout, DeviceFaultInfoKHRAllocator const & deviceFaultInfoKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceFaultReportsKHR && "Function requires " ); +# endif + + std::vector faultInfo( deviceFaultInfoKHRAllocator ); + uint32_t faultCounts; + Result result; + do + { + result = static_cast( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, nullptr ) ); + if ( ( result == Result::eSuccess ) && faultCounts ) + { + faultInfo.resize( faultCounts ); + result = + static_cast( d.vkGetDeviceFaultReportsKHR( m_device, timeout, &faultCounts, reinterpret_cast( faultInfo.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultReportsKHR", { Result::eSuccess, Result::eIncomplete, Result::eTimeout } ); + VULKAN_HPP_ASSERT( faultCounts <= faultInfo.size() ); + if ( faultCounts < faultInfo.size() ) + { + faultInfo.resize( faultCounts ); + } + return { result, faultInfo }; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceFaultDebugInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultDebugInfoKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultDebugInfoKHR( DeviceFaultDebugInfoKHR * pDebugInfo, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetDeviceFaultDebugInfoKHR( static_cast( m_device ), reinterpret_cast( pDebugInfo ) ) ); + } + #if defined( VK_USE_PLATFORM_OHOS ) //=== VK_OHOS_surface === diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index 3e86f64..f54b8c2 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -1213,6 +1213,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_AMD_device_coherent_memory === struct PhysicalDeviceCoherentMemoryFeaturesAMD; + //=== VK_KHR_shader_constant_data === + struct PhysicalDeviceShaderConstantDataFeaturesKHR; + + //=== VK_KHR_shader_abort === + struct PhysicalDeviceShaderAbortFeaturesKHR; + struct DeviceFaultShaderAbortMessageInfoKHR; + struct PhysicalDeviceShaderAbortPropertiesKHR; + //=== VK_EXT_shader_image_atomic_int64 === struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; @@ -1508,9 +1516,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceFaultFeaturesEXT; struct DeviceFaultCountsEXT; struct DeviceFaultInfoEXT; - struct DeviceFaultAddressInfoEXT; - struct DeviceFaultVendorInfoEXT; - struct DeviceFaultVendorBinaryHeaderVersionOneEXT; //=== VK_EXT_rgba10x6_formats === struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT; @@ -2205,6 +2210,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct GeneratedCommandsShaderInfoEXT; struct WriteIndirectExecutionSetShaderEXT; + //=== VK_KHR_device_fault === + struct PhysicalDeviceFaultFeaturesKHR; + struct PhysicalDeviceFaultPropertiesKHR; + struct DeviceFaultInfoKHR; + struct DeviceFaultDebugInfoKHR; + struct DeviceFaultAddressInfoKHR; + using DeviceFaultAddressInfoEXT = DeviceFaultAddressInfoKHR; + struct DeviceFaultVendorInfoKHR; + using DeviceFaultVendorInfoEXT = DeviceFaultVendorInfoKHR; + struct DeviceFaultVendorBinaryHeaderVersionOneKHR; + using DeviceFaultVendorBinaryHeaderVersionOneEXT = DeviceFaultVendorBinaryHeaderVersionOneKHR; + //=== VK_KHR_maintenance8 === struct MemoryBarrierAccessFlags3KHR; struct PhysicalDeviceMaintenance8FeaturesKHR; @@ -19742,6 +19759,37 @@ 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_KHR_device_fault === + + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFaultReportsKHR( uint64_t timeout, + uint32_t * pFaultCounts, + DeviceFaultInfoKHR * pFaultInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.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 ResultValue> + getFaultReportsKHR( uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.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 ResultValue> getFaultReportsKHR( + uint64_t timeout, DeviceFaultInfoKHRAllocator const & deviceFaultInfoKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceFaultDebugInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultDebugInfoKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFaultDebugInfoKHR( DeviceFaultDebugInfoKHR * pDebugInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_external_memory_metal === diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 80d118c..4b9b738 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -4950,14 +4950,14 @@ VULKAN_HPP_EXPORT namespace std }; template <> - struct hash + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoKHR const & deviceFaultAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoKHR.addressType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoKHR.reportedAddress ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoKHR.addressPrecision ); return seed; } }; @@ -4978,17 +4978,31 @@ VULKAN_HPP_EXPORT namespace std }; template <> - struct hash + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultDebugInfoKHR const & deviceFaultDebugInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultDebugInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultDebugInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultDebugInfoKHR.vendorBinarySize ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultDebugInfoKHR.pVendorBinaryData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoKHR const & deviceFaultVendorInfoKHR ) const VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) { - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoKHR.description[i] ); } - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoKHR.vendorFaultCode ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoKHR.vendorFaultData ); return seed; } }; @@ -5013,26 +5027,61 @@ VULKAN_HPP_EXPORT namespace std }; template <> - struct hash + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoKHR const & deviceFaultInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.groupId ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.description[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.faultAddressInfo ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.instructionAddressInfo ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoKHR.vendorInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultShaderAbortMessageInfoKHR const & deviceFaultShaderAbortMessageInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultShaderAbortMessageInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultShaderAbortMessageInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultShaderAbortMessageInfoKHR.messageDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultShaderAbortMessageInfoKHR.pMessageData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneKHR const & deviceFaultVendorBinaryHeaderVersionOneKHR ) const VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.headerSize ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.headerVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.vendorID ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.deviceID ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.driverVersion ); for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) { - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.pipelineCacheUUID[i] ); } - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.applicationNameOffset ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.applicationVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.engineNameOffset ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.engineVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneKHR.apiVersion ); return seed; } }; @@ -11323,6 +11372,35 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesKHR const & physicalDeviceFaultFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesKHR.deviceFault ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesKHR.deviceFaultVendorBinary ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesKHR.deviceFaultReportMasked ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesKHR.deviceFaultDeviceLostOnMasked ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultPropertiesKHR const & physicalDeviceFaultPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultPropertiesKHR.maxDeviceFaultCount ); + return seed; + } + }; + template <> struct hash { @@ -14235,6 +14313,33 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortFeaturesKHR const & physicalDeviceShaderAbortFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAbortFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAbortFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAbortFeaturesKHR.shaderAbort ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortPropertiesKHR const & physicalDeviceShaderAbortPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAbortPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAbortPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAbortPropertiesKHR.maxShaderAbortMessageSize ); + return seed; + } + }; + template <> struct hash { @@ -14344,6 +14449,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderConstantDataFeaturesKHR const & physicalDeviceShaderConstantDataFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderConstantDataFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderConstantDataFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderConstantDataFeaturesKHR.shaderConstantData ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index 79166b2..4898446 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -2007,6 +2007,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE vkUpdateIndirectExecutionSetShaderEXT = PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) ); + //=== VK_KHR_device_fault === + vkGetDeviceFaultReportsKHR = PFN_vkGetDeviceFaultReportsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceFaultReportsKHR" ) ); + vkGetDeviceFaultDebugInfoKHR = PFN_vkGetDeviceFaultDebugInfoKHR( vkGetDeviceProcAddr( device, "vkGetDeviceFaultDebugInfoKHR" ) ); + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_external_memory_metal === vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) ); @@ -3075,6 +3079,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0; PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0; + //=== VK_KHR_device_fault === + PFN_vkGetDeviceFaultReportsKHR vkGetDeviceFaultReportsKHR = 0; + PFN_vkGetDeviceFaultDebugInfoKHR vkGetDeviceFaultDebugInfoKHR = 0; + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_external_memory_metal === PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0; @@ -5933,6 +5941,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE createIndirectExecutionSetEXT( IndirectExecutionSetCreateInfoEXT const & createInfo, Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + //=== VK_KHR_device_fault === + + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.html + VULKAN_HPP_NODISCARD ResultValue> getFaultReportsKHR( uint64_t timeout ) const; + + // wrapper function for command vkGetDeviceFaultDebugInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultDebugInfoKHR.html + VULKAN_HPP_NODISCARD Result getFaultDebugInfoKHR( DeviceFaultDebugInfoKHR * pDebugInfo ) const VULKAN_HPP_NOEXCEPT; + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_external_memory_metal === @@ -29108,6 +29125,44 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE reinterpret_cast( executionSetWrites.data() ) ); } + //=== VK_KHR_device_fault === + + // wrapper function for command vkGetDeviceFaultReportsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultReportsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::getFaultReportsKHR( uint64_t timeout ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultReportsKHR && "Function requires " ); + + std::vector faultInfo; + uint32_t faultCounts; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetDeviceFaultReportsKHR( static_cast( m_device ), timeout, &faultCounts, nullptr ) ); + if ( ( result == Result::eSuccess ) && faultCounts ) + { + faultInfo.resize( faultCounts ); + result = static_cast( getDispatcher()->vkGetDeviceFaultReportsKHR( + static_cast( m_device ), timeout, &faultCounts, reinterpret_cast( faultInfo.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getFaultReportsKHR", { Result::eSuccess, Result::eIncomplete, Result::eTimeout } ); + VULKAN_HPP_ASSERT( faultCounts <= faultInfo.size() ); + if ( faultCounts < faultInfo.size() ) + { + faultInfo.resize( faultCounts ); + } + return { result, faultInfo }; + } + + // wrapper function for command vkGetDeviceFaultDebugInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultDebugInfoKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultDebugInfoKHR( DeviceFaultDebugInfoKHR * pDebugInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultDebugInfoKHR && "Function requires " ); + return static_cast( + getDispatcher()->vkGetDeviceFaultDebugInfoKHR( static_cast( m_device ), reinterpret_cast( pDebugInfo ) ) ); + } # if defined( VK_USE_PLATFORM_OHOS ) //=== VK_OHOS_surface === diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index 294e022..dfe5495 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -4881,6 +4881,39 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceCoherentMemoryFeaturesAMD is not nothrow_move_constructible!" ); +//=== VK_KHR_shader_constant_data === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderConstantDataFeaturesKHR ) == + sizeof( VkPhysicalDeviceShaderConstantDataFeaturesKHR ), + "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, + "PhysicalDeviceShaderConstantDataFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_abort === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAbortFeaturesKHR ), + "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, + "PhysicalDeviceShaderAbortFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultShaderAbortMessageInfoKHR ) == sizeof( VkDeviceFaultShaderAbortMessageInfoKHR ), + "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, + "DeviceFaultShaderAbortMessageInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAbortPropertiesKHR ) == sizeof( VkPhysicalDeviceShaderAbortPropertiesKHR ), + "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, + "PhysicalDeviceShaderAbortPropertiesKHR is not nothrow_move_constructible!" ); + //=== VK_EXT_shader_image_atomic_int64 === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT ) == @@ -6200,25 +6233,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "DeviceFaultInfoEXT is not nothrow_move_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT ) == sizeof( VkDeviceFaultAddressInfoEXT ), - "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, - "DeviceFaultAddressInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT ) == sizeof( VkDeviceFaultVendorInfoEXT ), - "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, - "DeviceFaultVendorInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT ) == sizeof( VkDeviceFaultVendorBinaryHeaderVersionOneEXT ), - "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, - "DeviceFaultVendorBinaryHeaderVersionOneEXT is not nothrow_move_constructible!" ); - //=== VK_EXT_rgba10x6_formats === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT ) == sizeof( VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT ), @@ -9396,6 +9410,50 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "WriteIndirectExecutionSetShaderEXT is not nothrow_move_constructible!" ); +//=== VK_KHR_device_fault === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesKHR ) == sizeof( VkPhysicalDeviceFaultFeaturesKHR ), + "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, + "PhysicalDeviceFaultFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultPropertiesKHR ) == sizeof( VkPhysicalDeviceFaultPropertiesKHR ), + "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, + "PhysicalDeviceFaultPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultInfoKHR ) == sizeof( VkDeviceFaultInfoKHR ), "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, + "DeviceFaultInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultDebugInfoKHR ) == sizeof( VkDeviceFaultDebugInfoKHR ), + "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, + "DeviceFaultDebugInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoKHR ) == sizeof( VkDeviceFaultAddressInfoKHR ), + "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, + "DeviceFaultAddressInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoKHR ) == sizeof( VkDeviceFaultVendorInfoKHR ), + "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, + "DeviceFaultVendorInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneKHR ) == sizeof( VkDeviceFaultVendorBinaryHeaderVersionOneKHR ), + "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, + "DeviceFaultVendorBinaryHeaderVersionOneKHR is not nothrow_move_constructible!" ); + //=== VK_KHR_maintenance8 === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR ) == sizeof( VkMemoryBarrierAccessFlags3KHR ), diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index 533e32e..f7a2fd2 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -50259,7 +50259,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) DeviceCreateInfo( DeviceCreateFlags flags_, ArrayProxyNoTemporaries const & queueCreateInfos_, - ArrayProxyNoTemporaries const & pEnabledLayerNames_ = {}, + uint32_t enabledLayerCount_ = {}, + char const * const * ppEnabledLayerNames_ = {}, ArrayProxyNoTemporaries const & pEnabledExtensionNames_ = {}, PhysicalDeviceFeatures const * pEnabledFeatures_ = {}, void const * pNext_ = nullptr ) @@ -50267,8 +50268,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE , flags( flags_ ) , queueCreateInfoCount( static_cast( queueCreateInfos_.size() ) ) , pQueueCreateInfos( queueCreateInfos_.data() ) - , enabledLayerCount( static_cast( pEnabledLayerNames_.size() ) ) - , ppEnabledLayerNames( pEnabledLayerNames_.data() ) + , enabledLayerCount( enabledLayerCount_ ) + , ppEnabledLayerNames( ppEnabledLayerNames_ ) , enabledExtensionCount( static_cast( pEnabledExtensionNames_.size() ) ) , ppEnabledExtensionNames( pEnabledExtensionNames_.data() ) , pEnabledFeatures( pEnabledFeatures_ ) @@ -50360,41 +50361,32 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_DEPRECATED( "unused" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) & VULKAN_HPP_NOEXCEPT { detail::ignore( enabledLayerCount_ ); return *this; } - VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setEnabledLayerCount( uint32_t enabledLayerCount_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_DEPRECATED( "unused" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setEnabledLayerCount( uint32_t enabledLayerCount_ ) && VULKAN_HPP_NOEXCEPT { detail::ignore( enabledLayerCount_ ); return std::move( *this ); } - VULKAN_HPP_DEPRECATED( "ignored" ) + VULKAN_HPP_DEPRECATED( "unused" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPpEnabledLayerNames( char const * const * ppEnabledLayerNames_ ) & VULKAN_HPP_NOEXCEPT { detail::ignore( ppEnabledLayerNames_ ); return *this; } - VULKAN_HPP_DEPRECATED( "ignored" ) + VULKAN_HPP_DEPRECATED( "unused" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPpEnabledLayerNames( char const * const * ppEnabledLayerNames_ ) && VULKAN_HPP_NOEXCEPT { detail::ignore( ppEnabledLayerNames_ ); return std::move( *this ); } -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VULKAN_HPP_DEPRECATED( "ignored" ) - DeviceCreateInfo & setPEnabledLayerNames( ArrayProxyNoTemporaries const & pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT - { - detail::ignore( pEnabledLayerNames_ ); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) & VULKAN_HPP_NOEXCEPT { enabledExtensionCount = enabledExtensionCount_; @@ -50521,16 +50513,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } public: - StructureType sType = StructureType::eDeviceCreateInfo; - void const * pNext = {}; - DeviceCreateFlags flags = {}; - uint32_t queueCreateInfoCount = {}; - DeviceQueueCreateInfo const * pQueueCreateInfos = {}; - VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount = {}; - VULKAN_HPP_DEPRECATED( "ignored" ) char const * const * ppEnabledLayerNames = {}; - uint32_t enabledExtensionCount = {}; - char const * const * ppEnabledExtensionNames = {}; - PhysicalDeviceFeatures const * pEnabledFeatures = {}; + StructureType sType = StructureType::eDeviceCreateInfo; + void const * pNext = {}; + DeviceCreateFlags flags = {}; + uint32_t queueCreateInfoCount = {}; + DeviceQueueCreateInfo const * pQueueCreateInfos = {}; + VULKAN_HPP_DEPRECATED( "unused" ) uint32_t enabledLayerCount = {}; + VULKAN_HPP_DEPRECATED( "unused" ) char const * const * ppEnabledLayerNames = {}; + uint32_t enabledExtensionCount = {}; + char const * const * ppEnabledExtensionNames = {}; + PhysicalDeviceFeatures const * pEnabledFeatures = {}; }; #if 20 <= VULKAN_HPP_CPP_VERSION @@ -51109,13 +51101,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DeviceEventInfoEXT; }; - // wrapper struct for struct VkDeviceFaultAddressInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressInfoEXT.html - struct DeviceFaultAddressInfoEXT + // wrapper struct for struct VkDeviceFaultAddressInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressInfoKHR.html + struct DeviceFaultAddressInfoKHR { - using NativeType = VkDeviceFaultAddressInfoEXT; + using NativeType = VkDeviceFaultAddressInfoKHR; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoEXT( DeviceFaultAddressTypeEXT addressType_ = DeviceFaultAddressTypeEXT::eNone, + VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoKHR( DeviceFaultAddressTypeKHR addressType_ = DeviceFaultAddressTypeKHR::eNone, DeviceAddress reportedAddress_ = {}, DeviceSize addressPrecision_ = {} ) VULKAN_HPP_NOEXCEPT : addressType{ addressType_ } @@ -51124,53 +51116,53 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { } - VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoEXT( DeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoKHR( DeviceFaultAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - DeviceFaultAddressInfoEXT( VkDeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceFaultAddressInfoEXT( *reinterpret_cast( &rhs ) ) + DeviceFaultAddressInfoKHR( VkDeviceFaultAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultAddressInfoKHR( *reinterpret_cast( &rhs ) ) { } - DeviceFaultAddressInfoEXT & operator=( DeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + DeviceFaultAddressInfoKHR & operator=( DeviceFaultAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - DeviceFaultAddressInfoEXT & operator=( VkDeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + DeviceFaultAddressInfoKHR & operator=( VkDeviceFaultAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } - operator VkDeviceFaultAddressInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkDeviceFaultAddressInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultAddressInfoKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkDeviceFaultAddressInfoEXT const *() const VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultAddressInfoKHR const *() const VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } - operator VkDeviceFaultAddressInfoEXT *() VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultAddressInfoKHR *() VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } #if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT + std::tuple reflect() const VULKAN_HPP_NOEXCEPT { return std::tie( addressType, reportedAddress, addressPrecision ); } #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceFaultAddressInfoEXT const & ) const = default; + auto operator<=>( DeviceFaultAddressInfoKHR const & ) const = default; #else - bool operator==( DeviceFaultAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( DeviceFaultAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); @@ -51179,25 +51171,26 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE # endif } - bool operator!=( DeviceFaultAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( DeviceFaultAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } #endif public: - DeviceFaultAddressTypeEXT addressType = DeviceFaultAddressTypeEXT::eNone; + DeviceFaultAddressTypeKHR addressType = DeviceFaultAddressTypeKHR::eNone; DeviceAddress reportedAddress = {}; DeviceSize addressPrecision = {}; }; #if 20 <= VULKAN_HPP_CPP_VERSION template <> - struct CppType + struct CppType { - using Type = DeviceFaultAddressInfoEXT; + using Type = DeviceFaultAddressInfoKHR; }; #endif + using DeviceFaultAddressInfoEXT = DeviceFaultAddressInfoKHR; // wrapper struct for struct VkDeviceFaultCountsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultCountsEXT.html struct DeviceFaultCountsEXT @@ -51353,13 +51346,111 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DeviceFaultCountsEXT; }; - // wrapper struct for struct VkDeviceFaultVendorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorInfoEXT.html - struct DeviceFaultVendorInfoEXT + // wrapper struct for struct VkDeviceFaultDebugInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultDebugInfoKHR.html + struct DeviceFaultDebugInfoKHR { - using NativeType = VkDeviceFaultVendorInfoEXT; + using NativeType = VkDeviceFaultDebugInfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceFaultDebugInfoKHR; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT( std::array const & description_ = {}, + VULKAN_HPP_CONSTEXPR DeviceFaultDebugInfoKHR( uint32_t vendorBinarySize_ = {}, void * pVendorBinaryData_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vendorBinarySize{ vendorBinarySize_ } + , pVendorBinaryData{ pVendorBinaryData_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceFaultDebugInfoKHR( DeviceFaultDebugInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultDebugInfoKHR( VkDeviceFaultDebugInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultDebugInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DeviceFaultDebugInfoKHR & operator=( DeviceFaultDebugInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultDebugInfoKHR & operator=( VkDeviceFaultDebugInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDeviceFaultDebugInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultDebugInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultDebugInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultDebugInfoKHR *() 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, vendorBinarySize, pVendorBinaryData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceFaultDebugInfoKHR const & ) const = default; +#else + bool operator==( DeviceFaultDebugInfoKHR 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 ) && ( vendorBinarySize == rhs.vendorBinarySize ) && ( pVendorBinaryData == rhs.pVendorBinaryData ); +# endif + } + + bool operator!=( DeviceFaultDebugInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceFaultDebugInfoKHR; + void * pNext = {}; + uint32_t vendorBinarySize = {}; + void * pVendorBinaryData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultDebugInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceFaultDebugInfoKHR; + }; + + // wrapper struct for struct VkDeviceFaultVendorInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorInfoKHR.html + struct DeviceFaultVendorInfoKHR + { + using NativeType = VkDeviceFaultVendorInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoKHR( std::array const & description_ = {}, uint64_t vendorFaultCode_ = {}, uint64_t vendorFaultData_ = {} ) VULKAN_HPP_NOEXCEPT : description{ description_ } @@ -51368,40 +51459,40 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoKHR( DeviceFaultVendorInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - DeviceFaultVendorInfoEXT( VkDeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceFaultVendorInfoEXT( *reinterpret_cast( &rhs ) ) + DeviceFaultVendorInfoKHR( VkDeviceFaultVendorInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultVendorInfoKHR( *reinterpret_cast( &rhs ) ) { } - DeviceFaultVendorInfoEXT & operator=( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + DeviceFaultVendorInfoKHR & operator=( DeviceFaultVendorInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - DeviceFaultVendorInfoEXT & operator=( VkDeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + DeviceFaultVendorInfoKHR & operator=( VkDeviceFaultVendorInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } - operator VkDeviceFaultVendorInfoEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorInfoKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkDeviceFaultVendorInfoEXT &() VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorInfoKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkDeviceFaultVendorInfoEXT const *() const VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorInfoKHR const *() const VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } - operator VkDeviceFaultVendorInfoEXT *() VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorInfoKHR *() VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } #if defined( VULKAN_HPP_USE_REFLECT ) @@ -51412,7 +51503,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + std::strong_ordering operator<=>( DeviceFaultVendorInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; @@ -51425,12 +51516,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } #endif - bool operator==( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( DeviceFaultVendorInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( strcmp( description, rhs.description ) == 0 ) && ( vendorFaultCode == rhs.vendorFaultCode ) && ( vendorFaultData == rhs.vendorFaultData ); } - bool operator!=( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( DeviceFaultVendorInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } @@ -51443,11 +51534,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if 20 <= VULKAN_HPP_CPP_VERSION template <> - struct CppType + struct CppType { - using Type = DeviceFaultVendorInfoEXT; + using Type = DeviceFaultVendorInfoKHR; }; #endif + using DeviceFaultVendorInfoEXT = DeviceFaultVendorInfoKHR; // wrapper struct for struct VkDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultInfoEXT.html struct DeviceFaultInfoEXT @@ -51459,8 +51551,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( std::array const & description_ = {}, - DeviceFaultAddressInfoEXT * pAddressInfos_ = {}, - DeviceFaultVendorInfoEXT * pVendorInfos_ = {}, + DeviceFaultAddressInfoKHR * pAddressInfos_ = {}, + DeviceFaultVendorInfoKHR * pVendorInfos_ = {}, void * pVendorBinaryData_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } @@ -51508,8 +51600,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE std::tuple const &, - DeviceFaultAddressInfoEXT * const &, - DeviceFaultVendorInfoEXT * const &, + DeviceFaultAddressInfoKHR * const &, + DeviceFaultVendorInfoKHR * const &, void * const &> reflect() const VULKAN_HPP_NOEXCEPT { @@ -51552,8 +51644,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE StructureType sType = StructureType::eDeviceFaultInfoEXT; void * pNext = {}; ArrayWrapper1D description = {}; - DeviceFaultAddressInfoEXT * pAddressInfos = {}; - DeviceFaultVendorInfoEXT * pVendorInfos = {}; + DeviceFaultAddressInfoKHR * pAddressInfos = {}; + DeviceFaultVendorInfoKHR * pVendorInfos = {}; void * pVendorBinaryData = {}; }; @@ -51571,16 +51663,251 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DeviceFaultInfoEXT; }; - // wrapper struct for struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneEXT.html - struct DeviceFaultVendorBinaryHeaderVersionOneEXT + // wrapper struct for struct VkDeviceFaultInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultInfoKHR.html + struct DeviceFaultInfoKHR { - using NativeType = VkDeviceFaultVendorBinaryHeaderVersionOneEXT; + using NativeType = VkDeviceFaultInfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceFaultInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoKHR( DeviceFaultFlagsKHR flags_ = {}, + uint64_t groupId_ = {}, + std::array const & description_ = {}, + DeviceFaultAddressInfoKHR faultAddressInfo_ = {}, + DeviceFaultAddressInfoKHR instructionAddressInfo_ = {}, + DeviceFaultVendorInfoKHR vendorInfo_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , groupId{ groupId_ } + , description{ description_ } + , faultAddressInfo{ faultAddressInfo_ } + , instructionAddressInfo{ instructionAddressInfo_ } + , vendorInfo{ vendorInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoKHR( DeviceFaultInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultInfoKHR( VkDeviceFaultInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceFaultInfoKHR( *reinterpret_cast( &rhs ) ) {} + + DeviceFaultInfoKHR & operator=( DeviceFaultInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultInfoKHR & operator=( VkDeviceFaultInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDeviceFaultInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + DeviceFaultAddressInfoKHR const &, + DeviceFaultAddressInfoKHR const &, + DeviceFaultVendorInfoKHR const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, groupId, description, faultAddressInfo, instructionAddressInfo, vendorInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DeviceFaultInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = groupId <=> rhs.groupId; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = faultAddressInfo <=> rhs.faultAddressInfo; cmp != 0 ) + return cmp; + if ( auto cmp = instructionAddressInfo <=> rhs.instructionAddressInfo; cmp != 0 ) + return cmp; + if ( auto cmp = vendorInfo <=> rhs.vendorInfo; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DeviceFaultInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( groupId == rhs.groupId ) && + ( strcmp( description, rhs.description ) == 0 ) && ( faultAddressInfo == rhs.faultAddressInfo ) && + ( instructionAddressInfo == rhs.instructionAddressInfo ) && ( vendorInfo == rhs.vendorInfo ); + } + + bool operator!=( DeviceFaultInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDeviceFaultInfoKHR; + void * pNext = {}; + DeviceFaultFlagsKHR flags = {}; + uint64_t groupId = {}; + ArrayWrapper1D description = {}; + DeviceFaultAddressInfoKHR faultAddressInfo = {}; + DeviceFaultAddressInfoKHR instructionAddressInfo = {}; + DeviceFaultVendorInfoKHR vendorInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceFaultInfoKHR; + }; + + // wrapper struct for struct VkDeviceFaultShaderAbortMessageInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultShaderAbortMessageInfoKHR.html + struct DeviceFaultShaderAbortMessageInfoKHR + { + using NativeType = VkDeviceFaultShaderAbortMessageInfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceFaultShaderAbortMessageInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DeviceFaultShaderAbortMessageInfoKHR( uint64_t messageDataSize_ = {}, void * pMessageData_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , messageDataSize{ messageDataSize_ } + , pMessageData{ pMessageData_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceFaultShaderAbortMessageInfoKHR( DeviceFaultShaderAbortMessageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultShaderAbortMessageInfoKHR( VkDeviceFaultShaderAbortMessageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultShaderAbortMessageInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DeviceFaultShaderAbortMessageInfoKHR & operator=( DeviceFaultShaderAbortMessageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultShaderAbortMessageInfoKHR & operator=( VkDeviceFaultShaderAbortMessageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDeviceFaultShaderAbortMessageInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultShaderAbortMessageInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultShaderAbortMessageInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultShaderAbortMessageInfoKHR *() 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, messageDataSize, pMessageData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceFaultShaderAbortMessageInfoKHR const & ) const = default; +#else + bool operator==( DeviceFaultShaderAbortMessageInfoKHR 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 ) && ( messageDataSize == rhs.messageDataSize ) && ( pMessageData == rhs.pMessageData ); +# endif + } + + bool operator!=( DeviceFaultShaderAbortMessageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceFaultShaderAbortMessageInfoKHR; + void * pNext = {}; + uint64_t messageDataSize = {}; + void * pMessageData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultShaderAbortMessageInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceFaultShaderAbortMessageInfoKHR; + }; + + // wrapper struct for struct VkDeviceFaultVendorBinaryHeaderVersionOneKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneKHR.html + struct DeviceFaultVendorBinaryHeaderVersionOneKHR + { + using NativeType = VkDeviceFaultVendorBinaryHeaderVersionOneKHR; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) VULKAN_HPP_CONSTEXPR_14 - DeviceFaultVendorBinaryHeaderVersionOneEXT( uint32_t headerSize_ = {}, - DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ = DeviceFaultVendorBinaryHeaderVersionEXT::eOne, + DeviceFaultVendorBinaryHeaderVersionOneKHR( uint32_t headerSize_ = {}, + DeviceFaultVendorBinaryHeaderVersionKHR headerVersion_ = DeviceFaultVendorBinaryHeaderVersionKHR::eOne, uint32_t vendorID_ = {}, uint32_t deviceID_ = {}, uint32_t driverVersion_ = {}, @@ -51604,183 +51931,183 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR( DeviceFaultVendorBinaryHeaderVersionOneKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - DeviceFaultVendorBinaryHeaderVersionOneEXT( VkDeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceFaultVendorBinaryHeaderVersionOneEXT( *reinterpret_cast( &rhs ) ) + DeviceFaultVendorBinaryHeaderVersionOneKHR( VkDeviceFaultVendorBinaryHeaderVersionOneKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultVendorBinaryHeaderVersionOneKHR( *reinterpret_cast( &rhs ) ) { } - DeviceFaultVendorBinaryHeaderVersionOneEXT & operator=( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + DeviceFaultVendorBinaryHeaderVersionOneKHR & operator=( DeviceFaultVendorBinaryHeaderVersionOneKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - DeviceFaultVendorBinaryHeaderVersionOneEXT & operator=( VkDeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT + DeviceFaultVendorBinaryHeaderVersionOneKHR & operator=( VkDeviceFaultVendorBinaryHeaderVersionOneKHR 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 DeviceFaultVendorBinaryHeaderVersionOneEXT & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT { headerSize = headerSize_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT { headerSize = headerSize_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ ) & + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionKHR headerVersion_ ) & VULKAN_HPP_NOEXCEPT { headerVersion = headerVersion_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ ) && + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionKHR headerVersion_ ) && VULKAN_HPP_NOEXCEPT { headerVersion = headerVersion_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setVendorID( uint32_t vendorID_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setVendorID( uint32_t vendorID_ ) & VULKAN_HPP_NOEXCEPT { vendorID = vendorID_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setVendorID( uint32_t vendorID_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setVendorID( uint32_t vendorID_ ) && VULKAN_HPP_NOEXCEPT { vendorID = vendorID_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setDeviceID( uint32_t deviceID_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setDeviceID( uint32_t deviceID_ ) & VULKAN_HPP_NOEXCEPT { deviceID = deviceID_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setDeviceID( uint32_t deviceID_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setDeviceID( uint32_t deviceID_ ) && VULKAN_HPP_NOEXCEPT { deviceID = deviceID_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setDriverVersion( uint32_t driverVersion_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setDriverVersion( uint32_t driverVersion_ ) & VULKAN_HPP_NOEXCEPT { driverVersion = driverVersion_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setDriverVersion( uint32_t driverVersion_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setDriverVersion( uint32_t driverVersion_ ) && VULKAN_HPP_NOEXCEPT { driverVersion = driverVersion_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setPipelineCacheUUID( std::array pipelineCacheUUID_ ) & + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setPipelineCacheUUID( std::array pipelineCacheUUID_ ) & VULKAN_HPP_NOEXCEPT { pipelineCacheUUID = pipelineCacheUUID_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setPipelineCacheUUID( std::array pipelineCacheUUID_ ) && + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setPipelineCacheUUID( std::array pipelineCacheUUID_ ) && VULKAN_HPP_NOEXCEPT { pipelineCacheUUID = pipelineCacheUUID_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApplicationNameOffset( uint32_t applicationNameOffset_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setApplicationNameOffset( uint32_t applicationNameOffset_ ) & VULKAN_HPP_NOEXCEPT { applicationNameOffset = applicationNameOffset_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApplicationNameOffset( uint32_t applicationNameOffset_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setApplicationNameOffset( uint32_t applicationNameOffset_ ) && VULKAN_HPP_NOEXCEPT { applicationNameOffset = applicationNameOffset_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApplicationVersion( uint32_t applicationVersion_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setApplicationVersion( uint32_t applicationVersion_ ) & VULKAN_HPP_NOEXCEPT { applicationVersion = applicationVersion_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApplicationVersion( uint32_t applicationVersion_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setApplicationVersion( uint32_t applicationVersion_ ) && VULKAN_HPP_NOEXCEPT { applicationVersion = applicationVersion_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setEngineNameOffset( uint32_t engineNameOffset_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setEngineNameOffset( uint32_t engineNameOffset_ ) & VULKAN_HPP_NOEXCEPT { engineNameOffset = engineNameOffset_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setEngineNameOffset( uint32_t engineNameOffset_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setEngineNameOffset( uint32_t engineNameOffset_ ) && VULKAN_HPP_NOEXCEPT { engineNameOffset = engineNameOffset_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setEngineVersion( uint32_t engineVersion_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setEngineVersion( uint32_t engineVersion_ ) & VULKAN_HPP_NOEXCEPT { engineVersion = engineVersion_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setEngineVersion( uint32_t engineVersion_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setEngineVersion( uint32_t engineVersion_ ) && VULKAN_HPP_NOEXCEPT { engineVersion = engineVersion_; return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApiVersion( uint32_t apiVersion_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR & setApiVersion( uint32_t apiVersion_ ) & VULKAN_HPP_NOEXCEPT { apiVersion = apiVersion_; return *this; } - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApiVersion( uint32_t apiVersion_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneKHR && setApiVersion( uint32_t apiVersion_ ) && VULKAN_HPP_NOEXCEPT { apiVersion = apiVersion_; return std::move( *this ); } #endif /*VULKAN_HPP_NO_SETTERS*/ - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorBinaryHeaderVersionOneKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT &() VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorBinaryHeaderVersionOneKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT const *() const VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorBinaryHeaderVersionOneKHR const *() const VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT *() VULKAN_HPP_NOEXCEPT + operator VkDeviceFaultVendorBinaryHeaderVersionOneKHR *() VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } #if defined( VULKAN_HPP_USE_REFLECT ) std::tuple( DeviceFaultVendorBinaryHeaderVersionOneEXT const & ) const = default; + auto operator<=>( DeviceFaultVendorBinaryHeaderVersionOneKHR const & ) const = default; #else - bool operator==( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( DeviceFaultVendorBinaryHeaderVersionOneKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); @@ -51821,7 +52148,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE # endif } - bool operator!=( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( DeviceFaultVendorBinaryHeaderVersionOneKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } @@ -51829,7 +52156,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE public: uint32_t headerSize = {}; - DeviceFaultVendorBinaryHeaderVersionEXT headerVersion = DeviceFaultVendorBinaryHeaderVersionEXT::eOne; + DeviceFaultVendorBinaryHeaderVersionKHR headerVersion = DeviceFaultVendorBinaryHeaderVersionKHR::eOne; uint32_t vendorID = {}; uint32_t deviceID = {}; uint32_t driverVersion = {}; @@ -51843,11 +52170,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if 20 <= VULKAN_HPP_CPP_VERSION template <> - struct CppType + struct CppType { - using Type = DeviceFaultVendorBinaryHeaderVersionOneEXT; + using Type = DeviceFaultVendorBinaryHeaderVersionOneKHR; }; #endif + using DeviceFaultVendorBinaryHeaderVersionOneEXT = DeviceFaultVendorBinaryHeaderVersionOneKHR; // wrapper struct for struct VkDeviceGroupBindSparseInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupBindSparseInfo.html struct DeviceGroupBindSparseInfo @@ -112121,6 +112449,274 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceFaultFeaturesEXT; }; + // wrapper struct for struct VkPhysicalDeviceFaultFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFaultFeaturesKHR.html + struct PhysicalDeviceFaultFeaturesKHR + { + using NativeType = VkPhysicalDeviceFaultFeaturesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFaultFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFaultFeaturesKHR( Bool32 deviceFault_ = {}, + Bool32 deviceFaultVendorBinary_ = {}, + Bool32 deviceFaultReportMasked_ = {}, + Bool32 deviceFaultDeviceLostOnMasked_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceFault{ deviceFault_ } + , deviceFaultVendorBinary{ deviceFaultVendorBinary_ } + , deviceFaultReportMasked{ deviceFaultReportMasked_ } + , deviceFaultDeviceLostOnMasked{ deviceFaultDeviceLostOnMasked_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFaultFeaturesKHR( PhysicalDeviceFaultFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFaultFeaturesKHR( VkPhysicalDeviceFaultFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFaultFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFaultFeaturesKHR & operator=( PhysicalDeviceFaultFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFaultFeaturesKHR & operator=( VkPhysicalDeviceFaultFeaturesKHR 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 PhysicalDeviceFaultFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR & setDeviceFault( Bool32 deviceFault_ ) & VULKAN_HPP_NOEXCEPT + { + deviceFault = deviceFault_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR && setDeviceFault( Bool32 deviceFault_ ) && VULKAN_HPP_NOEXCEPT + { + deviceFault = deviceFault_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR & setDeviceFaultVendorBinary( Bool32 deviceFaultVendorBinary_ ) & VULKAN_HPP_NOEXCEPT + { + deviceFaultVendorBinary = deviceFaultVendorBinary_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR && setDeviceFaultVendorBinary( Bool32 deviceFaultVendorBinary_ ) && VULKAN_HPP_NOEXCEPT + { + deviceFaultVendorBinary = deviceFaultVendorBinary_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR & setDeviceFaultReportMasked( Bool32 deviceFaultReportMasked_ ) & VULKAN_HPP_NOEXCEPT + { + deviceFaultReportMasked = deviceFaultReportMasked_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR && setDeviceFaultReportMasked( Bool32 deviceFaultReportMasked_ ) && VULKAN_HPP_NOEXCEPT + { + deviceFaultReportMasked = deviceFaultReportMasked_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR & setDeviceFaultDeviceLostOnMasked( Bool32 deviceFaultDeviceLostOnMasked_ ) & VULKAN_HPP_NOEXCEPT + { + deviceFaultDeviceLostOnMasked = deviceFaultDeviceLostOnMasked_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesKHR && setDeviceFaultDeviceLostOnMasked( Bool32 deviceFaultDeviceLostOnMasked_ ) && VULKAN_HPP_NOEXCEPT + { + deviceFaultDeviceLostOnMasked = deviceFaultDeviceLostOnMasked_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFaultFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultFeaturesKHR *() 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, deviceFault, deviceFaultVendorBinary, deviceFaultReportMasked, deviceFaultDeviceLostOnMasked ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFaultFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceFaultFeaturesKHR 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 ) && ( deviceFault == rhs.deviceFault ) && + ( deviceFaultVendorBinary == rhs.deviceFaultVendorBinary ) && ( deviceFaultReportMasked == rhs.deviceFaultReportMasked ) && + ( deviceFaultDeviceLostOnMasked == rhs.deviceFaultDeviceLostOnMasked ); +# endif + } + + bool operator!=( PhysicalDeviceFaultFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFaultFeaturesKHR; + void * pNext = {}; + Bool32 deviceFault = {}; + Bool32 deviceFaultVendorBinary = {}; + Bool32 deviceFaultReportMasked = {}; + Bool32 deviceFaultDeviceLostOnMasked = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFaultFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFaultFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceFaultPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFaultPropertiesKHR.html + struct PhysicalDeviceFaultPropertiesKHR + { + using NativeType = VkPhysicalDeviceFaultPropertiesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFaultPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFaultPropertiesKHR( uint32_t maxDeviceFaultCount_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxDeviceFaultCount{ maxDeviceFaultCount_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFaultPropertiesKHR( PhysicalDeviceFaultPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFaultPropertiesKHR( VkPhysicalDeviceFaultPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFaultPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFaultPropertiesKHR & operator=( PhysicalDeviceFaultPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFaultPropertiesKHR & operator=( VkPhysicalDeviceFaultPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFaultPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultPropertiesKHR *() 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, maxDeviceFaultCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFaultPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceFaultPropertiesKHR 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 ) && ( maxDeviceFaultCount == rhs.maxDeviceFaultCount ); +# endif + } + + bool operator!=( PhysicalDeviceFaultPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFaultPropertiesKHR; + void * pNext = {}; + uint32_t maxDeviceFaultCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFaultPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFaultPropertiesKHR; + }; + // wrapper struct for struct VkPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures2.html struct PhysicalDeviceFeatures2 { @@ -135842,6 +136438,252 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShader64BitIndexingFeaturesEXT; }; + // wrapper struct for struct VkPhysicalDeviceShaderAbortFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAbortFeaturesKHR.html + struct PhysicalDeviceShaderAbortFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderAbortFeaturesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAbortFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAbortFeaturesKHR( Bool32 shaderAbort_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderAbort{ shaderAbort_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAbortFeaturesKHR( PhysicalDeviceShaderAbortFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderAbortFeaturesKHR( VkPhysicalDeviceShaderAbortFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderAbortFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderAbortFeaturesKHR & operator=( PhysicalDeviceShaderAbortFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderAbortFeaturesKHR & operator=( VkPhysicalDeviceShaderAbortFeaturesKHR 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 PhysicalDeviceShaderAbortFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAbortFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAbortFeaturesKHR & setShaderAbort( Bool32 shaderAbort_ ) & VULKAN_HPP_NOEXCEPT + { + shaderAbort = shaderAbort_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAbortFeaturesKHR && setShaderAbort( Bool32 shaderAbort_ ) && VULKAN_HPP_NOEXCEPT + { + shaderAbort = shaderAbort_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderAbortFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAbortFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAbortFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAbortFeaturesKHR *() 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, shaderAbort ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderAbortFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderAbortFeaturesKHR 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 ) && ( shaderAbort == rhs.shaderAbort ); +# endif + } + + bool operator!=( PhysicalDeviceShaderAbortFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderAbortFeaturesKHR; + void * pNext = {}; + Bool32 shaderAbort = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAbortFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAbortFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderAbortPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAbortPropertiesKHR.html + struct PhysicalDeviceShaderAbortPropertiesKHR + { + using NativeType = VkPhysicalDeviceShaderAbortPropertiesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAbortPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAbortPropertiesKHR( uint64_t maxShaderAbortMessageSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxShaderAbortMessageSize{ maxShaderAbortMessageSize_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAbortPropertiesKHR( PhysicalDeviceShaderAbortPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderAbortPropertiesKHR( VkPhysicalDeviceShaderAbortPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderAbortPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderAbortPropertiesKHR & operator=( PhysicalDeviceShaderAbortPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderAbortPropertiesKHR & operator=( VkPhysicalDeviceShaderAbortPropertiesKHR 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 PhysicalDeviceShaderAbortPropertiesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAbortPropertiesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAbortPropertiesKHR & setMaxShaderAbortMessageSize( uint64_t maxShaderAbortMessageSize_ ) & VULKAN_HPP_NOEXCEPT + { + maxShaderAbortMessageSize = maxShaderAbortMessageSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAbortPropertiesKHR && setMaxShaderAbortMessageSize( uint64_t maxShaderAbortMessageSize_ ) && VULKAN_HPP_NOEXCEPT + { + maxShaderAbortMessageSize = maxShaderAbortMessageSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderAbortPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAbortPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAbortPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAbortPropertiesKHR *() 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, maxShaderAbortMessageSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderAbortPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderAbortPropertiesKHR 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 ) && ( maxShaderAbortMessageSize == rhs.maxShaderAbortMessageSize ); +# endif + } + + bool operator!=( PhysicalDeviceShaderAbortPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderAbortPropertiesKHR; + void * pNext = {}; + uint64_t maxShaderAbortMessageSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAbortPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAbortPropertiesKHR; + }; + // wrapper struct for struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.html struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV @@ -137102,6 +137944,129 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderClockFeaturesKHR; }; + // wrapper struct for struct VkPhysicalDeviceShaderConstantDataFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderConstantDataFeaturesKHR.html + struct PhysicalDeviceShaderConstantDataFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderConstantDataFeaturesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderConstantDataFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderConstantDataFeaturesKHR( Bool32 shaderConstantData_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderConstantData{ shaderConstantData_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderConstantDataFeaturesKHR( PhysicalDeviceShaderConstantDataFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderConstantDataFeaturesKHR( VkPhysicalDeviceShaderConstantDataFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderConstantDataFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderConstantDataFeaturesKHR & operator=( PhysicalDeviceShaderConstantDataFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderConstantDataFeaturesKHR & operator=( VkPhysicalDeviceShaderConstantDataFeaturesKHR 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 PhysicalDeviceShaderConstantDataFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderConstantDataFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderConstantDataFeaturesKHR & setShaderConstantData( Bool32 shaderConstantData_ ) & VULKAN_HPP_NOEXCEPT + { + shaderConstantData = shaderConstantData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderConstantDataFeaturesKHR && setShaderConstantData( Bool32 shaderConstantData_ ) && VULKAN_HPP_NOEXCEPT + { + shaderConstantData = shaderConstantData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderConstantDataFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderConstantDataFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderConstantDataFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderConstantDataFeaturesKHR *() 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, shaderConstantData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderConstantDataFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderConstantDataFeaturesKHR 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 ) && ( shaderConstantData == rhs.shaderConstantData ); +# endif + } + + bool operator!=( PhysicalDeviceShaderConstantDataFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderConstantDataFeaturesKHR; + void * pNext = {}; + Bool32 shaderConstantData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderConstantDataFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderConstantDataFeaturesKHR; + }; + // wrapper struct for struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.html struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index 4c6f0ca..c6e3242 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -4368,6 +4368,31 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return result; } + //=== VK_KHR_device_fault === + + VULKAN_HPP_INLINE std::string to_string( DeviceFaultFlagsKHR value ) + { + std::string result = "{"; + if ( value & DeviceFaultFlagBitsKHR::eFlagDeviceLost ) + result += " FlagDeviceLost |"; + if ( value & DeviceFaultFlagBitsKHR::eFlagMemoryAddress ) + result += " FlagMemoryAddress |"; + if ( value & DeviceFaultFlagBitsKHR::eFlagInstructionAddress ) + result += " FlagInstructionAddress |"; + if ( value & DeviceFaultFlagBitsKHR::eFlagVendor ) + result += " FlagVendor |"; + if ( value & DeviceFaultFlagBitsKHR::eFlagWatchdogTimeout ) + result += " FlagWatchdogTimeout |"; + if ( value & DeviceFaultFlagBitsKHR::eFlagOverflow ) + result += " FlagOverflow |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + //=== VK_KHR_maintenance8 === VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlags3KHR ) @@ -5139,6 +5164,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR : return "RenderingFragmentShadingRateAttachmentInfoKHR"; case StructureType::ePhysicalDeviceShaderCoreProperties2AMD : return "PhysicalDeviceShaderCoreProperties2AMD"; case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD : return "PhysicalDeviceCoherentMemoryFeaturesAMD"; + case StructureType::ePhysicalDeviceShaderConstantDataFeaturesKHR : return "PhysicalDeviceShaderConstantDataFeaturesKHR"; + case StructureType::ePhysicalDeviceShaderAbortFeaturesKHR : return "PhysicalDeviceShaderAbortFeaturesKHR"; + case StructureType::eDeviceFaultShaderAbortMessageInfoKHR : return "DeviceFaultShaderAbortMessageInfoKHR"; + case StructureType::ePhysicalDeviceShaderAbortPropertiesKHR : return "PhysicalDeviceShaderAbortPropertiesKHR"; case StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT : return "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT"; case StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR : return "PhysicalDeviceShaderQuadControlFeaturesKHR"; case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT"; @@ -5694,6 +5723,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::eIndirectExecutionSetShaderLayoutInfoEXT : return "IndirectExecutionSetShaderLayoutInfoEXT"; case StructureType::eGeneratedCommandsPipelineInfoEXT : return "GeneratedCommandsPipelineInfoEXT"; case StructureType::eGeneratedCommandsShaderInfoEXT : return "GeneratedCommandsShaderInfoEXT"; + case StructureType::ePhysicalDeviceFaultFeaturesKHR : return "PhysicalDeviceFaultFeaturesKHR"; + case StructureType::ePhysicalDeviceFaultPropertiesKHR : return "PhysicalDeviceFaultPropertiesKHR"; + case StructureType::eDeviceFaultInfoKHR : return "DeviceFaultInfoKHR"; + case StructureType::eDeviceFaultDebugInfoKHR : return "DeviceFaultDebugInfoKHR"; case StructureType::ePhysicalDeviceMaintenance8FeaturesKHR : return "PhysicalDeviceMaintenance8FeaturesKHR"; case StructureType::eMemoryBarrierAccessFlags3KHR : return "MemoryBarrierAccessFlags3KHR"; case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA : return "PhysicalDeviceImageAlignmentControlFeaturesMESA"; @@ -10041,32 +10074,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } - //=== VK_EXT_device_fault === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultAddressTypeEXT value ) - { - switch ( value ) - { - case DeviceFaultAddressTypeEXT::eNone : return "None"; - case DeviceFaultAddressTypeEXT::eReadInvalid : return "ReadInvalid"; - case DeviceFaultAddressTypeEXT::eWriteInvalid : return "WriteInvalid"; - case DeviceFaultAddressTypeEXT::eExecuteInvalid : return "ExecuteInvalid"; - case DeviceFaultAddressTypeEXT::eInstructionPointerUnknown: return "InstructionPointerUnknown"; - case DeviceFaultAddressTypeEXT::eInstructionPointerInvalid: return "InstructionPointerInvalid"; - case DeviceFaultAddressTypeEXT::eInstructionPointerFault : return "InstructionPointerFault"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultVendorBinaryHeaderVersionEXT value ) - { - switch ( value ) - { - case DeviceFaultVendorBinaryHeaderVersionEXT::eOne: return "One"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) //=== VK_EXT_directfb_surface === @@ -11079,6 +11086,46 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } + //=== VK_KHR_device_fault === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultAddressTypeKHR value ) + { + switch ( value ) + { + case DeviceFaultAddressTypeKHR::eNone : return "None"; + case DeviceFaultAddressTypeKHR::eReadInvalid : return "ReadInvalid"; + case DeviceFaultAddressTypeKHR::eWriteInvalid : return "WriteInvalid"; + case DeviceFaultAddressTypeKHR::eExecuteInvalid : return "ExecuteInvalid"; + case DeviceFaultAddressTypeKHR::eInstructionPointerUnknown: return "InstructionPointerUnknown"; + case DeviceFaultAddressTypeKHR::eInstructionPointerInvalid: return "InstructionPointerInvalid"; + case DeviceFaultAddressTypeKHR::eInstructionPointerFault : return "InstructionPointerFault"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultVendorBinaryHeaderVersionKHR value ) + { + switch ( value ) + { + case DeviceFaultVendorBinaryHeaderVersionKHR::eOne: return "One"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultFlagBitsKHR value ) + { + switch ( value ) + { + case DeviceFaultFlagBitsKHR::eFlagDeviceLost : return "FlagDeviceLost"; + case DeviceFaultFlagBitsKHR::eFlagMemoryAddress : return "FlagMemoryAddress"; + case DeviceFaultFlagBitsKHR::eFlagInstructionAddress: return "FlagInstructionAddress"; + case DeviceFaultFlagBitsKHR::eFlagVendor : return "FlagVendor"; + case DeviceFaultFlagBitsKHR::eFlagWatchdogTimeout : return "FlagWatchdogTimeout"; + case DeviceFaultFlagBitsKHR::eFlagOverflow : return "FlagOverflow"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + //=== VK_KHR_maintenance8 === VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits3KHR value )